diff --git a/TapSchemaManager/pom.xml b/TapSchemaManager/pom.xml index fb3f9ab00c3e8f7ad9ef35165d8c3010ddd014e2..12003b408e1f7f815ecbf3ff3ce6d184e5f87f21 100644 --- a/TapSchemaManager/pom.xml +++ b/TapSchemaManager/pom.xml @@ -29,7 +29,12 @@ it.inaf.oats.ia2 - TapSchemaModel + TapSchemaManagerDL + 1.0-SNAPSHOT + + + it.inaf.oats.ia2 + TapSchemaManagerBL 1.0-SNAPSHOT diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Column.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Column.java new file mode 100644 index 0000000000000000000000000000000000000000..727014b47bd9536b04b6dded19fa86c0d3c30e08 --- /dev/null +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Column.java @@ -0,0 +1,93 @@ +package it.inaf.oats.ia2.tapschemamanager.businesslayer; + +import it.inaf.oats.ia2.tapschemamanager.datalayer.ColumnEntity; + +/** + * + * @author Sonia Zorba + */ +public class Column extends EntityWrapper { + + public static final String UTYPE = "utype"; + public static final String UCD = "ucd"; + public static final String UNIT = "unit"; + public static final String DESCRIPTION = "description"; + public static final String STD = "std"; + public static final String PRINCIPAL = "principal"; + + private final String datatype; + private final int size; + private final boolean primaryKey; + private final boolean indexed; + + private boolean foreignKey; + + private boolean hidden; + + public Column(ColumnEntity columnEntity, boolean primaryKey) { + super(columnEntity, UTYPE, UCD, UNIT, DESCRIPTION, STD); + hidden = true; + this.primaryKey = primaryKey; + this.datatype = columnEntity.getDatatype(); + this.size = columnEntity.getSize(); + this.indexed = columnEntity.getIndexed() == 1; + + addValue(UTYPE, columnEntity.getUtype()); + addValue(UCD, columnEntity.getUcd()); + addValue(UNIT, columnEntity.getUnit()); + addValue(DESCRIPTION, columnEntity.getDescription()); + addValue(STD, columnEntity.getStd() + ""); + addValue(PRINCIPAL, columnEntity.getPrincipal() + ""); + } + + @Override + protected void afterSetValue(String key, String value) { + ColumnEntity columnEntity = getColumnEntity(); + if (key.equals(UTYPE)) { + columnEntity.setUtype(value); + } else if (key.equals(UCD)) { + columnEntity.setUcd(value); + } else if (key.equals(UNIT)) { + columnEntity.setUnit(value); + } else if (key.equals(DESCRIPTION)) { + columnEntity.setDescription(value); + } else if (key.equals(STD)) { + columnEntity.setStd(Integer.parseInt(value)); + } + } + + protected ColumnEntity getColumnEntity() { + return (ColumnEntity) getEntity(); + } + + public boolean isHidden() { + return hidden; + } + + public void setHidden(boolean hidden) { + this.hidden = hidden; + if (hidden) { + undoChanges(); + } + } + + public String getDatatype() { + return datatype; + } + + public int getSize() { + return size; + } + + public boolean isPrimaryKey() { + return primaryKey; + } + + public boolean isForeignKey() { + return foreignKey; + } + + public boolean isIndexed() { + return indexed; + } +} diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/EntityWrapper.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/EntityWrapper.java new file mode 100644 index 0000000000000000000000000000000000000000..3b5fd50fb8adfc61680e74079afb09c67cda92b6 --- /dev/null +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/EntityWrapper.java @@ -0,0 +1,103 @@ +package it.inaf.oats.ia2.tapschemamanager.businesslayer; + +import it.inaf.oats.ia2.tapschemamanager.datalayer.TapSchemaEntity; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * + * @author Sonia Zorba + */ +public abstract class EntityWrapper { + + private final TapSchemaEntity entity; + private final Map originalValues; + private final Map editedValues; + private final List supportedKeys; + private Status status; + + public EntityWrapper(TapSchemaEntity entity, String... supportedKeys) { + this.entity = entity; + this.supportedKeys = Arrays.asList(supportedKeys); + originalValues = new HashMap(); + editedValues = new HashMap(); + } + + public List getSupportedKeys() { + return supportedKeys; + } + + protected final void addValue(String key, String value) { + originalValues.put(key, value); + } + + public final String getValue(String key) { + String editedValue = editedValues.get(key); + if (editedValue != null) { + return editedValue; + } + return originalValues.get(key); + } + + protected abstract void afterSetValue(String key, String value); + + public final void setValue(String key, String value) { + if (originalValues.get(key) == null && value.equals("")) { + value = null; + } + editedValues.put(key, value); + afterSetValue(key, value); + } + + public final boolean isChanged(String key) { + String originalValue = originalValues.get(key); + String editedValue = editedValues.get(key); + if (originalValue == null) { + return editedValue != null; + } else { + if (editedValue != null && !originalValue.equals(editedValue)) { + return true; + } + } + return false; + } + + public final boolean isChanged() { + for (String key : editedValues.keySet()) { + if (isChanged(key)) { + return true; + } + } + return false; + } + + public Status getStatus() { + return status; + } + + public void setStatus(Status status) { + this.status = status; + } + + public TapSchemaEntity getEntity() { + return entity; + } + + public String getName() { + return entity.getName(); + } + + protected void setPersisted() { + setStatus(Status.ADDED_PERSISTED); + for (String key : editedValues.keySet()) { + originalValues.put(key, editedValues.get(key)); + } + editedValues.clear(); + } + + protected void undoChanges() { + editedValues.clear(); + } +} diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/EntityWrapperContainer.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/EntityWrapperContainer.java new file mode 100644 index 0000000000000000000000000000000000000000..750db8c2f706ebe80e13c105e11c6b4587489228 --- /dev/null +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/EntityWrapperContainer.java @@ -0,0 +1,25 @@ +package it.inaf.oats.ia2.tapschemamanager.businesslayer; + +import java.sql.SQLException; +import java.util.List; + +/** + * + * @author Sonia Zorba + */ +public interface EntityWrapperContainer { + + public EntityWrapper getSelectedEntity(); + + public void selectEntity(String entityName); + + public List getAddables(); + + public List getAllEntityWrappers(); + + public void addEntityWrapper(String name) throws SQLException; + + public void removeEntityWrapper(String name); + + public boolean hasChildren(); +} diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Schema.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Schema.java new file mode 100644 index 0000000000000000000000000000000000000000..ccc57636ec250c36887545b5ecb7381a785654b4 --- /dev/null +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Schema.java @@ -0,0 +1,152 @@ +package it.inaf.oats.ia2.tapschemamanager.businesslayer; + +import it.inaf.oats.ia2.tapschemamanager.datalayer.SchemaEntity; +import it.inaf.oats.ia2.tapschemamanager.datalayer.TableEntity; +import it.inaf.oats.ia2.tapschemamanager.datalayer.TapSchemaHandler; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +/** + * + * @author Sonia Zorba + */ +public class Schema extends EntityWrapper implements EntityWrapperContainer { + + public static final String UTYPE = "utype"; + public static final String DESCRIPTION = "description"; + + private final TapSchemaHandler tapSchemaHandler; + + private String selectedTable; + private final Map tables; + +// public Schema(TapSchemaHandler tapSchemaHandler, String schemaName) throws SQLException { +// this(tapSchemaHandler, tapSchemaHandler.getNewSchema(schemaName)); +// setStatus(Status.ADDED_NOT_PERSISTED); +// } + public Schema(TapSchemaHandler tapSchemaHandler, SchemaEntity schemaEntity) throws SQLException { + super(schemaEntity, UTYPE, DESCRIPTION); + + this.tapSchemaHandler = tapSchemaHandler; + + addValue(UTYPE, schemaEntity.getUtype()); + addValue(DESCRIPTION, schemaEntity.getDescription()); + + tables = new HashMap(); + + for (TableEntity tableEntity : schemaEntity.getTables().values()) { + String tableName = tableEntity.getTableName(); + tables.put(tableName, new Table(tapSchemaHandler, getName(), tableName, tableEntity)); + } + + setStatus(Status.ADDED_PERSISTED); + } + + @Override + protected void afterSetValue(String key, String value) { + SchemaEntity schemaEntity = getSchemaEntity(); + if (key.equals(UTYPE)) { + schemaEntity.setUtype(value); + } else if (key.equals(DESCRIPTION)) { + schemaEntity.setDescription(value); + } + } + + public List getTablesNames() { + return Util.setToList(tables.keySet()); + } + + @Override + public List getAddables() { + return Util.getAddables(tapSchemaHandler.getAllTables(getName()), tables.keySet()); + } + + @Override + public void addEntityWrapper(String name) throws SQLException { + Table table = tables.get(name); + if (table == null) { + // Add new + TableEntity tableEntity = tapSchemaHandler.getNewTable(getName(), name); + table = new Table(tapSchemaHandler, getName(), name, tableEntity); + tables.put(name, table); + table.setStatus(Status.ADDED_NOT_PERSISTED); + } else { + // Undo remove + table.setStatus(Status.ADDED_PERSISTED); + } + selectedTable = name; + + getSchemaEntity().addTable((TableEntity) table.getEntity()); + } + + @Override + public void removeEntityWrapper(String name) { + Table table = tables.get(name); + if (table.getStatus() == Status.ADDED_NOT_PERSISTED) { + tables.remove(name); + } else { + table.setStatus(Status.TO_REMOVE); + } + selectedTable = tables.isEmpty() ? null : tables.keySet().iterator().next(); + + getSchemaEntity().getTables().remove(table.getFullName()); + } + + public Table getTable(String name) { + return tables.get(name); + } + + protected SchemaEntity getSchemaEntity() { + return (SchemaEntity) getEntity(); + } + + @Override + protected void setPersisted() { + super.setPersisted(); + Iterator iterator = tables.values().iterator(); + while (iterator.hasNext()) { + Table table = iterator.next(); + if (table.getStatus() == Status.TO_REMOVE) { + iterator.remove(); + } else { + table.setPersisted(); + } + } + } + + @Override + public boolean hasChildren() { + return !tables.isEmpty(); + } + + @Override + public List getAllEntityWrappers() { + return new ArrayList(tables.values()); + } + + public Table getSelectedTable() { + return selectedTable == null ? null : tables.get(selectedTable); + } + + @Override + public void selectEntity(String entityName) { + selectedTable = entityName; + Table table = tables.get(entityName); + List columns = table.getColumnsNames(); + if (!columns.isEmpty()) { + table.selectEntity(columns.get(0)); + } + } + + @Override + public EntityWrapper getSelectedEntity() { + if (selectedTable == null) { + return null; + } + return tables.get(selectedTable); + } +} diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Status.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Status.java new file mode 100644 index 0000000000000000000000000000000000000000..509a0b849a29345dad3cb4571cadc199af4e77db --- /dev/null +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Status.java @@ -0,0 +1,11 @@ +package it.inaf.oats.ia2.tapschemamanager.businesslayer; + +/** + * + * @author Sonia Zorba + */ +public enum Status { + ADDED_PERSISTED, + ADDED_NOT_PERSISTED, + TO_REMOVE +} diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Table.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Table.java new file mode 100644 index 0000000000000000000000000000000000000000..c33dfba91586b652a2693e7a1a8c29d89aabe6fc --- /dev/null +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Table.java @@ -0,0 +1,194 @@ +package it.inaf.oats.ia2.tapschemamanager.businesslayer; + +import it.inaf.oats.ia2.tapschemamanager.datalayer.ColumnEntity; +import it.inaf.oats.ia2.tapschemamanager.datalayer.ColumnInfo; +import it.inaf.oats.ia2.tapschemamanager.datalayer.TableEntity; +import it.inaf.oats.ia2.tapschemamanager.datalayer.TapSchemaHandler; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * + * @author Sonia Zorba + */ +public class Table extends EntityWrapper implements EntityWrapperContainer { + + public static final String UTYPE = "utype"; + public static final String DESCRIPTION = "description"; + + private String selectedColumn; + private final Map columns; + + private final String schemaName; + private final String tableName; + +// public Table(TapSchemaHandler tapSchemaHandler, String schemaName, String tableName) throws SQLException { +// this(tapSchemaHandler, schemaName, tableName, new TableEntity(schemaName + "." + tableName)); +// setStatus(Status.ADDED_NOT_PERSISTED); +// } + public Table(TapSchemaHandler tapSchemaHandler, String schemaName, String tableName, TableEntity tableEntity) throws SQLException { + super(tableEntity, UTYPE, DESCRIPTION); + + addValue(UTYPE, tableEntity.getUtype()); + addValue(DESCRIPTION, tableEntity.getDescription()); + + this.schemaName = schemaName; + this.tableName = tableName; + + // Load all ColumnEntity map + columns = new HashMap(); + Set alreadyLoadedColumns = tableEntity.getColumns().keySet(); + for (ColumnInfo columnInfo : tapSchemaHandler.getColumnInfo(schemaName, tableName)) { + ColumnEntity columnEntity = columnInfo.getColumnEntity(); + Column column = new Column(columnEntity, columnInfo.isPrimaryKey()); + columns.put(columnEntity.getName(), column); + + if (alreadyLoadedColumns.contains(columnEntity.getName())) { + column.setHidden(false); + column.setStatus(Status.ADDED_PERSISTED); + } + } + + // Load foreign keys constraints + // TODO ... + setStatus(Status.ADDED_PERSISTED); + } + + @Override + protected void afterSetValue(String key, String value) { + TableEntity tableEntity = getTableEntity(); + if (key.equals(UTYPE)) { + tableEntity.setUtype(value); + } else if (key.equals(DESCRIPTION)) { + tableEntity.setDescription(value); + } + } + + protected TableEntity getTableEntity() { + return (TableEntity) getEntity(); + } + + @Override + public List getAddables() { + List addables = new ArrayList(); + for (Column column : columns.values()) { + if (column.isHidden()) { + addables.add(column.getName()); + } + } + return addables; + } + + @Override + public void addEntityWrapper(String name) throws SQLException { + Column column = columns.get(name); + if (column.isHidden()) { + // Add new + column.setStatus(Status.ADDED_NOT_PERSISTED); + column.setHidden(false); + } else { + // Undo remove + column.setStatus(Status.ADDED_PERSISTED); + } + selectedColumn = name; + + getTableEntity().addColumn(column.getColumnEntity()); + } + + @Override + public void removeEntityWrapper(String name) { + Column column = columns.get(name); + + if (column.getStatus() == Status.ADDED_NOT_PERSISTED) { + column.setHidden(true); + } else { + column.setStatus(Status.TO_REMOVE); + } + List visibleColumns = getColumnsNames(); + selectedColumn = visibleColumns.isEmpty() ? null : visibleColumns.get(0); + + column.setStatus(Status.ADDED_NOT_PERSISTED); + getTableEntity().addColumn(column.getColumnEntity()); + } + + public Column getColumn(String name) { + return columns.get(name); + } + + public List getColumnsNames() { + List columnsNames = new ArrayList(); + for (Column column : columns.values()) { + if (!column.isHidden()) { + columnsNames.add(column.getName()); + } + } + return columnsNames; + } + + @Override + protected void setPersisted() { + super.setPersisted(); + for (Column column : columns.values()) { + if (column.getStatus() == Status.TO_REMOVE) { + column.setHidden(true); + } else { + column.setPersisted(); + } + } + } + + @Override + public boolean hasChildren() { + for (Column column : columns.values()) { + if (!column.isHidden()) { + return true; + } + } + return false; + } + + @Override + public List getAllEntityWrappers() { + List list = new ArrayList(); + for (Column column : columns.values()) { + if (!column.isHidden()) { + list.add(column); + } + } + return list; + } + + public Column getSelectedColumn() { + return selectedColumn == null ? null : columns.get(selectedColumn); + } + + @Override + public void selectEntity(String entityName) { + selectedColumn = entityName; + } + + public String getSchemaName() { + return schemaName; + } + + public String getFullName() { + return getEntity().getName(); + } + + @Override + public String getName() { + return tableName; + } + + @Override + public EntityWrapper getSelectedEntity() { + if (selectedColumn == null) { + return null; + } + return columns.get(selectedColumn); + } +} diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/TapSchema.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/TapSchema.java new file mode 100644 index 0000000000000000000000000000000000000000..3783c7751cb6c98fbdb0f2a74e1c5c0ccb7201aa --- /dev/null +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/TapSchema.java @@ -0,0 +1,148 @@ +package it.inaf.oats.ia2.tapschemamanager.businesslayer; + +import it.inaf.oats.ia2.tapschemamanager.datalayer.Credentials; +import it.inaf.oats.ia2.tapschemamanager.datalayer.SchemaEntity; +import it.inaf.oats.ia2.tapschemamanager.datalayer.TapSchemaHandler; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +/** + * + * @author Sonia Zorba + */ +public class TapSchema implements EntityWrapperContainer { + + private final TapSchemaHandler tapSchemaHandler; + + private final String name; + + private String selectedSchema; + private final Map schemas; + + public TapSchema(Credentials credentials, String tapSchemaName, boolean exists) throws SQLException { + this.name = tapSchemaName; + schemas = new HashMap(); + + this.tapSchemaHandler = new TapSchemaHandler(credentials, tapSchemaName, exists); + + if (exists) { + for (SchemaEntity schemaEntity : tapSchemaHandler.getSchemas()) { + Schema schema = new Schema(tapSchemaHandler, schemaEntity); + schemas.put(schema.getName(), schema); + } + if (!schemas.isEmpty()) { + selectEntity(schemas.keySet().iterator().next()); // select first schema + } + } + } + + @Override + public List getAddables() { + return Util.getAddables(tapSchemaHandler.getAllSchemas(), schemas.keySet()); + } + + @Override + public void addEntityWrapper(String name) throws SQLException { + Schema schema = schemas.get(name); + SchemaEntity schemaEntity; + if (schema == null) { + // Add new + schemaEntity = tapSchemaHandler.getNewSchema(name); + schema = new Schema(tapSchemaHandler, schemaEntity); + schemas.put(name, schema); + schema.setStatus(Status.ADDED_NOT_PERSISTED); + } else { + schemaEntity = schema.getSchemaEntity(); + // Undo remove + schema.setStatus(Status.ADDED_PERSISTED); + } + selectedSchema = name; + + tapSchemaHandler.addSchema(schemaEntity); + } + + @Override + public void removeEntityWrapper(String name) { + Schema schema = schemas.get(name); + if (schema.getStatus() == Status.ADDED_NOT_PERSISTED) { + schemas.remove(name); + } else { + schema.setStatus(Status.TO_REMOVE); + } + selectedSchema = schemas.isEmpty() ? null : schemas.keySet().iterator().next(); + + tapSchemaHandler.removeSchema(name); + } + + public Schema getSchema(String name) { + return schemas.get(name); + } + + public List getSchemasNames() { + return Util.setToList(schemas.keySet()); + } + + public String getName() { + return name; + } + + public void save() throws SQLException { + tapSchemaHandler.save(); + + Iterator iterator = schemas.values().iterator(); + while (iterator.hasNext()) { + Schema schema = iterator.next(); + if (schema.getStatus() == Status.TO_REMOVE) { + iterator.remove(); + } else { + schema.setPersisted(); + } + } + } + + public Schema getSelectedSchema() { + return selectedSchema == null ? null : schemas.get(selectedSchema); + } + + public Table getSelectedTable() { + Schema schema = getSelectedSchema(); + return schema == null ? null : schema.getSelectedTable(); + } + + public Column getSelectedColumn() { + Table table = getSelectedTable(); + return table == null ? null : table.getSelectedColumn(); + } + + @Override + public final void selectEntity(String entityName) { + selectedSchema = entityName; + Schema schema = schemas.get(entityName); + List tables = schema.getTablesNames(); + if (!tables.isEmpty()) { + schema.selectEntity(tables.get(0)); + } + } + + @Override + public boolean hasChildren() { + return !schemas.isEmpty(); + } + + @Override + public List getAllEntityWrappers() { + return new ArrayList(schemas.values()); + } + + @Override + public EntityWrapper getSelectedEntity() { + if (selectedSchema == null) { + return null; + } + return schemas.get(selectedSchema); + } +} diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Util.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Util.java new file mode 100644 index 0000000000000000000000000000000000000000..56b6cd5885e429b45f9e3655bb1616953e3843d9 --- /dev/null +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Util.java @@ -0,0 +1,29 @@ +package it.inaf.oats.ia2.tapschemamanager.businesslayer; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Set; + +/** + * + * @author Sonia Zorba + */ +class Util { + + protected static List getAddables(List allElements, Set addedElements) { + List addables = new ArrayList(); + for (String elementName : allElements) { + if (!addedElements.contains(elementName)) { + addables.add(elementName); + } + } + return addables; + } + + protected static List setToList(Set set) { + List list = new ArrayList(); + list.addAll(set); + return list; + } +} diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/ApplicationConfig.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/ApplicationConfig.java similarity index 85% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/ApplicationConfig.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/ApplicationConfig.java index 3a1872d8654e6a8873c7d096cdcb626be2a280f9..1943e095c61431a8927f59ced09fb9928bd0d163 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/ApplicationConfig.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/ApplicationConfig.java @@ -1,4 +1,4 @@ -package it.inaf.oats.ia2.tapschemamanager; +package it.inaf.oats.ia2.tapschemamanager.webapp; import java.util.HashSet; import java.util.Set; @@ -25,7 +25,7 @@ public class ApplicationConfig extends Application { * out calling this method in getClasses(). */ private void addRestResourceClasses(Set> resources) { - resources.add(it.inaf.oats.ia2.tapschemamanager.TapSchemaResource.class); + resources.add(it.inaf.oats.ia2.tapschemamanager.webapp.TapSchemaResource.class); } } diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/ApplicationManager.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/ApplicationManager.java similarity index 75% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/ApplicationManager.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/ApplicationManager.java index 01ff5b5f89dd84262c348bd5f5c76bca11dabfef..e103b912ad633e105023e328db160e05fe022446 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/ApplicationManager.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/ApplicationManager.java @@ -1,17 +1,13 @@ -package it.inaf.oats.ia2.tapschemamanager; +package it.inaf.oats.ia2.tapschemamanager.webapp; -import it.inaf.oats.ia2.tapschemamanager.ApplicationManagerLocal; -import it.inaf.oats.ia2.tapschemamanager.TSMPages; -import it.inaf.oats.ia2.tapschemamodel.Credentials; -import javax.annotation.PostConstruct; -import javax.ejb.Stateful; +import it.inaf.oats.ia2.tapschemamanager.datalayer.Credentials; /** * * @author Sonia Zorba */ -@Stateful -public class ApplicationManager implements ApplicationManagerLocal { +//@Stateful +public class ApplicationManager {// implements ApplicationManagerLocal { String currentPage; @@ -21,8 +17,11 @@ public class ApplicationManager implements ApplicationManagerLocal { private SelectTapSchemaModel selectTapSchemaModel; private EditTapSchemaPageState editTapSchemaPageState; - @PostConstruct - public void init() { + public ApplicationManager() { + init(); + } + + private void init() { credentials = new Credentials(); currentPage = TSMPages.CREDENTIALS; isLoggedIn = false; @@ -30,43 +29,35 @@ public class ApplicationManager implements ApplicationManagerLocal { editTapSchemaPageState = null; } - @Override public boolean isLoggedIn() { return isLoggedIn; } - @Override public Credentials getCredentials() { return this.credentials; } - @Override public SelectTapSchemaModel getSelectTapSchema() { return this.selectTapSchemaModel; } - @Override public void setSelectTapSchemaModel(SelectTapSchemaModel selectTapSchemaModel) { this.selectTapSchemaModel = selectTapSchemaModel; this.isLoggedIn = true; } - @Override public EditTapSchemaPageState getEditTapSchemaPageState() { return this.editTapSchemaPageState; } - @Override public void setEditTapSchemaPageState(EditTapSchemaPageState editTapSchemaPageState) { this.editTapSchemaPageState = editTapSchemaPageState; } - @Override public String getCurrentPage() { return this.currentPage; } - @Override public void setCurrentPage(String pageName) { this.currentPage = pageName; diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/ApplicationManagerLocal.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/ApplicationManagerLocal.java similarity index 81% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/ApplicationManagerLocal.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/ApplicationManagerLocal.java index 42f3af3104dfeaf6af1c115a1e6a49aeef70b63f..da1f86f0531221505508506ce99816351f581d84 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/ApplicationManagerLocal.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/ApplicationManagerLocal.java @@ -1,13 +1,13 @@ -package it.inaf.oats.ia2.tapschemamanager; +package it.inaf.oats.ia2.tapschemamanager.webapp; -import it.inaf.oats.ia2.tapschemamodel.Credentials; +import it.inaf.oats.ia2.tapschemamanager.datalayer.Credentials; import javax.ejb.Local; /** * * @author Sonia Zorba */ -@Local +//@Local public interface ApplicationManagerLocal { Credentials getCredentials(); diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/EditTapSchemaPageModel.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/EditTapSchemaPageModel.java similarity index 55% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/EditTapSchemaPageModel.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/EditTapSchemaPageModel.java index 9398f7832ba368566a417bd770ad69abfe459a33..9acf23c38aadc8385a2bf82a3fd3a7669f99dc62 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/EditTapSchemaPageModel.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/EditTapSchemaPageModel.java @@ -1,6 +1,12 @@ -package it.inaf.oats.ia2.tapschemamanager; - -import it.inaf.oats.ia2.tapschemamodel.*; +package it.inaf.oats.ia2.tapschemamanager.webapp; + +import it.inaf.oats.ia2.tapschemamanager.businesslayer.Column; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.EntityWrapper; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.EntityWrapperContainer; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.Schema; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.Status; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.Table; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.TapSchema; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -17,7 +23,7 @@ public class EditTapSchemaPageModel { boolean toRemove; Map values; - Entity(DbEntity dbEntity) { + Entity(EntityWrapper dbEntity) { toRemove = dbEntity.getStatus() == Status.TO_REMOVE; values = getEditablesFields(dbEntity); } @@ -28,9 +34,9 @@ public class EditTapSchemaPageModel { Object value; boolean isChanged; - EditableField(String key, DbEntity container) { - this.value = container.getValue(key); - this.isChanged = container.isChanged(key); + EditableField(String key, EntityWrapper entityWrapper) { + this.value = entityWrapper.getValue(key); + this.isChanged = entityWrapper.isChanged(key); } } @@ -40,9 +46,9 @@ public class EditTapSchemaPageModel { private final boolean toRemove; private final boolean active; - public EntityItem(DbEntity dbEntity, boolean active) { - this.title = dbEntity.getName(); - this.toRemove = dbEntity.getStatus() == Status.TO_REMOVE; + public EntityItem(EntityWrapper entityWrapper, boolean active) { + this.title = entityWrapper.getName(); + this.toRemove = entityWrapper.getStatus() == Status.TO_REMOVE; this.active = active; } } @@ -62,7 +68,7 @@ public class EditTapSchemaPageModel { super(schema); if (schema != null) { hasAddables = !schema.getAddables().isEmpty(); - hasChildren = !schema.getAllEntities().isEmpty(); + hasChildren = !schema.hasChildren(); } } } @@ -76,7 +82,7 @@ public class EditTapSchemaPageModel { super(table); if (table != null) { hasAddables = !table.getAddables().isEmpty(); - hasChildren = !table.getAllEntities().isEmpty(); + hasChildren = !table.hasChildren(); } } } @@ -108,46 +114,50 @@ public class EditTapSchemaPageModel { List tables; List columns; - public EditTapSchemaPageModel(TapSchema tapSchema) { + private transient EditTapSchemaPageState pageState; + + public EditTapSchemaPageModel(EditTapSchemaPageState pageState) { + + TapSchema ts = pageState.getTapSchema(); - Schema selectedSchema = tapSchema.getSelectedSchema(); - Table selectedTable = tapSchema.getSelectedTable(); - Column selectedColumn = tapSchema.getSelectedColumn(); + Schema selectedSchema = ts.getSelectedSchema(); + Table selectedTable = ts.getSelectedTable(); + Column selectedColumn = ts.getSelectedColumn(); this.tapSchema = new TapSchemaModel(); - this.tapSchema.hasAddables = !tapSchema.getAddables().isEmpty(); - this.tapSchema.hasChildren = !tapSchema.getAllEntities().isEmpty(); + this.tapSchema.hasAddables = !ts.getAddables().isEmpty(); + this.tapSchema.hasChildren = !ts.getAllEntityWrappers().isEmpty(); - schemas = getAllEntities(tapSchema); - tables = getAllEntities(selectedSchema); - columns = getAllEntities(selectedTable); + schemas = getAllEntities(ts, selectedSchema); + tables = getAllEntities(selectedSchema, selectedTable); + columns = getAllEntities(selectedTable, selectedColumn); schema = selectedSchema == null ? null : new SchemaModel(selectedSchema); table = selectedTable == null ? null : new TableModel(selectedTable); column = selectedColumn == null ? null : new ColumnModel(selectedColumn); } - private List getAllEntities(IDbEntitiesContainer container) { + private List getAllEntities(EntityWrapperContainer container, EntityWrapper selectedEntityWrapper) { if (container == null) { return null; } ArrayList entities = new ArrayList(); - String selectedEntity = container.getSelected() == null ? null : container.getSelected().getName(); - for (DbEntity entity : container.getAllEntities()) { - entities.add(new EntityItem(entity, entity.getName().equals(selectedEntity))); + String selectedName = selectedEntityWrapper == null ? null : selectedEntityWrapper.getName(); + for (EntityWrapper entityWrapper : container.getAllEntityWrappers()) { + entities.add(new EntityItem(entityWrapper, entityWrapper.getName().equals(selectedName))); } return entities; } - private Map getEditablesFields(DbEntity entity) { - if (entity == null) { + private Map getEditablesFields(EntityWrapper entityWrapper) { + if (entityWrapper == null) { return null; } - HashMap fields = new HashMap(); - for (String key : entity.getSupportedValues()) { - fields.put(key, new EditableField(key, entity)); + Map fields = new HashMap(); + for (String key : entityWrapper.getSupportedKeys()) { + fields.put(key, new EditableField(key, entityWrapper)); } return fields; } diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/EditTapSchemaPageState.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/EditTapSchemaPageState.java similarity index 84% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/EditTapSchemaPageState.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/EditTapSchemaPageState.java index f06c2f5d834a635cc1df1ae96f53cde47a2f9a6a..3a8933398409c204ce159f7c61a5e4d896204ea9 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/EditTapSchemaPageState.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/EditTapSchemaPageState.java @@ -1,9 +1,8 @@ -package it.inaf.oats.ia2.tapschemamanager; +package it.inaf.oats.ia2.tapschemamanager.webapp; -import it.inaf.oats.ia2.tapschemamanager.EditTapSchemaPageModel; import com.google.gson.Gson; import com.google.gson.GsonBuilder; -import it.inaf.oats.ia2.tapschemamodel.TapSchema; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.TapSchema; /** * @@ -25,11 +24,11 @@ public class EditTapSchemaPageState { public void setPreviousModel(EditTapSchemaPageModel pageModel) { this.previousModel = pageModel; } - + public EditTapSchemaPageModel getPreviousModel() { return previousModel; } - + public TapSchema getTapSchema() { return tapSchema; } diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/InsertCredentialsModel.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/InsertCredentialsModel.java similarity index 88% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/InsertCredentialsModel.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/InsertCredentialsModel.java index 19f9f65f6825a330b853abe10529f3591acdaa57..f9c36912c866edd7c4ed5421921892da81ade60f 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/InsertCredentialsModel.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/InsertCredentialsModel.java @@ -1,6 +1,6 @@ -package it.inaf.oats.ia2.tapschemamanager; +package it.inaf.oats.ia2.tapschemamanager.webapp; -import it.inaf.oats.ia2.tapschemamodel.Credentials; +import it.inaf.oats.ia2.tapschemamanager.datalayer.Credentials; import java.util.ArrayList; import java.util.List; diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/SearchUCDDialog.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/SearchUCDDialog.java similarity index 98% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/SearchUCDDialog.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/SearchUCDDialog.java index 817c68e063c2444b1a25e751f77bd6b8e37959c6..c21a4f76f88c76255aec2b13659b9488fc3a2a77 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/SearchUCDDialog.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/SearchUCDDialog.java @@ -1,4 +1,4 @@ -package it.inaf.oats.ia2.tapschemamanager; +package it.inaf.oats.ia2.tapschemamanager.webapp; import java.io.BufferedReader; import java.io.InputStreamReader; diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/SelectTapSchemaModel.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/SelectTapSchemaModel.java similarity index 76% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/SelectTapSchemaModel.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/SelectTapSchemaModel.java index 0d5a03af8c6a19f6a7b28857fb64305082525ecb..792acc057e64643e007d30046b069a3f3639884e 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/SelectTapSchemaModel.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/SelectTapSchemaModel.java @@ -1,6 +1,6 @@ -package it.inaf.oats.ia2.tapschemamanager; +package it.inaf.oats.ia2.tapschemamanager.webapp; -import it.inaf.oats.ia2.tapschemamodel.TapSchemaDL; +import it.inaf.oats.ia2.tapschemamanager.datalayer.DataProvider; import java.sql.Connection; import java.sql.SQLException; import java.util.List; @@ -16,8 +16,8 @@ public class SelectTapSchemaModel { private String exposedSchemas = ""; public SelectTapSchemaModel(Connection connection) throws SQLException { - allSchemas = TapSchemaDL.getAllSchemasNames(connection); - allTAPSchemas = TapSchemaDL.getAllTAPSchemasNames(connection, allSchemas); + allSchemas = DataProvider.getAllSchemasNames(connection); + allTAPSchemas = DataProvider.getAllTAPSchemasNames(connection, allSchemas); if (!allTAPSchemas.isEmpty()) { loadExposedSchemas(connection, allTAPSchemas.get(0)); @@ -26,7 +26,7 @@ public class SelectTapSchemaModel { } public final void loadExposedSchemas(Connection connection, String tapSchemaName) throws SQLException { - List schemas = TapSchemaDL.getExposedSchemas(connection, tapSchemaName); + List schemas = DataProvider.getExposedSchemas(connection, tapSchemaName); exposedSchemas = ""; for (int i = 0; i < schemas.size(); i++) { exposedSchemas += schemas.get(i); diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/TSMPages.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/TSMPages.java similarity index 81% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/TSMPages.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/TSMPages.java index ae67e7e615b88454ed581600331ad672e8afd022..c13bdce9a8ae63fb247059f885411f6b0fbfd6e7 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/TSMPages.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/TSMPages.java @@ -1,4 +1,4 @@ -package it.inaf.oats.ia2.tapschemamanager; +package it.inaf.oats.ia2.tapschemamanager.webapp; /** * diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/TSMServlet.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/TSMServlet.java similarity index 78% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/TSMServlet.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/TSMServlet.java index 109463f1e53e12e50bd96ff7ad200878331495e5..0f68eadb5aee8a41e82c20c8e1140e509d714f88 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/TSMServlet.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/TSMServlet.java @@ -1,13 +1,11 @@ -package it.inaf.oats.ia2.tapschemamanager; +package it.inaf.oats.ia2.tapschemamanager.webapp; -import it.inaf.oats.ia2.tapschemamodel.TapSchema; -import it.inaf.oats.ia2.tapschemamodel.Credentials; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.TapSchema; +import it.inaf.oats.ia2.tapschemamanager.datalayer.Credentials; import java.io.IOException; -import java.sql.Connection; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; -import javax.ejb.EJB; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; @@ -21,13 +19,24 @@ import javax.servlet.http.HttpServletResponse; @WebServlet(name = "TSMServlet", urlPatterns = {"/" + TSMPages.CREDENTIALS, "/" + TSMPages.SELECT_SCHEMA, "/" + TSMPages.EDIT_SCHEMA}) public class TSMServlet extends HttpServlet { - @EJB - private ApplicationManagerLocal applicationManager; + private ApplicationManager getApplicationManager(HttpServletRequest request) { + Object appManagerObj = request.getSession().getAttribute("applicationManager"); + ApplicationManager applicationManager; + if (appManagerObj == null) { + applicationManager = new ApplicationManager(); + request.getSession().setAttribute("applicationManager", applicationManager); + } else { + applicationManager = (ApplicationManager) appManagerObj; + } + return applicationManager; + } @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { + ApplicationManager applicationManager = getApplicationManager(request); + String path = request.getRequestURI().substring(request.getContextPath().length()); if (!applicationManager.isLoggedIn() && !path.startsWith("/" + TSMPages.CREDENTIALS)) { @@ -52,15 +61,14 @@ public class TSMServlet extends HttpServlet { protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { + ApplicationManager applicationManager = getApplicationManager(request); + String path = request.getRequestURI().substring(request.getContextPath().length()); if (path.startsWith("/" + TSMPages.CREDENTIALS)) { processInsertCredentials(request, response); } else if (path.startsWith("/" + TSMPages.SELECT_SCHEMA)) { - Connection connection = null; try { - connection = applicationManager.getCredentials().getConnection(); - TapSchema tapSchema; if (request.getParameter("tapschemaRadioGroup").equals("create")) { String tapSchemaName = request.getParameter("tapschemaName"); @@ -69,24 +77,22 @@ public class TSMServlet extends HttpServlet { if (selectedSchemasParam != null) { selectedSchemas.addAll(Arrays.asList(selectedSchemasParam)); } - tapSchema = new TapSchema(connection, tapSchemaName, selectedSchemas); + tapSchema = new TapSchema(applicationManager.getCredentials(), tapSchemaName, false); + for (String selectedSchema : selectedSchemas) { + tapSchema.addEntityWrapper(selectedSchema); + } + //tapSchema.closeConnection(); } else { String tapSchemaName = request.getParameter("tapschemaDropDownChoice"); - tapSchema = new TapSchema(connection, tapSchemaName); + tapSchema = new TapSchema(applicationManager.getCredentials(), tapSchemaName, true); } - applicationManager.setEditTapSchemaPageState(new EditTapSchemaPageState(tapSchema)); + EditTapSchemaPageState pageState = new EditTapSchemaPageState(tapSchema); + applicationManager.setEditTapSchemaPageState(pageState); response.sendRedirect(TSMPages.EDIT_SCHEMA); } catch (SQLException e) { e.printStackTrace(System.err); - } finally { - try { - if (connection != null) { - connection.close(); - } - } catch (SQLException e) { - e.printStackTrace(System.err); - } + throw new ServletException("SQL error occours during TAP_SCHEMA creation"); } } } @@ -99,6 +105,7 @@ public class TSMServlet extends HttpServlet { private void processInsertCredentials(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { + ApplicationManager applicationManager = getApplicationManager(request); String hostname = request.getParameter("hostname"); String portStr = request.getParameter("port"); @@ -142,7 +149,6 @@ public class TSMServlet extends HttpServlet { try { SelectTapSchemaModel selectTapSchema = new SelectTapSchemaModel(credentials.getConnection()); applicationManager.setSelectTapSchemaModel(selectTapSchema); - request.getSession().setAttribute("applicationManager", applicationManager); response.sendRedirect(TSMPages.SELECT_SCHEMA); } catch (SQLException e) { insertCredentialsModel.addError("Connection error: " + e.getMessage()); diff --git a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/TapSchemaResource.java b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/TapSchemaResource.java similarity index 78% rename from TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/TapSchemaResource.java rename to TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/TapSchemaResource.java index 412812180b113c9e7b4a24a10ec73f518fc9943a..d2b633f29ab0c15932a506b7dc6db21cabcf5e2f 100644 --- a/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/TapSchemaResource.java +++ b/TapSchemaManager/src/main/java/it/inaf/oats/ia2/tapschemamanager/webapp/TapSchemaResource.java @@ -1,11 +1,15 @@ -package it.inaf.oats.ia2.tapschemamanager; +package it.inaf.oats.ia2.tapschemamanager.webapp; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.flipkart.zjsonpatch.JsonDiff; import com.google.gson.Gson; import com.google.gson.GsonBuilder; -import it.inaf.oats.ia2.tapschemamodel.*; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.EntityWrapper; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.EntityWrapperContainer; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.Status; +import it.inaf.oats.ia2.tapschemamanager.businesslayer.TapSchema; +import it.inaf.oats.ia2.tapschemamanager.datalayer.Credentials; import java.io.IOException; import javax.ws.rs.core.Context; import javax.ws.rs.Consumes; @@ -41,8 +45,8 @@ public class TapSchemaResource { @Context private HttpServletRequest request; - private ApplicationManagerLocal getApplicationManager() { - return (ApplicationManagerLocal) request.getSession().getAttribute("applicationManager"); + private ApplicationManager getApplicationManager() { + return (ApplicationManager) request.getSession().getAttribute("applicationManager"); } private TapSchema getTapSchema() { @@ -60,7 +64,7 @@ public class TapSchemaResource { private String getPageModelPatches() throws IOException { EditTapSchemaPageState pageState = getPageState(); - EditTapSchemaPageModel newModel = new EditTapSchemaPageModel(pageState.getTapSchema()); + EditTapSchemaPageModel newModel = new EditTapSchemaPageModel(pageState); JsonNode jn1 = mapper.readTree(NULLABLE_GSON.toJson(pageState.getPreviousModel())); JsonNode jn2 = mapper.readTree(NULLABLE_GSON.toJson(newModel)); @@ -72,29 +76,25 @@ public class TapSchemaResource { return patches.toString(); } - private IDbEntitiesContainer getEntitiesContainer(String name) { + private EntityWrapperContainer getEntitiesContainer(String name) { TapSchema tapSchema = getTapSchema(); if (name.equals(TAP_SCHEMA)) { return tapSchema; - } - if (name.equals(SCHEMA)) { + } else if (name.equals(SCHEMA)) { return tapSchema.getSelectedSchema(); - } - if (name.equals(TABLE)) { + } else if (name.equals(TABLE)) { return tapSchema.getSelectedTable(); } return null; } - private DbEntity getDbEntity(String name) { + private EntityWrapper getEntityWrapper(String name) { TapSchema tapSchema = getTapSchema(); if (name.equals(SCHEMA)) { return tapSchema.getSelectedSchema(); - } - if (name.equals(TABLE)) { + } else if (name.equals(TABLE)) { return tapSchema.getSelectedTable(); - } - if (name.equals(COLUMN)) { + } else if (name.equals(COLUMN)) { return tapSchema.getSelectedColumn(); } return null; @@ -104,17 +104,20 @@ public class TapSchemaResource { @Path("model") @Produces(MediaType.APPLICATION_JSON) public String getPageModelJson() { - EditTapSchemaPageModel pi = new EditTapSchemaPageModel(getTapSchema()); - getPageState().setPreviousModel(pi); - return NULLABLE_GSON.toJson(pi); + EditTapSchemaPageState pageState = getPageState(); + EditTapSchemaPageModel pageModel = new EditTapSchemaPageModel(pageState); + pageState.setPreviousModel(pageModel); + return NULLABLE_GSON.toJson(pageModel); + } + + private void selectEntity(String containerName, String entityName) { + getEntitiesContainer(containerName).selectEntity(entityName); } @POST @Path("select") public String select(@FormParam("containerName") String containerName, @FormParam("entityName") String entityName) throws IOException { - IDbEntitiesContainer container = getEntitiesContainer(containerName); - container.select(entityName); - System.out.println("select " + containerName + " " + entityName); + selectEntity(containerName, entityName); return getPageModelPatches(); } @@ -127,8 +130,8 @@ public class TapSchemaResource { @POST @Path("remove") public String remove(@FormParam("containerName") String containerName, @FormParam("entityName") String entityName) throws IOException { - IDbEntitiesContainer container = getEntitiesContainer(containerName); - container.removeEntity(entityName); + EntityWrapperContainer container = getEntitiesContainer(containerName); + container.removeEntityWrapper(entityName); return getPageModelPatches(); } @@ -145,7 +148,7 @@ public class TapSchemaResource { @POST @Path("addables") public String getAddables(@FormParam("containerName") String containerName) { - IDbEntitiesContainer container = getEntitiesContainer(containerName); + EntityWrapperContainer container = getEntitiesContainer(containerName); ArrayList addables = new ArrayList(); for (String name : container.getAddables()) { addables.add(new Addable(name)); @@ -163,7 +166,7 @@ public class TapSchemaResource { @Path("update") public String update() throws SQLException, IOException { TapSchema tapSchema = getTapSchema(); - (new UpdateManager(getCredentials(), tapSchema)).update(); + tapSchema.save(); return getPageModelPatches(); } @@ -174,13 +177,9 @@ public class TapSchemaResource { public String add(String params) throws SQLException, IOException { final AddParams addParams = STANDARD_GSON.fromJson(params, AddParams.class); - (new ConnectionManager(getCredentials()) { - - @Override - public void use(Connection connection) throws SQLException { - getEntitiesContainer(addParams.containerName).loadEntities(connection, addParams.entities); - } - }).connect(); + for (String entityName : addParams.entities) { + getEntitiesContainer(addParams.containerName).addEntityWrapper(entityName); + } return getPageModelPatches(); } @@ -198,7 +197,10 @@ public class TapSchemaResource { @Produces(MediaType.APPLICATION_JSON) public String edit(String params) throws SQLException { EditParams editParams = STANDARD_GSON.fromJson(params, EditParams.class); - boolean isChanged = getDbEntity(editParams.entity).updateValue(editParams.key, editParams.value); + EntityWrapper entityWrapper = getEntityWrapper(editParams.entity); + + entityWrapper.setValue(editParams.key, editParams.value); + boolean isChanged = entityWrapper.isChanged(editParams.key); // Update previous model getPageState().getPreviousModel().updateEditableField(editParams.entity, editParams.key, editParams.value, isChanged); @@ -210,7 +212,7 @@ public class TapSchemaResource { @Path("undoremove") @Produces(MediaType.APPLICATION_JSON) public String undoremove(@FormParam("containerName") String containerName) throws SQLException, IOException { - getEntitiesContainer(containerName).getSelected().setStatus(Status.SELECTED_SAVED); + getEntitiesContainer(containerName).getSelectedEntity().setStatus(Status.ADDED_PERSISTED); return getPageModelPatches(); } diff --git a/TapSchemaManager/src/main/webapp/WEB-INF/tags/editcheckbox.tag b/TapSchemaManager/src/main/webapp/WEB-INF/tags/editcheckbox.tag index e374f64ae7d2775bfe939f6c46d51ac7fd42faf8..ba0a57e9bee12767e21bd6c987743b03b39a8d31 100644 --- a/TapSchemaManager/src/main/webapp/WEB-INF/tags/editcheckbox.tag +++ b/TapSchemaManager/src/main/webapp/WEB-INF/tags/editcheckbox.tag @@ -1,4 +1,4 @@ <%@tag description="Edit checkbox template" pageEncoding="UTF-8"%> <%@ attribute name="entity" required="true" type="String" %> <%@ attribute name="key" required="true" type="String" %> - \ No newline at end of file + \ No newline at end of file diff --git a/TapSchemaManager/src/main/webapp/editTapSchema.jsp b/TapSchemaManager/src/main/webapp/editTapSchema.jsp index bc075e22056242ff6ed77de730cce2da08c04cbd..025e54665c7567b9b6ae0ad7602dc5dd5c597ae4 100644 --- a/TapSchemaManager/src/main/webapp/editTapSchema.jsp +++ b/TapSchemaManager/src/main/webapp/editTapSchema.jsp @@ -173,11 +173,23 @@ -
- +
+
+
+ +
+
+
+
+ +
+
diff --git a/TapSchemaManager/src/test/java/TapSchemaMangerTest.java b/TapSchemaManager/src/test/java/TapSchemaMangerTest.java new file mode 100644 index 0000000000000000000000000000000000000000..e519592eaed116417881a41ccf979e085664e6d0 --- /dev/null +++ b/TapSchemaManager/src/test/java/TapSchemaMangerTest.java @@ -0,0 +1,68 @@ + +import it.inaf.oats.ia2.tapschemamanager.businesslayer.Column; +import it.inaf.oats.ia2.tapschemamanager.datalayer.ColumnEntity; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import static org.junit.Assert.*; +import org.junit.Ignore; + +/** + * + * @author Sonia Zorba + */ +public class TapSchemaMangerTest { + + public TapSchemaMangerTest() { + } + + @BeforeClass + public static void setUpClass() { + } + + @AfterClass + public static void tearDownClass() { + } + + @Before + public void setUp() { + } + + @After + public void tearDown() { + } + + @Ignore + @Test + public void testEditingFieldValue() { +// ColumnEntity columnEntity = new ColumnEntity("test"); +// columnEntity.setDescription("desc"); +// columnEntity.setUnit(null); +// columnEntity.setStd(0); +// +// Column column = new Column(columnEntity, false); +// +// String key = Column.DESCRIPTION; +// assertFalse(column.isChanged(key)); +// column.setValue(key, "mod"); +// assertTrue(column.isChanged(key)); +// column.setValue(key, "desc"); +// assertFalse(column.isChanged(key)); +// +// key = Column.UNIT; +// assertFalse(column.isChanged(key)); +// column.setValue(key, "xxx"); +// assertTrue(column.isChanged(key)); +// column.setValue(key, ""); +// assertFalse(column.isChanged(key)); +// +// key = Column.STD; +// assertFalse(column.isChanged(key)); +// column.setValue(key, "1"); +// assertTrue(column.isChanged(key)); +// column.setValue(key, "0"); +// assertFalse(column.isChanged(key)); + } +} diff --git a/TapSchemaManagerBL/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Status.java b/TapSchemaManagerBL/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Status.java deleted file mode 100644 index 7da73e64b7bd6b7d759ab00bcbee2ead7137afce..0000000000000000000000000000000000000000 --- a/TapSchemaManagerBL/src/main/java/it/inaf/oats/ia2/tapschemamanager/businesslayer/Status.java +++ /dev/null @@ -1,12 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -/** - * - * @author Sonia Zorba - */ -public enum Status { - NOT_SELECTED, - SELECTED_SAVED, - SELECTED_TO_SAVE, - TO_REMOVE -} diff --git a/TapSchemaModel/pom.xml b/TapSchemaManagerDL/pom.xml similarity index 55% rename from TapSchemaModel/pom.xml rename to TapSchemaManagerDL/pom.xml index 07b810f78b612a8bdf1aa9301e833dd4a7b9af8a..14a1e8c12ff11f8bae20ff27e245a999a8a9ec2e 100644 --- a/TapSchemaModel/pom.xml +++ b/TapSchemaManagerDL/pom.xml @@ -2,7 +2,7 @@ 4.0.0 it.inaf.oats.ia2 - TapSchemaModel + TapSchemaManagerDL 1.0-SNAPSHOT jar @@ -11,6 +11,23 @@ 1.6 + + org.hibernate.javax.persistence + hibernate-jpa-2.0-api + 1.0.1.Final + + + org.eclipse.persistence + eclipselink + 2.5.2 + + + mysql + mysql-connector-java + 5.1.37 + jar + runtime + junit junit diff --git a/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/ColumnEntity.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/ColumnEntity.java new file mode 100644 index 0000000000000000000000000000000000000000..38816a702c03e304d5977fc40b555e6709c85277 --- /dev/null +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/ColumnEntity.java @@ -0,0 +1,179 @@ +package it.inaf.oats.ia2.tapschemamanager.datalayer; + +import java.io.Serializable; +import java.math.BigInteger; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.IdClass; +import javax.persistence.ManyToOne; +import javax.persistence.PrimaryKeyJoinColumn; +import javax.persistence.Table; + +class ColumnId implements Serializable { + + String tableName; + String name; +} + +/** + * + * @author Sonia Zorba + */ +@Entity +@IdClass(ColumnId.class) +@Table(name = "columns") +public class ColumnEntity implements Serializable, TapSchemaEntity { + + @Id + @Column(name = "table_name", length = 128) + private String tableName; + + @Id + @Column(name = "column_name", length = 64) + private String name; + + @ManyToOne(fetch = FetchType.EAGER) + @PrimaryKeyJoinColumn(name = "table_name", referencedColumnName = "table_name") + private TableEntity table; + + @Column(name = "utype", length = 512) + private String utype; + + @Column(name = "ucd", length = 64) + private String ucd; + + @Column(name = "unit", length = 64) + private String unit; + + @Column(name = "description", length = 512) + private String description; + + @Column(name = "datatype", length = 64) + private String datatype; + + @Column(name = "size") + private int size; + + @Column(name = "principal") + private int principal; + + @Column(name = "indexed") + private int indexed; + + @Column(name = "std") + private int std; + + @Column(name = "columnID") + private BigInteger columnID; + + protected ColumnEntity() { + } + + protected ColumnEntity(String columnName) { + this(); + this.name = columnName; + } + + public String getTableName() { + return tableName; + } + + protected void setTableName(String tableName) { + this.tableName = tableName; + } + + @Override + public String getName() { + return name; + } + + protected void setName(String columnName) { + this.name = columnName; + } + + public String getUtype() { + return utype; + } + + public void setUtype(String utype) { + this.utype = utype; + } + + public String getUcd() { + return ucd; + } + + public void setUcd(String ucd) { + this.ucd = ucd; + } + + public String getUnit() { + return unit; + } + + public void setUnit(String unit) { + this.unit = unit; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public String getDatatype() { + return datatype; + } + + public void setDatatype(String datatype) { + this.datatype = datatype; + } + + public int getSize() { + return size; + } + + public void setSize(int size) { + this.size = size; + } + + public int getPrincipal() { + return principal; + } + + public void setPrincipal(int principal) { + this.principal = principal; + } + + public int getIndexed() { + return indexed; + } + + public void setIndexed(int indexed) { + this.indexed = indexed; + } + + public int getStd() { + return std; + } + + public void setStd(int std) { + this.std = std; + } + + protected BigInteger getColumnID() { + return columnID; + } + + protected void setColumnID(BigInteger columnID) { + this.columnID = columnID; + } + + public TableEntity getTable() { + return table; + } +} diff --git a/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/ColumnInfo.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/ColumnInfo.java new file mode 100644 index 0000000000000000000000000000000000000000..2c93b08f61ab41a8b4abb8c411bdbcb531663283 --- /dev/null +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/ColumnInfo.java @@ -0,0 +1,27 @@ +package it.inaf.oats.ia2.tapschemamanager.datalayer; + +/** + * + * @author Sonia Zorba + */ +public class ColumnInfo { + + private boolean primaryKey; + private final ColumnEntity columnEntity; + + public ColumnInfo(ColumnEntity columnEntity) { + this.columnEntity = columnEntity; + } + + public boolean isPrimaryKey() { + return primaryKey; + } + + public void setPrimaryKey(boolean primaryKey) { + this.primaryKey = primaryKey; + } + + public ColumnEntity getColumnEntity() { + return columnEntity; + } +} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Credentials.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/Credentials.java similarity index 69% rename from TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Credentials.java rename to TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/Credentials.java index a418937a01eddbc21713cd6ce51085bac2a1277b..efc805dd76fecd0ad1f0c14b56cde4bb0648acb5 100644 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Credentials.java +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/Credentials.java @@ -1,4 +1,4 @@ -package it.inaf.oats.ia2.tapschemamodel; +package it.inaf.oats.ia2.tapschemamanager.datalayer; import java.sql.Connection; import java.sql.DriverManager; @@ -15,10 +15,12 @@ public class Credentials { private String username; private String password; + private DatabaseType databaseType; + public Credentials() { super(); - System.out.println("Credentials created"); this.port = 3306; + this.databaseType = DatabaseType.MYSQL; } public String getHostname() { @@ -53,9 +55,25 @@ public class Credentials { this.password = password; } + public DatabaseType getDatabaseType() { + return databaseType; + } + + public void setDatabaseType(DatabaseType databaseType) { + this.databaseType = databaseType; + } + + public String getDatabaseDriverClass() { + switch (getDatabaseType()) { + case MYSQL: + return "com.mysql.jdbc.Driver"; + } + return null; + } + public Connection getConnection() throws SQLException { try { - Class.forName("com.mysql.jdbc.Driver"); + Class.forName(getDatabaseDriverClass()); } catch (ClassNotFoundException e) { e.printStackTrace(System.err); } diff --git a/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/DataProvider.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/DataProvider.java new file mode 100644 index 0000000000000000000000000000000000000000..936d567601abae5e792818650a4db68dcd33f2b5 --- /dev/null +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/DataProvider.java @@ -0,0 +1,268 @@ +package it.inaf.oats.ia2.tapschemamanager.datalayer; + +import java.sql.Connection; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.Persistence; + +/** + * + * @author Sonia Zorba + */ +public class DataProvider { + + public static List getAllTAPSchemasNames(Connection connection, final List allSchemas) throws SQLException { + + class TAPSchemaChecker { + + boolean schemas; + boolean tables; + boolean columns; + boolean keys; + boolean key_columns; + + // if database has schemas, tables, columns, keys and key_columns + // then it is a tap_schema database + boolean isTAPSchema() { + return schemas && tables && columns && keys && key_columns; + } + } + + final List allTAPSchemas = new ArrayList(); + + for (String schemaName : allSchemas) { + + final TAPSchemaChecker tapSchemaChecker = new TAPSchemaChecker(); + + (new ResultSetReader("SHOW TABLES FROM " + schemaName + ";") { + + @Override + public void manipulateItem(ResultSet resultSet) throws SQLException { + // searches if the current database has schemas, tables, columns, + // keys, key_columns, that is a tap_schema database + + String tableName = resultSet.getString(1); + + if (tableName.equals("schemas")) { + tapSchemaChecker.schemas = true; + } else if (tableName.equals("tables")) { + tapSchemaChecker.tables = true; + } else if (tableName.equals("columns")) { + tapSchemaChecker.columns = true; + } else if (tableName.equals("keys")) { + tapSchemaChecker.keys = true; + } else if (tableName.equals("key_columns")) { + tapSchemaChecker.key_columns = true; + } + } + + }).read(connection); + + if (tapSchemaChecker.isTAPSchema()) { + allTAPSchemas.add(schemaName); + } + } + + return allTAPSchemas; + } + + public static List getExposedSchemas(Connection connection, final String tapSchemaName) throws SQLException { + final List exposedSchemas = new ArrayList(); + + (new ResultSetReader("SELECT schema_name FROM " + tapSchemaName + ".`schemas`") { + + @Override + public void manipulateItem(ResultSet resultSet) throws SQLException { + exposedSchemas.add(resultSet.getString(1)); + } + }).read(connection); + + return exposedSchemas; + } + + public static EntityManager getEntityManager(Credentials credentials, String tapSchemaName) { + Map persistenceMap = new HashMap(); + + persistenceMap.put("javax.persistence.jdbc.url", "jdbc:mysql://" + credentials.getHostname() + ":" + credentials.getPort() + "/" + tapSchemaName); + persistenceMap.put("javax.persistence.jdbc.user", credentials.getUsername()); + persistenceMap.put("javax.persistence.jdbc.password", credentials.getPassword()); + persistenceMap.put("javax.persistence.jdbc.driver", credentials.getDatabaseDriverClass()); + + EntityManagerFactory managerFactory = Persistence.createEntityManagerFactory("pu", persistenceMap); + return managerFactory.createEntityManager(); + } + + public static void createDatabase(Connection connection, String tapSchemaName) throws SQLException { + Statement statement = connection.createStatement(); + statement.executeUpdate("CREATE DATABASE IF NOT EXISTS " + tapSchemaName); + statement.close(); + } + + public static List getAllSchemasNames(Connection connection) throws SQLException { + final List allSchemas = new ArrayList(); + (new ResultSetReader("SHOW DATABASES;") { + + @Override + public void manipulateItem(ResultSet resultSet) throws SQLException { + allSchemas.add(resultSet.getString(1)); + } + + }).read(connection); + return allSchemas; + } + + public static ArrayList getAllTablesNames(Connection connection, String schemaName) throws SQLException { + final ArrayList allTables = new ArrayList(); + + (new ResultSetReader("SHOW TABLES FROM " + schemaName + ";") { + + @Override + public void manipulateItem(ResultSet resultSet) throws SQLException { + allTables.add(resultSet.getString(1)); + } + }).read(connection); + + return allTables; + } + + /** + * Generate list of KeyEntity for a given schema. This keys are without id! + * It has to be set when a table is added to a schema. + * + * @param connection + * @param schemaName + * @return + * @throws SQLException + */ + public static List getSchemaKeys(final Connection connection, final String schemaName) throws SQLException { + + final Map schemaKeysMap = new HashMap(); + + (new ResultSetReader("SELECT k.TABLE_NAME, k.COLUMN_NAME, " + + "k.REFERENCED_TABLE_NAME, k.REFERENCED_COLUMN_NAME " + + "FROM information_schema.TABLE_CONSTRAINTS i " + + "LEFT JOIN information_schema.KEY_COLUMN_USAGE k " + + "ON i.CONSTRAINT_NAME = k.CONSTRAINT_NAME " + + "WHERE i.CONSTRAINT_TYPE = 'FOREIGN KEY' " + + "AND i.TABLE_SCHEMA = '" + schemaName + "' " + + "AND k.TABLE_SCHEMA = '" + schemaName + "';") { + + @Override + public void manipulateItem(ResultSet resultSet) throws SQLException { + String fromTable = schemaName + "." + resultSet.getString("k.TABLE_NAME"); + String targetTable = schemaName + "." + resultSet.getString("k.REFERENCED_TABLE_NAME"); + + String mapKey = fromTable + "_" + targetTable; + + KeyEntity keyEntity = schemaKeysMap.get(mapKey); + if (keyEntity == null) { + keyEntity = new KeyEntity(); + keyEntity.setFromTableName(fromTable); + keyEntity.setTargetTableName(targetTable); + schemaKeysMap.put(mapKey, keyEntity); + } + + KeyColumnEntity keyColumnEntity = new KeyColumnEntity(); + keyColumnEntity.setFromColumn(resultSet.getString("k.COLUMN_NAME")); + keyColumnEntity.setTargetColumn(resultSet.getString("k.REFERENCED_COLUMN_NAME")); + keyEntity.getKeyColumns().add(keyColumnEntity); + } + }).read(connection); + + return new ArrayList(schemaKeysMap.values()); + } + + private static boolean equalsOneOf(String string, String... values) { + for (String value : values) { + if (string.equals(value)) { + return true; + } + } + return false; + } + + public static List getAllColumns(final Connection connection, final String schemaName, final String tableName, final Map alreadyLoadedColumns) throws SQLException { + final List allColumns = new ArrayList(); + + (new ResultSetReader("SHOW COLUMNS FROM `" + schemaName + "`.`" + tableName + "`;") { + + @Override + public void manipulateItem(ResultSet resultSet) throws SQLException { + + String columnName = resultSet.getString("Field"); + + boolean alreadyLoaded = alreadyLoadedColumns != null && alreadyLoadedColumns.containsKey(columnName); + + ColumnEntity columnEntity; + if (alreadyLoaded) { + columnEntity = alreadyLoadedColumns.get(columnName); + } else { + columnEntity = new ColumnEntity(columnName); + } + + ColumnInfo columnInfo = new ColumnInfo(columnEntity); + + // Key + String key = resultSet.getString("Key"); + columnInfo.setPrimaryKey(key.equals("PRI")); + columnEntity.setIndexed(equalsOneOf(key, "PRI", "UNI", "MUL") ? 1 : 0); + if (!alreadyLoaded) { + columnEntity.setPrincipal(key.equals("PRI") ? 1 : 0); + } + + // Datatype and Size + String type = resultSet.getString("Type").toLowerCase(); + + int size = 0; + String datatype; + if (type.startsWith("int")) { + datatype = "adql:INTEGER"; + } else if (type.startsWith("smallint")) { + datatype = "adql:SMALLINT"; + } else if (type.startsWith("bigint")) { + datatype = "adql:BIGINT"; + } else if (type.startsWith("float")) { + datatype = "adql:REAL"; + } else if (type.startsWith("char")) { + int beginIndex = type.indexOf('('); + int endIndex = type.indexOf(')'); + size = Integer.parseInt(type.substring(beginIndex + 1, endIndex)); + datatype = "adql:CHAR"; + } else if (type.startsWith("varchar")) { + int beginIndex = type.indexOf('('); + int endIndex = type.indexOf(')'); + size = Integer.parseInt(type.substring(beginIndex + 1, endIndex)); + datatype = "adql:VARCHAR"; + } else if (type.contains("timestamp")) { + datatype = "adql:TIMESTAMP"; + } else { + datatype = "adql:" + type.toUpperCase(); + } + columnEntity.setDatatype(datatype); + columnEntity.setSize(size); + + if (!alreadyLoaded) { + columnEntity.setStd(0); + } + + // STD TAP_SCHEMA +// boolean std = false; +// if ((schemaName.equals(tapSchemaName)) +// && !equalsOneOf(columnName, "schemaID", "tableID", "columnID", "keyID", "key_columnID")) { +// std = true; +// } +// column.setStd(std ? 1 : 0); + allColumns.add(columnInfo); + } + }).read(connection); + + return allColumns; + } +} diff --git a/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/DatabaseType.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/DatabaseType.java new file mode 100644 index 0000000000000000000000000000000000000000..4b15e59f9a179b4d0c8c389f24358f92cb64f942 --- /dev/null +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/DatabaseType.java @@ -0,0 +1,9 @@ +package it.inaf.oats.ia2.tapschemamanager.datalayer; + +/** + * + * @author Sonia Zorba + */ +public enum DatabaseType { + MYSQL +} diff --git a/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/KeyColumnEntity.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/KeyColumnEntity.java new file mode 100644 index 0000000000000000000000000000000000000000..5790c03a58fa1cd6259bc0dc67f6f4781355e3b6 --- /dev/null +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/KeyColumnEntity.java @@ -0,0 +1,84 @@ +package it.inaf.oats.ia2.tapschemamanager.datalayer; + +import java.io.Serializable; +import java.math.BigInteger; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.IdClass; +import javax.persistence.ManyToOne; +import javax.persistence.PrimaryKeyJoinColumn; +import javax.persistence.Table; + +class KeyColumn implements Serializable { + + String keyId; + String fromColumn; + String targetColumn; +} + +/** + * + * @author Sonia Zorba + */ +@Entity +@IdClass(KeyColumn.class) +@Table(name = "key_columns") +public class KeyColumnEntity implements Serializable { + + @Id + @Column(name = "key_id", length = 64) + private String keyId; + + @Id + @Column(name = "from_column", length = 64) + private String fromColumn; + + @Id + @Column(name = "target_column", length = 64) + private String targetColumn; + + @Column(name = "key_columnID") + private BigInteger keyColumnID; + + @ManyToOne(fetch = FetchType.EAGER) + @PrimaryKeyJoinColumn(name = "key_id", referencedColumnName = "key_id") + private KeyEntity key; + + public String getKeyId() { + return keyId; + } + + public void setKeyId(String keyId) { + this.keyId = keyId; + } + + public String getFromColumn() { + return fromColumn; + } + + public void setFromColumn(String fromColumn) { + this.fromColumn = fromColumn; + } + + public String getTargetColumn() { + return targetColumn; + } + + public void setTargetColumn(String targetColumn) { + this.targetColumn = targetColumn; + } + + public BigInteger getKeyColumnID() { + return keyColumnID; + } + + public void setKeyColumnID(BigInteger keyColumnID) { + this.keyColumnID = keyColumnID; + } + + public KeyEntity getKey() { + return key; + } +} diff --git a/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/KeyEntity.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/KeyEntity.java new file mode 100644 index 0000000000000000000000000000000000000000..ff470b4d8abb3758a531e6fda36b4782c060c257 --- /dev/null +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/KeyEntity.java @@ -0,0 +1,123 @@ +package it.inaf.oats.ia2.tapschemamanager.datalayer; + +import java.io.Serializable; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.ManyToOne; +import javax.persistence.OneToMany; +import javax.persistence.PrimaryKeyJoinColumn; +import javax.persistence.Table; + +/** + * + * @author Sonia Zorba + */ +@Entity +@Table(name = "`keys`") +public class KeyEntity implements Serializable { + + @Id + @Column(name = "key_id", length = 64) + private String keyId; + + @Column(name = "from_table", length = 128) + private String fromTableName; + + @Column(name = "target_table", length = 128) + private String targetTableName; + + @Column(name = "utype", length = 512) + private String utype; + + @Column(name = "description", length = 512) + private String description; + + @Column(name = "keyID") + private BigInteger keyID; + + @ManyToOne(fetch = FetchType.EAGER) + @PrimaryKeyJoinColumn(name = "from_table", referencedColumnName = "table_name") + private TableEntity fromTable; + + @ManyToOne(fetch = FetchType.EAGER) + @PrimaryKeyJoinColumn(name = "target_table", referencedColumnName = "table_name") + private TableEntity targetTable; + + @OneToMany(mappedBy = "key", cascade = CascadeType.ALL, orphanRemoval = true) + private final List keyColumns; + + public KeyEntity() { + keyColumns = new ArrayList(); + } + + public KeyEntity(int keyId) { + this(); + this.keyId = keyId + ""; + } + + public String getKeyId() { + return keyId; + } + + public void setKeyId(String keyId) { + this.keyId = keyId; + } + + public String getFromTableName() { + return fromTableName; + } + + public void setFromTableName(String fromTableName) { + this.fromTableName = fromTableName; + } + + public String getTargetTableName() { + return targetTableName; + } + + public void setTargetTableName(String targetTableName) { + this.targetTableName = targetTableName; + } + + public String getUtype() { + return utype; + } + + public void setUtype(String utype) { + this.utype = utype; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public BigInteger getKeyID() { + return keyID; + } + + public void setKeyID(BigInteger keyID) { + this.keyID = keyID; + } + + public TableEntity getFromTable() { + return fromTable; + } + + public TableEntity getTargetTable() { + return targetTable; + } + + public List getKeyColumns() { + return keyColumns; + } +} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/ResultSetReader.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/ResultSetReader.java similarity index 86% rename from TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/ResultSetReader.java rename to TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/ResultSetReader.java index 7d0b5e7ab1412b5c9f5820ec4c8810c8531b76c0..63459b0fe585681053a3b440925bd1296e36a460 100644 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/ResultSetReader.java +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/ResultSetReader.java @@ -1,4 +1,4 @@ -package it.inaf.oats.ia2.tapschemamodel; +package it.inaf.oats.ia2.tapschemamanager.datalayer; import java.sql.Connection; import java.sql.ResultSet; @@ -29,6 +29,7 @@ public abstract class ResultSetReader { manipulateItem(resultSet); } } catch (SQLException e) { + System.err.println("[ResultSetReader]: The following query caused SQLException: \"" + query + "\""); throw e; } finally { if (resultSet != null) { diff --git a/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/SchemaEntity.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/SchemaEntity.java new file mode 100644 index 0000000000000000000000000000000000000000..4a846eade22087ab08ad825fd21921d2cbceac99 --- /dev/null +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/SchemaEntity.java @@ -0,0 +1,90 @@ +package it.inaf.oats.ia2.tapschemamanager.datalayer; + +import java.io.Serializable; +import java.math.BigInteger; +import java.util.HashMap; +import java.util.Map; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.MapKeyColumn; +import javax.persistence.OneToMany; +import javax.persistence.Table; + +/** + * + * @author Sonia Zorba + */ +@Entity +@Table(name = "`schemas`") +public class SchemaEntity implements Serializable, TapSchemaEntity { + + @Id + @Column(name = "schema_name", length = 64) + private String name; + + @Column(name = "utype", length = 512) + private String utype; + + @Column(name = "description", length = 512) + private String description; + + @Column(name = "schemaID") + private BigInteger schemaID; + + @OneToMany(mappedBy = "schema", cascade = CascadeType.ALL, orphanRemoval = true) + @MapKeyColumn(name = "table_name", insertable = false, updatable = false) + private final Map tables; + + protected SchemaEntity() { + this.tables = new HashMap(); + } + + protected SchemaEntity(String schemaName) { + this(); + this.name = schemaName; + } + + @Override + public String getName() { + return name; + } + + protected void setName(String schemaName) { + this.name = schemaName; + } + + public String getUtype() { + return utype; + } + + public void setUtype(String utype) { + this.utype = utype; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + protected BigInteger getSchemaID() { + return schemaID; + } + + protected void setSchemaID(BigInteger schemaID) { + this.schemaID = schemaID; + } + + public Map getTables() { + return tables; + } + + public void addTable(TableEntity table) { + tables.put(table.getName(), table); + table.setSchemaName(name); + } +} diff --git a/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/TableEntity.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/TableEntity.java new file mode 100644 index 0000000000000000000000000000000000000000..b9745257f3397b60d381ecce8fe4d94e99a3345c --- /dev/null +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/TableEntity.java @@ -0,0 +1,152 @@ +package it.inaf.oats.ia2.tapschemamanager.datalayer; + +import java.io.Serializable; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.regex.Pattern; +import javax.persistence.CascadeType; +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.Id; +import javax.persistence.ManyToOne; +import javax.persistence.MapKeyColumn; +import javax.persistence.OneToMany; +import javax.persistence.PrimaryKeyJoinColumn; +import javax.persistence.Table; + +/** + * + * @author Sonia Zorba + */ +@Entity +@Table(name = "tables") +public class TableEntity implements Serializable, TapSchemaEntity { + + @Id + @Column(name = "table_name", length = 128) + private String name; + + @Column(name = "schema_name", length = 64) + private String schemaName; + + @Column(name = "table_type", length = 8) + private String tableType; + + @Column(name = "utype", length = 512) + private String utype; + + @Column(name = "description", length = 512) + private String description; + + @Column(name = "tableID") + private BigInteger tableID; + + @ManyToOne(fetch = FetchType.EAGER) + @PrimaryKeyJoinColumn(name = "schema_name", referencedColumnName = "schema_name") + private SchemaEntity schema; + + @OneToMany(mappedBy = "table", cascade = CascadeType.ALL, orphanRemoval = true) + @MapKeyColumn(name = "column_name", insertable = false, updatable = false) + private final Map columns; + + @OneToMany(mappedBy = "fromTable", cascade = CascadeType.ALL, orphanRemoval = true) + private final List fromKeys; + + @OneToMany(mappedBy = "targetTable", cascade = CascadeType.ALL, orphanRemoval = true) + private final List targetKeys; + + protected TableEntity() { + columns = new HashMap(); + fromKeys = new ArrayList(); + targetKeys = new ArrayList(); + } + + protected TableEntity(String tableName) { + this(); + this.name = tableName; + } + + /** + * @return full table name: schemaName.tableName + */ + @Override + public String getName() { + return name; + } + + /** + * @return table name without schema name + */ + public String getTableName() { + return name.split(Pattern.quote("."))[1]; + } + + protected void setName(String tableName) { + this.name = tableName; + } + + public String getSchemaName() { + return schemaName; + } + + protected void setSchemaName(String schemaName) { + this.schemaName = schemaName; + } + + public String getTableType() { + return tableType; + } + + public void setTableType(String tableType) { + this.tableType = tableType; + } + + public String getUtype() { + return utype; + } + + public void setUtype(String utype) { + this.utype = utype; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + protected BigInteger getTableID() { + return tableID; + } + + protected void setTableID(BigInteger tableID) { + this.tableID = tableID; + } + + public SchemaEntity getSchema() { + return schema; + } + + public Map getColumns() { + return columns; + } + + public List getFromKeys() { + return fromKeys; + } + + public List getTargetKeys() { + return targetKeys; + } + + public void addColumn(ColumnEntity column) { + columns.put(column.getName(), column); + column.setTableName(name); + } +} diff --git a/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/TapSchemaEntity.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/TapSchemaEntity.java new file mode 100644 index 0000000000000000000000000000000000000000..addd8ae3249db19091b958fae0e26a59ea7b285a --- /dev/null +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/TapSchemaEntity.java @@ -0,0 +1,10 @@ +package it.inaf.oats.ia2.tapschemamanager.datalayer; + +/** + * + * @author Sonia Zorba + */ +public interface TapSchemaEntity { + + String getName(); +} diff --git a/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/TapSchemaHandler.java b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/TapSchemaHandler.java new file mode 100644 index 0000000000000000000000000000000000000000..a6fed9be47635812a934a6e4000714cbb32487b8 --- /dev/null +++ b/TapSchemaManagerDL/src/main/java/it/inaf/oats/ia2/tapschemamanager/datalayer/TapSchemaHandler.java @@ -0,0 +1,250 @@ +package it.inaf.oats.ia2.tapschemamanager.datalayer; + +import java.sql.Connection; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import javax.persistence.EntityManager; +import javax.persistence.criteria.CriteriaBuilder; +import javax.persistence.criteria.CriteriaQuery; + +class ColumnsInfo { + + private final Map>> columnsInfo; + + ColumnsInfo() { + this.columnsInfo = new HashMap>>(); + } + + void addColumnsInfo(Connection connection, String schemaName, String tableName, Map alreadyLoadedColumns) throws SQLException { + Map> map = columnsInfo.get(schemaName); + if (map == null) { + map = new HashMap>(); + columnsInfo.put(schemaName, map); + } + map.put(tableName, DataProvider.getAllColumns(connection, schemaName, tableName, alreadyLoadedColumns)); + } + + List getColumnsInfo(String schemaName, String tableName) { + return columnsInfo.get(schemaName).get(tableName); + } +} + +/** + * + * @author Sonia Zorba + */ +public class TapSchemaHandler { + + private final Credentials credentials; + private final String name; + private boolean exists; + + private final List allSchemas; + private final Map schemas; + private final Map> schemaKeys; + private final List persisedSchemas; + private final List toRemoveSchemas; + + private final Map> allSchemaTables; + + private final ColumnsInfo columnsInfo; + + private EntityManager entityManager; + + private Connection connection; + + public TapSchemaHandler(Credentials credentials, String tapSchemaName, boolean exists) throws SQLException { + this.credentials = credentials; + this.name = tapSchemaName; + this.exists = exists; + + Connection conn = getConnection(); + + try { + this.allSchemas = DataProvider.getAllSchemasNames(conn); + + this.schemas = new HashMap(); + this.schemaKeys = new HashMap>(); + this.persisedSchemas = new ArrayList(); + this.toRemoveSchemas = new ArrayList(); + + this.allSchemaTables = new HashMap>(); + + this.columnsInfo = new ColumnsInfo(); + + if (exists) { + entityManager = DataProvider.getEntityManager(credentials, tapSchemaName); + CriteriaBuilder cb = entityManager.getCriteriaBuilder(); + CriteriaQuery cq = cb.createQuery(SchemaEntity.class); + for (SchemaEntity schemaEntity : entityManager.createQuery(cq).getResultList()) { + String schemaName = schemaEntity.getName(); + addSchema(schemaEntity); + addSchemaInfo(conn, schemaName); + persisedSchemas.add(schemaName); + for (TableEntity tableEntity : schemaEntity.getTables().values()) { + columnsInfo.addColumnsInfo(conn, schemaName, tableEntity.getTableName(), tableEntity.getColumns()); + } + } + } + + } catch (SQLException e) { + throw e; + } finally { + closeConnection(); + } + } + + private void addSchemaInfo(Connection connection, String schemaName) throws SQLException { + schemaKeys.put(schemaName, DataProvider.getSchemaKeys(connection, schemaName)); + allSchemaTables.put(schemaName, DataProvider.getAllTablesNames(connection, schemaName)); + } + + public SchemaEntity getNewSchema(String schemaName) throws SQLException { + SchemaEntity schemaEntity = new SchemaEntity(schemaName); + + Connection conn = getConnection(); + try { + addSchemaInfo(conn, schemaName); + } catch (SQLException e) { + throw e; + } finally { + closeConnection(); + } + + return schemaEntity; + } + + public final void addSchema(SchemaEntity schemaEntity) { + schemas.put(schemaEntity.getName(), schemaEntity); + } + + public final void removeSchema(String schemaName) { + if (persisedSchemas.contains(schemaName)) { + toRemoveSchemas.add(schemas.get(schemaName)); + persisedSchemas.remove(schemaName); + } + schemas.remove(schemaName); + } + + public Collection getSchemas() { + return schemas.values(); + } + + public List getAllSchemas() { + return allSchemas; + } + + public List getAllTables(String schemaName) { + return allSchemaTables.get(schemaName); + } + + public List getColumnInfo(String schemaName, String tableName) { + return columnsInfo.getColumnsInfo(schemaName, tableName); + } + + private int getMaxKey() { + int maxKey = 0; + for (SchemaEntity schemaEntity : schemas.values()) { + for (TableEntity tableEntity : schemaEntity.getTables().values()) { + for (KeyEntity keyEntity : tableEntity.getFromKeys()) { + int key = Integer.parseInt(keyEntity.getKeyId()); + if (key > maxKey) { + maxKey = key; + } + } + for (KeyEntity keyEntity : tableEntity.getTargetKeys()) { + int key = Integer.parseInt(keyEntity.getKeyId()); + if (key > maxKey) { + maxKey = key; + } + } + } + } + return maxKey; + } + + public TableEntity getNewTable(String schemaName, String tableName) throws SQLException { + + SchemaEntity schema = schemas.get(schemaName); + TableEntity table = new TableEntity(schemaName + "." + tableName); + + // Add table keys + int maxKey = getMaxKey(); + for (KeyEntity keyEntity : schemaKeys.get(schemaName)) { + String fromTable = keyEntity.getFromTableName(); + String targetTable = keyEntity.getTargetTableName(); + if (schema.getTables().containsKey(fromTable) + && schema.getTables().containsKey(targetTable)) { + String key = maxKey + ""; + keyEntity.setKeyId(key); + for (KeyColumnEntity keyColumn : keyEntity.getKeyColumns()) { + keyColumn.setKeyId(key); + } + + schema.getTables().get(fromTable).getFromKeys().add(keyEntity); + schema.getTables().get(targetTable).getTargetKeys().add(keyEntity); + + maxKey++; + } + } + + Connection conn = getConnection(); + try { + // Add columns info + // For performance reasons all possible column entities are loaded together + columnsInfo.addColumnsInfo(conn, schemaName, tableName, null); + } catch (SQLException e) { + throw e; + } finally { + closeConnection(); + } + + return table; + } + + public final Connection getConnection() throws SQLException { + if (connection == null) { + connection = credentials.getConnection(); + } + return connection; + } + + public final void closeConnection() throws SQLException { + if (connection != null) { + try { + connection.close(); + } catch (SQLException e) { + throw e; + } finally { + connection = null; + } + } + } + + public void save() throws SQLException { + if (!exists) { + try { + DataProvider.createDatabase(getConnection(), name); + } catch (SQLException e) { + throw e; + } finally { + closeConnection(); + } + entityManager = DataProvider.getEntityManager(credentials, name); + exists = true; + } + + entityManager.getTransaction().begin(); + for (SchemaEntity toRemoveSchema : toRemoveSchemas) { + entityManager.remove(toRemoveSchema); + } + for (SchemaEntity schemaEntity : schemas.values()) { + entityManager.persist(schemaEntity); + } + entityManager.getTransaction().commit(); + } +} diff --git a/TapSchemaManagerDL/src/main/resources/META-INF/persistence.xml b/TapSchemaManagerDL/src/main/resources/META-INF/persistence.xml new file mode 100644 index 0000000000000000000000000000000000000000..f677e29adcdfa8ad0574dfb19b299ba19cbd6e04 --- /dev/null +++ b/TapSchemaManagerDL/src/main/resources/META-INF/persistence.xml @@ -0,0 +1,16 @@ + + + + org.eclipse.persistence.jpa.PersistenceProvider + false + + + + + + + + + + + diff --git a/TapSchemaManagerDL/src/test/java/TestQuery.java b/TapSchemaManagerDL/src/test/java/TestQuery.java new file mode 100644 index 0000000000000000000000000000000000000000..c1f35cf90f7c0cfd46438f85791c5d08696ba6ec --- /dev/null +++ b/TapSchemaManagerDL/src/test/java/TestQuery.java @@ -0,0 +1,243 @@ + +import it.inaf.oats.ia2.tapschemamanager.datalayer.ColumnEntity; +import it.inaf.oats.ia2.tapschemamanager.datalayer.Credentials; +import it.inaf.oats.ia2.tapschemamanager.datalayer.SchemaEntity; +import it.inaf.oats.ia2.tapschemamanager.datalayer.TableEntity; +import it.inaf.oats.ia2.tapschemamanager.datalayer.TapSchemaHandler; +import java.sql.Connection; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.List; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import static org.junit.Assert.*; +import org.junit.Ignore; + +/** + * + * @author Sonia Zorba + */ +public class TestQuery { + + private static final int DATABASES_COUNT = 2; + private static final int TABLES_COUNT = 3; + private static Credentials credentials; + + public TestQuery() { + } + + @BeforeClass + public static void setUpClass() { + credentials = new Credentials(); + credentials.setHostname("localhost"); + credentials.setUsername("root"); + credentials.setPassword("root"); + } + + @AfterClass + public static void tearDownClass() { + } + + @Before + public void setUp() { + } + + @After + public void tearDown() { + } + + private void removeTestingDatabases(Credentials credentials) throws SQLException { + Connection connection = credentials.getConnection(); + Statement statement = connection.createStatement(); + for (int i = 0; i < DATABASES_COUNT; i++) { + statement.executeUpdate("DROP DATABASE IF EXISTS db" + i); + } + statement.executeUpdate("DROP DATABASE IF EXISTS test_tap_schema"); + statement.close(); + connection.close(); + } + + private void setUpTestingDatabases(Credentials credentials) throws SQLException { + removeTestingDatabases(credentials); + + Connection connection = credentials.getConnection(); + + Statement statement = connection.createStatement(); + for (int i = 0; i < DATABASES_COUNT; i++) { + statement.executeUpdate("CREATE DATABASE db" + i); + for (int j = 0; j < TABLES_COUNT; j++) { + statement.executeUpdate("CREATE TABLE db" + i + ".table" + j + " (\n" + + "id INT PRIMARY KEY AUTO_INCREMENT,\n" + + "value1 VARCHAR(255),\n" + + "value2 FLOAT\n" + + ");"); + } + } + statement.close(); + + connection.setCatalog("db0"); + + statement = connection.createStatement(); + for (int j = 0; j < TABLES_COUNT - 1; j++) { + statement.executeUpdate("ALTER TABLE table" + (j + 1) + " ADD COLUMN table" + j + "_id INT"); + statement.executeUpdate("ALTER TABLE table" + (j + 1) + " ADD CONSTRAINT id_constraint FOREIGN KEY(table" + j + "_id) REFERENCES table" + j + "(id)"); + } + statement.close(); + + connection.close(); + } + + @Test + public void loadSchema() throws SQLException { + TapSchemaHandler tapSchemaHandler = new TapSchemaHandler(credentials, "vlkb_voinfo_schema", true); + assertTrue(!tapSchemaHandler.getSchemas().isEmpty()); + } + + @Test + public void createNewAndUpdate() throws SQLException { + System.out.println("TEST createNewAndUpdate STARTED"); + + try { + setUpTestingDatabases(credentials); + + // TEST first TapSchema creation + TapSchemaHandler tsh = new TapSchemaHandler(credentials, "test_tap_schema", false); + + SchemaEntity db0 = tsh.getNewSchema("db0"); + tsh.addSchema(db0); + + // Test add, remove and re-add of a table + List db0Tables = tsh.getAllTables(db0.getName()); + + TableEntity db0table0 = tsh.getNewTable(db0.getName(), "table0"); + assertEquals(db0table0.getName(), "db0.table0"); + db0.addTable(db0table0); + TableEntity db0table1 = tsh.getNewTable(db0.getName(), "table1"); + + //db0table1.getFromKeys(); + + + tsh.save(); + assertNotNull(db0.getTables().get("db0.table0")); + + tsh = new TapSchemaHandler(credentials, "test_tap_schema", true); + db0 = tsh.getSchemas().iterator().next(); + db0.getTables().remove("db0.table0"); + assertNull(db0.getTables().get("db0.table0")); + tsh.save(); + + tsh = new TapSchemaHandler(credentials, "test_tap_schema", true); + db0 = tsh.getSchemas().iterator().next(); + assertNull(db0.getTables().get("db0.table0")); + + // Test key constraints + db0.addTable(db0table0); + + +// assertEquals(db0Tables.size(), TABLES_COUNT); +// for (String tableName : db0Tables) { +// tapSchemaHandler.get +// } +// +// TableEntity db0_ +// +// List addables = tapSchema.getAddables(); +// assertTrue(addables.contains("db0")); +// assertTrue(addables.contains("db1")); +// +// tapSchema.addEntityWrapper("db0"); +// assertFalse(tapSchema.getAddables().contains("db0")); +// +// Schema schema = tapSchema.getSchema("db0"); +// +// addables = schema.getAddables(); +// for (int i = 0; i < addables.size(); i++) { +// String tableName = addables.get(i); +// assertEquals(tableName, "table" + i); +// schema.addEntityWrapper(tableName); +// } +// assertTrue(schema.getAddables().isEmpty()); +// +// Table table1 = schema.getTable("table1"); +// assertEquals(table1.getName(), "table1"); +// assertEquals(table1.getFullName(), "db0.table1"); +// table1.addEntityWrapper("id"); +// table1.addEntityWrapper("value1"); +// assertFalse(table1.getAddables().contains("id")); +// assertTrue(table1.getAddables().contains("value2")); +// +// Column column = table1.getColumn("id"); +// column.setValue(Column.DESCRIPTION, "Test description"); +// assertTrue(column.isChanged()); +// column.setValue(Column.DESCRIPTION, ""); +// assertFalse(column.isChanged()); + } catch (SQLException e) { + throw e; + } finally { + removeTestingDatabases(credentials); + } + } + + @Ignore + @Test + public void query() throws SQLException { + +// EntityManagerFactory emf = Persistence.createEntityManagerFactory("pu"); +// EntityManager em = emf.createEntityManager(); + //CriteriaBuilder cb = em.getCriteriaBuilder(); + //CriteriaQuery cq = cb.createQuery(SchemaEntity.class); + //List results = em.createQuery(cq).getResultList(); +// SchemaEntity schema = new SchemaEntity("test_schema"); +// +// TableEntity table = new TableEntity("table1"); +// schema.addTable(table); +// +// ColumnEntity column = new ColumnEntity("table1_column1"); +// table.addColumn(column); + + //TapSchemaHandler tapSchemaHandler = new TapSchemaHandler(credentials, "TestJPA", false); + //statement = connection.createStatement(); + // String tapschemaName = tapSchema.getName(); + //creates database + //String queryString = "CREATE DATABASE IF NOT EXISTS " + tapschemaName + ";"; + //statement.executeUpdate(queryString); + //em.getTransaction().begin(); +// for (SchemaEntity schema : results) { +// System.out.println("schema = " + schema.getSchemaName()); +// for (TableEntity table : schema.getTables().values()) { +// System.out.println("table = " + table.getTableName()); +// } +// +//// if (schema.getSchemaName().equals("geo")) { +//// Map tables = schema.getTables(); +//// TableEntity table = schema.getTables().get("geo.country_block_ipv4"); +//// //em.remove(table); +////// for (ColumnEntity column : table.getColumns().values()) { +////// System.out.println("column = " + column.getColumnName()); +////// column.setDescription("testDescription"); +////// } +//// break; +//// } +// } + //em.getTransaction().commit(); + //results.get(i) +// for (SchemaEntity schema : results) { +// System.out.println("schema = " + schema.getSchemaName()); +// for (TableEntity table : schema.getTables()) { +// System.out.println("table = " + table.getTableName()); +// for (ColumnEntity column : table.getColumns()) { +// System.out.println("column = " + column.getColumnName()); +// } +// for (KeyEntity fromKey : table.getFromKeys()) { +// System.out.println("fromKey = " + fromKey.getKeyId()); +// } +// for (KeyEntity targetKey : table.getTargetKeys()) { +// System.out.println("targetKey = " + targetKey.getKeyId()); +// } +// } +// } + } +} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Column.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Column.java deleted file mode 100644 index bdf93c85e9946c164f2f934871975e821f9e71ed..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Column.java +++ /dev/null @@ -1,258 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.sql.Connection; -import java.sql.PreparedStatement; -import java.sql.SQLException; - -/** - * - * @author pietro - */ -public class Column extends DbEntity { - - // editable properties - public static final String UTYPE = "utype"; - public static final String UCD = "ucd"; - public static final String UNIT = "unit"; - public static final String DESCRIPTION = "description"; - public static final String STD = "std"; - - // uneditable properties - //public static final String DESCRIPTION = "description"; - private String tableName; - private String name; - -// private final EditableValue utype; -// private final EditableValue ucd; -// private final EditableValue unit; -// private final EditableValue description; -// private final EditableValue std; - private String datatype; - private int size; - - private boolean isPrimaryKey; - private boolean isForeignKey; - private boolean principal; - private boolean indexed; - - public Column() { - super(UTYPE, UCD, UNIT, DESCRIPTION, STD); - setStatus(Status.NOT_SELECTED); - -// utype = new EditableValue(); -// ucd = new EditableValue(); -// unit = new EditableValue(); -// description = new EditableValue(); -// std = new EditableValue(); - } - -// public EditableValue getUtypeEditableValue() { -// return utype; -// } -// -// public EditableValue getUcdEditableValue() { -// return ucd; -// } -// -// public EditableValue getUnitEditableValue() { -// return unit; -// } -// -// public EditableValue getDescriptionEditableValue() { -// return description; -// } -// -// public EditableValue getStdEditableValue() { -// return std; -// } -// private void setValue(ColumnField key, Serializable value) { -// if (properties.containsKey(key)) { -// properties.get(key).setValue(value); -// } else { -// properties.put(key, new EditableValue(value)); -// } -// } -// private Object getValue(ColumnField key) { -// EditableValue value = properties.get(key); -// if (value != null) { -// return value.getValue(); -// } -// return null; -// } -// private boolean checked; - public String getTableName() { - return tableName; - } - - public void setTableName(String tableName) { - this.tableName = tableName; - } - - @Override - public String getName() { - return name; - } - - public void setName(String columnName) { - this.name = columnName; - } - -// public String getUtype() { -// return getValue(UTYPE); -// } -// -// public void setUtype(String utype) { -// setValue(UTYPE, utype); -// } -// -// public String getUcd() { -// return getValue(UCD); -// } -// -// public void setUcd(String ucd) { -// setValue(UCD, ucd); -// } -// -// public String getUnit() { -// return getValue(UNIT); -// } -// -// public void setUnit(String unit) { -// setValue(UNIT, unit); -// } -// -// public String getDescription() { -// return getValue(DESCRIPTION); -// } -// -// public void setDescription(String description) { -// setValue(DESCRIPTION, description); -// } - public String getDatatype() { - return datatype; - } - - public void setDatatype(String datatype) { - this.datatype = datatype; - } - - public int getSize() { - return size; - } - - public void setSize(int size) { - this.size = size; - } - - public boolean getPrincipal() { - return principal; - } - - public void setPrincipal(boolean principal) { - this.principal = principal; - } - - public boolean getIndexed() { - return indexed; - } - - public void setIndexed(boolean indexed) { - this.indexed = indexed; - } - - public boolean getStd() { - return Boolean.parseBoolean(getValue(STD)); - } - - public void setStd(boolean std) { - setValue(STD, std + ""); - } - - public boolean isPrimaryKey() { - return isPrimaryKey; - } - - public void setIsPrimaryKey(boolean value) { - isPrimaryKey = value; - } - - public boolean isForeignKey() { - return isForeignKey; - } - - public void setIsForeignKey(boolean value) { - isForeignKey = value; - } - -// @Override -// public String getOriginalValue(String key) { -// if (key.equals(UTYPE)) { -// return this.getUtype(); -// } -// if (key.equals(UCD)) { -// return this.getUcd(); -// } -// if (key.equals(UNIT)) { -// return this.getUnit(); -// } -// if (key.equals(DESCRIPTION)) { -// return this.getDescription(); -// } -// if (key.equals(STD)) { -// return this.getStd() + ""; -// } -// return null; -// } - @Override - public void update(Connection connection) throws SQLException { - PreparedStatement statement = null; - try { - statement = connection.prepareStatement("UPDATE `columns` " - + "SET utype = ?, ucd = ?, unit = ?, description = ?, std = ? " - + "WHERE column_name = ? AND table_name = ?"); - statement.setString(1, getValue(UTYPE)); - statement.setString(2, getValue(UCD)); - statement.setString(3, getValue(UNIT)); - statement.setString(4, getValue(DESCRIPTION)); - statement.setInt(5, Boolean.parseBoolean(getValue(STD)) ? 1 : 0); - statement.setString(6, getName()); - statement.setString(7, getTableName()); - statement.executeUpdate(); - } catch (SQLException e) { - throw e; - } finally { - if (statement != null) { - statement.close(); - } - } - } - - @Override - public void insert(Connection connection) throws SQLException { - PreparedStatement statement = null; - try { - statement = connection.prepareStatement("INSERT INTO `columns` " - + "(table_name, column_name, utype, ucd, unit, description, " - + "datatype, size, principal, indexed, std, columnID) " - + "VALUES(?,?,?,?,?,?,?,?,?,?,?,null)"); - statement.setString(1, getTableName()); - statement.setString(2, getName()); - statement.setString(3, getValue(UTYPE)); - statement.setString(4, getValue(UCD)); - statement.setString(5, getValue(UNIT)); - statement.setString(6, getValue(DESCRIPTION)); - statement.setString(7, getDatatype()); - statement.setInt(8, getSize()); - statement.setInt(9, getPrincipal() ? 1 : 0); - statement.setInt(10, getIndexed() ? 1 : 0); - statement.setInt(11, Boolean.parseBoolean(getValue(STD)) ? 1 : 0); - statement.executeUpdate(); - } catch (SQLException e) { - throw e; - } finally { - if (statement != null) { - statement.close(); - } - } - } -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/ColumnField.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/ColumnField.java deleted file mode 100644 index 8651291aeeb5a85e40d1029fd6dbf6d347a4aeb0..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/ColumnField.java +++ /dev/null @@ -1,20 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -/** - * - * @author Sonia Zorba - */ -public enum ColumnField { - - TABLE_NAME, - COLUMN_NAME, - UTYPE, - UCD, - UNIT, - DESCRIPTION, - DATATYPE, - SIZE, - PRINCIPAL, - INDEXED, - STD -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/ConnectionManager.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/ConnectionManager.java deleted file mode 100644 index ebfc19ac9109566e34b1b0f9484ec931db12f87f..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/ConnectionManager.java +++ /dev/null @@ -1,33 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.sql.Connection; -import java.sql.SQLException; - -/** - * - * @author Sonia Zorba - */ -public abstract class ConnectionManager { - - private final Credentials credentials; - - public ConnectionManager(Credentials credentials) { - this.credentials = credentials; - } - - public void connect() throws SQLException { - Connection connection = null; - try { - connection = credentials.getConnection(); - use(connection); - } catch (SQLException e) { - throw e; - } finally { - if (connection != null) { - connection.close(); - } - } - } - - public abstract void use(Connection connection) throws SQLException; -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/DbEntity.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/DbEntity.java deleted file mode 100644 index 267a16f56b49e0dbe759ea39faa912594da19c43..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/DbEntity.java +++ /dev/null @@ -1,142 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.sql.Connection; -import java.sql.SQLException; -import java.util.Collection; -import java.util.HashMap; -import java.util.Map; - -/** - * Object that keeps track of changes in the value that it wraps. - */ -class EditableValue { - - String originalValue; - String newValue; - - EditableValue(String value) { - setValue(value); - } - - String getValue() { - return newValue; - } - - final void setValue(String value) { - originalValue = value; - newValue = value; - } - - void updateValue(String value) { - newValue = value; - } - - boolean isChanged() { - if (originalValue == null) { - return newValue != null && !newValue.equals(""); - } - return !originalValue.equals(newValue); - } -} - -/** - * - * @author Sonia Zorba - */ -public abstract class DbEntity { - - private Status status; - - private final HashMap values = new HashMap(); - - public DbEntity(String... supportedValues) { - for (String key : supportedValues) { - setValue(key, null); - } - } - - public final void setValue(String key, String value) { - EditableValue editableValue = values.get(key); - if (editableValue == null) { - editableValue = new EditableValue(value); - values.put(key, editableValue); - } else { - editableValue.setValue(value); - } - } - - public boolean updateValue(String key, String value) { - EditableValue editableValue = values.get(key); - editableValue.updateValue(value); - return editableValue.isChanged(); - } - - public String getValue(String key) { - EditableValue editableValue = values.get(key); - if (editableValue != null) { - return editableValue.getValue(); - } - return null; - } - - public boolean isChanged(String key) { - EditableValue editableValue = values.get(key); - if (editableValue != null) { - return editableValue.isChanged(); - } - return false; - } - - public Collection getSupportedValues() { - return values.keySet(); - } - - public Status getStatus() { - return status; - } - - public void setStatus(Status status) { - this.status = status; - } - - public boolean hasChanges() { - for (EditableValue value : values.values()) { - if (value.isChanged()) { - return true; - } - } - return false; - } - - public Map getChanges() { - Map changes = new HashMap(); - for (String key : values.keySet()) { - EditableValue editableValue = values.get(key); - if (editableValue != null) { - changes.put(key, editableValue.getValue()); - } - } - return changes; - } - - public void setUpdated() { - if (getStatus() == Status.SELECTED_TO_SAVE) { - setStatus(Status.SELECTED_SAVED); - } - for (EditableValue value : values.values()) { - value.setValue(value.getValue()); - } - } - - public void setOriginalValues() { - for (EditableValue value : values.values()) { - value.newValue = value.originalValue; - } - } - - public abstract String getName(); - - public abstract void insert(Connection connection) throws SQLException; - - public abstract void update(Connection connection) throws SQLException; -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/IDbEntitiesContainer.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/IDbEntitiesContainer.java deleted file mode 100644 index 4211b270adfc5e87db63e47cce433070af928452..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/IDbEntitiesContainer.java +++ /dev/null @@ -1,34 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.sql.Connection; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.List; - -/** - * - * @author Sonia Zorba - */ -public interface IDbEntitiesContainer { - - //public List getAdded(); - public ArrayList getAddables(); - - //public boolean canAdd(); - public void loadEntities(Connection connection, List selectedEntities) throws SQLException; - - public void addEntity(String name, DbEntity entity); - - public void removeEntity(String name); - - public ArrayList getAllEntities(); - - public DbEntity getSelected(); - - public void select(String name); - - /** - * After SQL Update refresh all child status values - */ - public void update(); -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Key.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Key.java deleted file mode 100644 index 241d28a75075985bcce33d5254424a092a5c71ac..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Key.java +++ /dev/null @@ -1,62 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.io.Serializable; -import java.util.ArrayList; -import java.util.List; - -/** - * - * @author pietro - */ -public class Key implements Serializable { - - private String keyId; - private final String fromTable; - private final String targetTable; - private String utype; - private String description; - private final ArrayList keyColumns; - - public Key(String fromTable, String targetTable) { - this.fromTable = fromTable; - this.targetTable = targetTable; - this.keyColumns = new ArrayList(); - } - - public void addKeyColumn(String fromColumn, String targetColumn) { - keyColumns.add(new KeyColumn(fromColumn, targetColumn)); - } - - public void setKeyId(String keyId) { - this.keyId = keyId; - } - - public void setUtype(String utype) { - this.utype = utype; - } - - public void setDescription(String description) { - this.description = description; - } - - public String getFromTable() { - return fromTable; - } - - public String getTargetTable() { - return targetTable; - } - - public boolean hasFromKeyColumn(String keyColumnName) { - for (KeyColumn keyColumn : keyColumns) { - if (keyColumn.getFromColumn().equals(keyColumnName)) { - return true; - } - } - return false; - } - - public List getKeyColumns() { - return keyColumns; - } -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/KeyColumn.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/KeyColumn.java deleted file mode 100644 index b3c50d0135ec9dc848b891e6d299fcbf08ff3d0b..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/KeyColumn.java +++ /dev/null @@ -1,27 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.io.Serializable; - -/** - * - * @author pietro - */ -public class KeyColumn implements Serializable { - - //public String key_id; - private final String fromColumn; - private final String targetColumn; - - public KeyColumn(String fromColumn, String targetColumn) { - this.fromColumn = fromColumn; - this.targetColumn = targetColumn; - } - - public String getFromColumn() { - return fromColumn; - } - - public String getTargetColumn() { - return targetColumn; - } -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Schema.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Schema.java deleted file mode 100644 index 7bfbbde3c11d29303b6572885c26a853da0c921b..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Schema.java +++ /dev/null @@ -1,274 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.io.Serializable; -import java.sql.Connection; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -/** - * - * @author pietro - */ -public class Schema extends DbEntity implements IDbEntitiesContainer, Serializable { - - public static final String UTYPE = "utype"; - public static final String DESCRIPTION = "description"; - - private final String name; - private final String tapSchemaName; - -// private final EditableValue utype; -// private final EditableValue description; - //private String utype; - //private String description; - private final Map tablesMap; - //private final Map keysMap; - private final List keysInfo; - - private String selectedTable; - - public Schema(Connection connection, String schemaName, String tapSchemaName, boolean toCreate) throws SQLException { - super(UTYPE, DESCRIPTION); - - this.name = schemaName; - this.tapSchemaName = tapSchemaName; - setStatus(Status.NOT_SELECTED); - - tablesMap = new HashMap(); - for (String tableName : SchemaDL.getAllTablesNames(connection, schemaName)) { - tablesMap.put(tableName, null); - } - - keysInfo = new ArrayList(); - (new ResultSetReader("SELECT k.TABLE_NAME, k.COLUMN_NAME, " - + "k.REFERENCED_TABLE_NAME, k.REFERENCED_COLUMN_NAME " - + "FROM information_schema.TABLE_CONSTRAINTS i " - + "LEFT JOIN information_schema.KEY_COLUMN_USAGE k " - + "ON i.CONSTRAINT_NAME = k.CONSTRAINT_NAME " - + "WHERE i.CONSTRAINT_TYPE = 'FOREIGN KEY' " - + "AND i.TABLE_SCHEMA = '" + schemaName + "' " - + "AND k.TABLE_SCHEMA = '" + schemaName + "'") { - - @Override - public void manipulateItem(ResultSet resultSet) throws SQLException { - addKey( - resultSet.getString("k.TABLE_NAME"), - resultSet.getString("k.REFERENCED_TABLE_NAME"), - resultSet.getString("k.COLUMN_NAME"), - resultSet.getString("k.REFERENCED_COLUMN_NAME") - ); - } - }).read(connection); - - //keysMap = new HashMap(); - //SchemaDL.setKeysMap(connection, tapSchemaName, schemaName, keysMap); - if (!toCreate) { - SchemaDL.loadSavedTables(connection, tapSchemaName, (this), toCreate); - } - -// utype = new EditableValue(); -// description = new EditableValue(); - } - - private void addKey(String fromTable, String targetTable, String fromColumn, String targetColumn) { - fromTable = getName() + "." + fromTable; - targetTable = getName() + "." + targetTable; - - Key key = null; - for (Key k : keysInfo) { - if (k.getFromTable().equals(fromTable) && k.getTargetTable().equals(targetTable)) { - key = k; - } - } - - if (key == null) { - key = new Key(fromTable, targetTable); - keysInfo.add(key); - } - - key.addKeyColumn(fromColumn, targetColumn); - } - - @Override - public void loadEntities(Connection connection, List selectedTables) throws SQLException { - for (String tableName : selectedTables) { - Table table = SchemaDL.loadTable(connection, tapSchemaName, this, tableName); - table.setStatus(Status.SELECTED_TO_SAVE); - addEntity(tableName, table); - } - select(selectedTables.get(selectedTables.size() - 1)); - } - - public Table getTable(String tableName) { - return tablesMap.get(tableName); - } - - @Override - public String getName() { - return name; - } - -// public EditableValue getUtypeEditableValue() { -// return utype; -// } -// -// public String getUtype() { -// return utype.getValue(); -// } -// -// public void setUtype(String utype) { -// this.utype.setValue(utype); -// } -// public EditableValue getDescriptionEditableValue() { -// return description; -// } -// public String getDescription() { -// return this.description.getValue(); -// } -// -// public void setDescription(String description) { -// this.description.setValue(description); -// } - @Override - public void addEntity(String tableName, DbEntity table) { - tablesMap.put(tableName, (Table) table); - } - -// public Collection getTablesNames() { -// return tablesMap.keySet(); -// } - @Override - public ArrayList getAllEntities() { - ArrayList list = new ArrayList(); - for (Table table : tablesMap.values()) { - if (table != null) { - list.add(table); - } - } - return list; - } - - @Override - public ArrayList getAddables() { - ArrayList addableTables = new ArrayList(); - - for (String tableName : tablesMap.keySet()) { - if (tablesMap.get(tableName) == null) { - addableTables.add(tableName); - } - } - - return addableTables; - } - - @Override - public void removeEntity(String tableName) { - Table table = getTable(tableName); - if (table.getStatus() == Status.SELECTED_SAVED) { - table.setStatus(Status.TO_REMOVE); - } - if (table.getStatus() == Status.SELECTED_TO_SAVE) { - tablesMap.put(tableName, null); - ArrayList entities = getAllEntities(); - if (!entities.isEmpty()) { - select(entities.get(0).getName()); - } - } - } - - public boolean isForeignKey(String tableName, String columnName) { - for (Key key : keysInfo) { - if (key.getFromTable().equals(tableName) && key.hasFromKeyColumn(columnName)) { - return true; - } - } - return false; - } - -// @Override -// public String getOriginalValue(String key) { -// if (key.equals(UTYPE)) { -// return this.getUtype(); -// } -// if (key.equals(DESCRIPTION)) { -// return this.getDescription(); -// } -// return null; -// } - @Override - public DbEntity getSelected() { - return tablesMap.get(selectedTable); - } - - @Override - public void select(String name) { - selectedTable = name; - - // select first column - Table table = tablesMap.get(selectedTable); - ArrayList columns = table.getAllEntities(); - if (!columns.isEmpty()) { - table.select(columns.get(0).getName()); - } - } - - @Override - public void insert(Connection connection) throws SQLException { - PreparedStatement statement = null; - try { - statement = connection.prepareStatement("INSERT INTO `schemas` (schema_name, utype, description, schemaID) " - + "VALUES(?, ?, ? , null);"); - statement.setString(1, getName()); - statement.setString(2, getValue(UTYPE)); - statement.setString(3, getValue(DESCRIPTION)); - statement.executeUpdate(); - } catch (SQLException e) { - throw e; - } finally { - if (statement != null) { - statement.close(); - } - } - } - - @Override - public void update(Connection connection) throws SQLException { - PreparedStatement statement = null; - try { - statement = connection.prepareStatement("UPDATE `schemas` " - + "SET utype = ?, description = ? WHERE schema_name = ?"); - statement.setString(1, getValue(UTYPE)); - statement.setString(2, getValue(DESCRIPTION)); - statement.setString(3, getName()); - statement.executeUpdate(); - } catch (SQLException e) { - throw e; - } finally { - if (statement != null) { - statement.close(); - } - } - } - - public List getKeys() { - return keysInfo; - } - - @Override - public void update() { - setUpdated(); - for (DbEntity tableEntity : getAllEntities()) { - Table table = (Table) tableEntity; - if (table.getStatus() == Status.TO_REMOVE) { - tablesMap.put(table.getName(), null); - } else { - table.update(); - } - } - } -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/SchemaDL.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/SchemaDL.java deleted file mode 100644 index a6069f2850e66030a2374c9980e449e14c4607fa..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/SchemaDL.java +++ /dev/null @@ -1,97 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.sql.Connection; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Map; - -/** - * - * @author Sonia Zorba - */ -public class SchemaDL { - - public static ArrayList getAllTablesNames(Connection connection, String schemaName) throws SQLException { - final ArrayList allTables = new ArrayList(); - - (new ResultSetReader("SHOW TABLES FROM " + schemaName + ";") { - - @Override - public void manipulateItem(ResultSet resultSet) throws SQLException { - allTables.add(resultSet.getString(1)); - } - }).read(connection); - - return allTables; - } - - public static void setKeysMap(final Connection connection, final String tapSchemaName, final String schemaName, final Map keysMap) throws SQLException { - - final HashMap keys = new HashMap(); - - (new ResultSetReader("SELECT k.CONSTRAINT_NAME, k.TABLE_NAME, k.COLUMN_NAME, " - + "k.REFERENCED_TABLE_NAME, k.REFERENCED_COLUMN_NAME " - + "FROM information_schema.TABLE_CONSTRAINTS i " - + "LEFT JOIN information_schema.KEY_COLUMN_USAGE k " - + "ON i.CONSTRAINT_NAME = k.CONSTRAINT_NAME " - + "WHERE i.CONSTRAINT_TYPE = 'FOREIGN KEY' " - + "AND i.TABLE_SCHEMA = '" + schemaName + "' " - + "AND k.TABLE_SCHEMA = '" + schemaName + "';") { - - @Override - public void manipulateItem(ResultSet resultSet) throws SQLException { - String constraintName = resultSet.getString("k.CONSTRAINT_NAME"); - String fromTable = schemaName + "." + resultSet.getString("k.TABLE_NAME"); - String targetTable = schemaName + "." + resultSet.getString("k.REFERENCED_TABLE_NAME"); - String fromColumn = resultSet.getString("k.COLUMN_NAME"); - String targetColumn = resultSet.getString("k.REFERENCED_COLUMN_NAME"); - - Key key = keys.get(constraintName); - if (key == null) { - String keyId = "" + keys.size() + 1; - key = new Key(fromTable, targetTable); - keys.put(constraintName, key); - keysMap.put(keyId, key); - } - key.addKeyColumn(fromColumn, targetColumn); - } - }).read(connection); - } - - public static Table loadTable(final Connection connection, final String tapSchemaName, final Schema schema, final String tableName) throws SQLException { - Table table = new Table(connection, tapSchemaName, schema, tableName, true); - for (DbEntity column : table.getAllEntities()) { - // Select all table columns by default - column.setStatus(Status.SELECTED_TO_SAVE); - } - return table; - } - - public static void loadSavedTables(final Connection connection, final String tapSchemaName, final Schema schema, final boolean toCreate) throws SQLException { - - (new ResultSetReader("SELECT * FROM " + tapSchemaName + ".tables " - + "WHERE schema_name='" + schema.getName() + "';") { - - @Override - public void manipulateItem(ResultSet resultSet) throws SQLException { - - String tableName = resultSet.getString("table_name"); - // Removing schema prefix from table name - if (tableName.startsWith(schema.getName() + ".")) { - tableName = tableName.substring(schema.getName().length() + 1); - } - - Table table = new Table(connection, tapSchemaName, schema, tableName, toCreate); - - table.setValue(Table.UTYPE, resultSet.getString("utype")); - table.setValue(Table.DESCRIPTION, resultSet.getString("description")); - - table.setStatus(Status.SELECTED_SAVED); - schema.addEntity(tableName, table); - } - }).read(connection); - } - -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Status.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Status.java deleted file mode 100644 index 7da73e64b7bd6b7d759ab00bcbee2ead7137afce..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Status.java +++ /dev/null @@ -1,12 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -/** - * - * @author Sonia Zorba - */ -public enum Status { - NOT_SELECTED, - SELECTED_SAVED, - SELECTED_TO_SAVE, - TO_REMOVE -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Table.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Table.java deleted file mode 100644 index 1ac7048b853cebef0a22d55af69cb9cf210c4ae2..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/Table.java +++ /dev/null @@ -1,211 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.io.Serializable; -import java.sql.Connection; -import java.sql.PreparedStatement; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -/** - * - * @author pietro - */ -public class Table extends DbEntity implements IDbEntitiesContainer, Serializable { - - public static final String UTYPE = "utype"; - public static final String DESCRIPTION = "description"; - - private final Schema schema; - private final String tableName; - private final Map columnsMap; - - public String tableType; // table || view -// private String utype; -// private String description; - - private String selectedColumn; - - public Table(Connection connection, String tapSchemaName, Schema schema, String tableName, boolean toCreate) throws SQLException { - super(UTYPE, DESCRIPTION); - - this.tableName = tableName; - this.schema = schema; - this.columnsMap = new HashMap(); - setStatus(Status.NOT_SELECTED); - - TableDL.loadAllColumns(connection, tapSchemaName, schema.getName(), (this)); - - if (!toCreate) { - TableDL.loadSavedColumns(connection, tapSchemaName, schema.getName(), (this)); - } - } - - public Map getColumnsMap() { - return columnsMap; - } - - @Override - public void addEntity(String key, DbEntity column) { - columnsMap.put(key, (Column) column); - } - - @Override - public ArrayList getAddables() { - ArrayList addablesColumns = new ArrayList(); - - for (Column column : columnsMap.values()) { - if (column.getStatus() == Status.NOT_SELECTED) { - addablesColumns.add(column.getName()); - } - } - - return addablesColumns; - } - - @Override - public ArrayList getAllEntities() { - ArrayList list = new ArrayList(); - for (Column column : columnsMap.values()) { - if (column.getStatus() != Status.NOT_SELECTED) { - list.add(column); - } - } - return list; - } - - public Column getColumn(String columnName) { - return columnsMap.get(columnName); - } - - @Override - public String getName() { - return tableName; - } - - public String getFullName() { - return schema.getName() + "." + tableName; - } - -// public String getUtype() { -// return utype; -// } -// -// public void setUtype(String utype) { -// this.utype = utype; -// } -// -// public String getDescription() { -// return description; -// } -// -// public void setDescription(String description) { -// this.description = description; -// } - @Override - public void loadEntities(Connection connection, List selectedEntities) throws SQLException { - for (String columnName : selectedEntities) { - getColumn(columnName).setStatus(Status.SELECTED_TO_SAVE); - } - select(selectedEntities.get(selectedEntities.size() - 1)); - } - - @Override - public void removeEntity(String name) { - Column column = getColumn(name); - if (column.getStatus() == Status.SELECTED_SAVED) { - column.setStatus(Status.TO_REMOVE); - } else { - column.setStatus(Status.NOT_SELECTED); - ArrayList entities = getAllEntities(); - if (!entities.isEmpty()) { - select(entities.get(0).getName()); - } - } - } - - public boolean isForeignKey(String columnName) { - return schema.isForeignKey(getFullName(), columnName); - } - - @Override - public DbEntity getSelected() { - return columnsMap.get(selectedColumn); - } - - @Override - public void select(String name) { - selectedColumn = name; - } - -// @Override -// public String getOriginalValue(String key) { -// if (key.equals(UTYPE)) { -// return this.getUtype(); -// } -// if (key.equals(DESCRIPTION)) { -// return this.getDescription(); -// } -// return null; -// } - public String getSchemaName() { - return schema.getName(); - } - - @Override - public void insert(Connection connection) throws SQLException { - PreparedStatement statement = null; - try { - statement = connection.prepareStatement("INSERT INTO `tables` " - + "(schema_name, table_name, table_type, utype, description, tableID) " - + "VALUES(?, ?, ?, ?, ?, null)"); - statement.setString(1, getSchemaName()); - statement.setString(2, getFullName()); - statement.setString(3, "table"); - statement.setString(4, getValue(UTYPE)); - statement.setString(5, getValue(DESCRIPTION)); - statement.executeUpdate(); - } catch (SQLException e) { - throw e; - } finally { - if (statement != null) { - statement.close(); - } - } - } - - @Override - public void update(Connection connection) throws SQLException { - PreparedStatement statement = null; - try { - statement = connection.prepareStatement("UPDATE `tables` " - + "SET utype = ?, description = ? WHERE table_name = ?"); - statement.setString(1, getValue(UTYPE)); - statement.setString(2, getValue(DESCRIPTION)); - statement.setString(3, getFullName()); - statement.executeUpdate(); - } catch (SQLException e) { - throw e; - } finally { - if (statement != null) { - statement.close(); - } - } - } - - @Override - public void update() { - setUpdated(); - for (String columnName : columnsMap.keySet()) { - Column column = columnsMap.get(columnName); - if (column.getStatus() == Status.TO_REMOVE) { - column.setOriginalValues(); - column.setStatus(Status.NOT_SELECTED); - } else { - column.setUpdated(); - } - } - } -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/TableDL.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/TableDL.java deleted file mode 100644 index ddc0a74661f987c662a23a7a475ee440466a7227..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/TableDL.java +++ /dev/null @@ -1,151 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.sql.Connection; -import java.sql.ResultSet; -import java.sql.SQLException; - -/** - * - * @author Sonia Zorba - */ -public class TableDL { - - private static boolean equalsOneOf(String string, String... values) { - for (String value : values) { - if (string.equals(value)) { - return true; - } - } - return false; - } - - // updates variables of current column structure - public static void loadAllColumns(Connection connection, final String tapSchemaName, final String schemaName, final Table table) throws SQLException { - - (new ResultSetReader("SHOW COLUMNS FROM " + schemaName + "." + table.getName() + ";") { - - @Override - public void manipulateItem(ResultSet resultSet) throws SQLException { - - Column column = new Column(); - column.setTableName(table.getFullName()); - column.setStatus(Status.NOT_SELECTED); - - // Key - String key = resultSet.getString("Key"); - column.setPrincipal(key.equals("PRI")); - column.setIsPrimaryKey(key.equals("PRI")); - column.setIndexed(equalsOneOf(key, "PRI", "UNI", "MUL")); - - // Datatype and Size - String type = resultSet.getString("Type").toLowerCase(); - - int size = 0; - String datatype; - if (type.startsWith("int")) { - datatype = "adql:INTEGER"; - } else if (type.startsWith("smallint")) { - datatype = "adql:SMALLINT"; - } else if (type.startsWith("bigint")) { - datatype = "adql:BIGINT"; - } else if (type.startsWith("float")) { - datatype = "adql:REAL"; - } else if (type.startsWith("char")) { - int beginIndex = type.indexOf('('); - int endIndex = type.indexOf(')'); - size = Integer.parseInt(type.substring(beginIndex + 1, endIndex)); - datatype = "adql:CHAR"; - } else if (type.startsWith("varchar")) { - int beginIndex = type.indexOf('('); - int endIndex = type.indexOf(')'); - size = Integer.parseInt(type.substring(beginIndex + 1, endIndex)); - datatype = "adql:VARCHAR"; - } else if (type.contains("timestamp")) { - datatype = "adql:TIMESTAMP"; - } else { - datatype = "adql:" + type.toUpperCase(); - } - column.setDatatype(datatype); - column.setSize(size); - - // Column name - String columnName = resultSet.getString("Field"); - column.setName(columnName); - - // STD - boolean std = false; - if ((schemaName.equals(tapSchemaName)) - && !equalsOneOf(columnName, "schemaID", "tableID", "columnID", "keyID", "key_columnID")) { - std = true; - } - column.setStd(std); - - column.setIsForeignKey(table.isForeignKey(columnName)); - table.addEntity(columnName, column); - } - }).read(connection); - } - - public static void loadSavedColumns(Connection connection, final String tapSchemaName, final String schemaName, final Table table) throws SQLException { - - (new ResultSetReader("SELECT * FROM " + tapSchemaName + ".columns " - + "WHERE table_name='" + schemaName + "." + table.getName() + "';") { - - @Override - public void manipulateItem(ResultSet columnsResultSet) throws SQLException { - - Column column = table.getColumn(columnsResultSet.getString("column_name")); - column.setStatus(Status.SELECTED_SAVED); - - // updates variables of current column structure - column.setTableName(columnsResultSet.getString("table_name")); - column.setValue(Column.UTYPE, columnsResultSet.getString("utype")); - column.setValue(Column.UCD, columnsResultSet.getString("ucd")); - column.setValue(Column.UNIT, columnsResultSet.getString("unit")); - column.setValue(Column.DESCRIPTION, columnsResultSet.getString("description")); - column.setDatatype(columnsResultSet.getString("datatype")); - column.setSize(columnsResultSet.getInt("size")); - column.setPrincipal(columnsResultSet.getInt("principal") == 1); - column.setIndexed(columnsResultSet.getInt("indexed") == 1); - column.setStd(columnsResultSet.getInt("std") == 1); - - //column.checked = true; - //search if foreign key -// statement = connection.createStatement(); -// queryString = "SELECT * FROM " + tapschemaName + ".keys " -// + "INNER JOIN " + tapschemaName + ".key_columns " -// + "USING (key_id) " -// + "WHERE " + tapschemaName + ".keys.from_table='" + column.getTableName() + "' " -// + "AND " + tapschemaName + ".key_columns.from_column='" + column.getColumnName() + "';"; -// keysResultSet = statement.executeQuery(queryString); -// -// statement = connection.createStatement(); -// queryString = "SELECT * FROM " + tapschemaName + ".keys " -// + "INNER JOIN " + tapschemaName + ".key_columns " -// + "USING (key_id) " -// + "WHERE " + tapschemaName + ".keys.target_table='" + column.getTableName() + "' " -// + "AND " + tapschemaName + ".key_columns.target_column='" + column.getColumnName() + "';"; -// foreignKeysResultSet = statement.executeQuery(queryString); -// while (keysResultSet.next()) { -// while (foreignKeysResultSet.next()) { -// for (Key key : schema.keysMap.values()) { -// for (KeyColumn key_column : schema.key_columnsMap.values()) { -// if (key.from_table.equals(keysResultSet.getString("from_table")) -// && key_column.from_column.equals(foreignKeysResultSet.getString("from_column")) -// && keysResultSet.getString("key_id").equals(foreignKeysResultSet.getString("key_id"))) { -// // updates variables of current key structure -// key.key_id = keysResultSet.getString("key_id"); -// key.utype = keysResultSet.getString("utype"); -// key.description = keysResultSet.getString("description"); -// -// // updates variables of current key_column structure -// key_column.key_id = foreignKeysResultSet.getString("key_id"); -// } -// } -// } -// } -// } - } - }).read(connection); - } -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/TapSchema.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/TapSchema.java deleted file mode 100644 index e484c71595d425a65fbdf46968fcbcf8106fea4b..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/TapSchema.java +++ /dev/null @@ -1,185 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.io.Serializable; -import java.sql.Connection; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -/** - * - * @author pietro - */ -public class TapSchema implements Serializable, IDbEntitiesContainer { - - private final String name; - private boolean toCreate; - //private final ArrayList allSchemas; - - // current schemas (saved, added or to remove) - private final Map schemasMap; - - private String selectedSchema; - - // For EXISTING TAP Schemas - public TapSchema(Connection connection, String tapSchemaName) throws SQLException { - this(connection, tapSchemaName, false, null); - toCreate = false; - } - - // For NEW TAP Schemas - public TapSchema(Connection connection, String tapSchemaName, ArrayList selectedSchemas) throws SQLException { - this(connection, tapSchemaName, true, selectedSchemas); - } - - private TapSchema(final Connection connection, String tapSchemaName, boolean toCreate, ArrayList selectedSchemas) throws SQLException { - this.name = tapSchemaName; - this.toCreate = toCreate; - - schemasMap = new HashMap(); - for (String schemaName : TapSchemaDL.getAllSchemasNames(connection)) { - schemasMap.put(schemaName, null); - } - - if (toCreate) { - loadEntities(connection, selectedSchemas); - } else { - TapSchemaDL.loadSavedSchemas(connection, (this)); - } - - if (!schemasMap.isEmpty()) { - for (String key : schemasMap.keySet()) { - Schema schema = schemasMap.get(key); - if (schema != null) { - select(schema.getName()); - break; - } - } - } - } - - @Override - public final void loadEntities(Connection connection, List selectedSchemas) throws SQLException { - TapSchemaDL.loadSelectedSchemas(connection, this, selectedSchemas); - select(selectedSchemas.get(selectedSchemas.size() - 1)); - } - - public boolean toCreate() { - return toCreate; - } - - public Schema getSchema(String name) { - return schemasMap.get(name); - } - - @Override - public void addEntity(String name, DbEntity schema) { - schemasMap.put(name, (Schema) schema); - } - - public Collection getSchemasNames() { - return schemasMap.keySet(); - } - - @Override - public ArrayList getAllEntities() { - ArrayList list = new ArrayList(); - for (DbEntity schema : schemasMap.values()) { - if (schema != null) { - list.add(schema); - } - } - return list; - } - - public String getName() { - return name; - } - - @Override - public ArrayList getAddables() { - ArrayList addableSchemas = new ArrayList(); - - for (String schemaName : schemasMap.keySet()) { - if (schemasMap.get(schemaName) == null && !schemaName.equals(this.name)) { - addableSchemas.add(schemaName); - } - } - - return addableSchemas; - } - - @Override - public void removeEntity(String schemaName) { - Schema schema = getSchema(schemaName); - if (schema.getStatus() == Status.SELECTED_TO_SAVE) { - schemasMap.put(schemaName, null); - ArrayList entities = getAllEntities(); - if (!entities.isEmpty()) { - select(entities.get(0).getName()); - } - } - if (schema.getStatus() == Status.SELECTED_SAVED) { - schema.setStatus(Status.TO_REMOVE); - } - } - - @Override - public DbEntity getSelected() { - return schemasMap.get(selectedSchema); - } - - @Override - public void select(String name) { - selectedSchema = name; - - // select first table - ArrayList tables = getSelectedSchema().getAllEntities(); - if (!tables.isEmpty()) { - getSelectedSchema().select(tables.get(0).getName()); - } - } - - public Schema getSelectedSchema() { - if (getSelected() == null) { - return null; - } - return (Schema) getSelected(); - } - - public Table getSelectedTable() { - if (getSelected() != null) { - Object table = ((Schema) getSelected()).getSelected(); - if (table != null) { - return (Table) table; - } - } - return null; - } - - public Column getSelectedColumn() { - Table table = getSelectedTable(); - if (table != null) { - Object column = table.getSelected(); - if (column != null) { - return (Column) column; - } - } - return null; - } - - @Override - public void update() { - for (DbEntity schemaEntity : getAllEntities()) { - Schema schema = (Schema) schemaEntity; - if (schema.getStatus() == Status.TO_REMOVE) { - schemasMap.put(schema.getName(), null); - } else { - schema.update(); - } - } - } -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/TapSchemaDL.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/TapSchemaDL.java deleted file mode 100644 index d4c70f119651f262925d0e7eaa845cc60d392617..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/TapSchemaDL.java +++ /dev/null @@ -1,128 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.sql.Connection; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.List; - -/** - * - * @author Sonia Zorba - */ -public class TapSchemaDL { - - public static List getAllSchemasNames(Connection connection) throws SQLException { - final List allSchemas = new ArrayList(); - (new ResultSetReader("SHOW DATABASES;") { - - @Override - public void manipulateItem(ResultSet resultSet) throws SQLException { - allSchemas.add(resultSet.getString(1)); - } - - }).read(connection); - return allSchemas; - } - - public static List getAllTAPSchemasNames(Connection connection, final List allSchemas) throws SQLException { - - class TAPSchemaChecker { - - boolean schemas; - boolean tables; - boolean columns; - boolean keys; - boolean key_columns; - - // if database has schemas, tables, columns, keys and key_columns - // then it is a tap_schema database - boolean isTAPSchema() { - return schemas && tables && columns && keys && key_columns; - } - } - - final List allTAPSchemas = new ArrayList(); - - for (String schemaName : allSchemas) { - - final TAPSchemaChecker tapSchemaChecker = new TAPSchemaChecker(); - - (new ResultSetReader("SHOW TABLES FROM " + schemaName + ";") { - - @Override - public void manipulateItem(ResultSet resultSet) throws SQLException { - // searches if the current database has schemas, tables, columns, - // keys, key_columns, that is a tap_schema database - - String tableName = resultSet.getString(1); - - if (tableName.equals("schemas")) { - tapSchemaChecker.schemas = true; - } else if (tableName.equals("tables")) { - tapSchemaChecker.tables = true; - } else if (tableName.equals("columns")) { - tapSchemaChecker.columns = true; - } else if (tableName.equals("keys")) { - tapSchemaChecker.keys = true; - } else if (tableName.equals("key_columns")) { - tapSchemaChecker.key_columns = true; - } - } - - }).read(connection); - - if (tapSchemaChecker.isTAPSchema()) { - allTAPSchemas.add(schemaName); - } - } - - return allTAPSchemas; - } - - public static List getExposedSchemas(Connection connection, final String tapSchemaName) throws SQLException { - final List exposedSchemas = new ArrayList(); - - (new ResultSetReader("SELECT schema_name FROM " + tapSchemaName + ".`schemas`") { - - @Override - public void manipulateItem(ResultSet resultSet) throws SQLException { - exposedSchemas.add(resultSet.getString(1)); - } - }).read(connection); - - return exposedSchemas; - } - - public static void loadSelectedSchemas(final Connection connection, TapSchema tapSchema, List selectedSchemas) throws SQLException { - for (String schemaName : selectedSchemas) { - Schema schema = new Schema(connection, schemaName, tapSchema.getName(), tapSchema.toCreate()); - schema.setStatus(Status.SELECTED_TO_SAVE); - tapSchema.addEntity(schemaName, schema); - } - } - - public static void loadSavedSchemas(final Connection connection, final TapSchema tapSchema) throws SQLException { - - (new ResultSetReader("SELECT * FROM " + tapSchema.getName() + ".`schemas`;") { - - @Override - public void manipulateItem(ResultSet resultSet) throws SQLException { - String schemaName = resultSet.getString("schema_name"); - - Schema schema = new Schema(connection, schemaName, tapSchema.getName(), tapSchema.toCreate()); - schema.setStatus(Status.SELECTED_SAVED); - - schema.setValue(Schema.UTYPE, resultSet.getString("utype")); - schema.setValue(Schema.DESCRIPTION, resultSet.getString("description")); - // And schemaID ?? - - tapSchema.addEntity(schemaName, schema); - } - }).read(connection); - } - - public static void update(Credentials credentials, TapSchema tapSchema) { - - } -} diff --git a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/UpdateManager.java b/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/UpdateManager.java deleted file mode 100644 index 94bd1be047b45b72c4c567ad23e03a1de0935836..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/main/java/it/inaf/oats/ia2/tapschemamodel/UpdateManager.java +++ /dev/null @@ -1,424 +0,0 @@ -package it.inaf.oats.ia2.tapschemamodel; - -import java.sql.Connection; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.SQLException; -import java.sql.Statement; -import java.util.ArrayList; -import java.util.HashSet; - -/** - * - * @author Sonia Zorba - */ -public class UpdateManager { - - private final Credentials credentials; - private final TapSchema tapSchema; - - private final ArrayList keysToRemove; - - private final ArrayList schemasToAdd; - private final ArrayList
tablesToAdd; - private final ArrayList columnsToAdd; - - private final ArrayList schemasToRemove; - private final ArrayList tablesToRemove; - private final ArrayList columnsToRemove; - - private final ArrayList schemasToUpdate; - private final ArrayList
tablesToUpdate; - private final ArrayList columnsToUpdate; - - public UpdateManager(Credentials credentials, TapSchema tapSchema) { - this.credentials = credentials; - this.tapSchema = tapSchema; - - keysToRemove = new ArrayList(); - - schemasToAdd = new ArrayList(); - tablesToAdd = new ArrayList
(); - columnsToAdd = new ArrayList(); - - schemasToRemove = new ArrayList(); - tablesToRemove = new ArrayList(); - columnsToRemove = new ArrayList(); - - schemasToUpdate = new ArrayList(); - tablesToUpdate = new ArrayList
(); - columnsToUpdate = new ArrayList(); - } - - private void createTapSchema(Connection connection) throws SQLException { - Statement statement = null; - - try { - statement = connection.createStatement(); - - String tapschemaName = tapSchema.getName(); - - //creates database - String queryString = "CREATE DATABASE IF NOT EXISTS " + tapschemaName + ";"; - statement.executeUpdate(queryString); - - //creates schemas table - queryString = "CREATE TABLE IF NOT EXISTS " + tapschemaName + ".`schemas` (" - + "schema_name varchar(64), " - + "utype varchar(512) NULL, " - + "description varchar(512) NULL, " - + "schemaID bigint, " - + "PRIMARY KEY (schema_name));"; - statement.executeUpdate(queryString); - - //creates tables table - queryString = "CREATE TABLE IF NOT EXISTS " + tapschemaName + ".tables (" - + "schema_name varchar(64), " - + "table_name varchar(128), " - + "table_type varchar(8), " - + "utype varchar(512) NULL, " - + "description varchar(512) NULL, " - + "tableID bigint, " - + "PRIMARY KEY (table_name), " - + "FOREIGN KEY (schema_name) REFERENCES " + tapschemaName + ".`schemas` (schema_name));"; - statement.executeUpdate(queryString); - - //creates columns table - queryString = "CREATE TABLE IF NOT EXISTS " + tapschemaName + ".columns (" - + "table_name varchar(128), " - + "column_name varchar(64), " - + "utype varchar(512) NULL, " - + "ucd varchar(64) NULL, " - + "unit varchar(64) NULL, " - + "description varchar(512) NULL, " - + "datatype varchar(64) NOT NULL, " - + "size integer NULL, " - + "principal integer NOT NULL, " - + "indexed integer NOT NULL, " - + "std integer NOT NULL, " - + "columnID bigint, " - + "PRIMARY KEY (table_name, column_name), " - + "FOREIGN KEY (table_name) REFERENCES " + tapschemaName + ".tables (table_name));"; - statement.executeUpdate(queryString); - - //creates keys table - queryString = "CREATE TABLE IF NOT EXISTS " + tapschemaName + ".keys (" - + "key_id varchar(64), " - + "from_table varchar(128) NOT NULL, " - + "target_table varchar(128) NOT NULL, " - + "utype varchar(512) NULL, " - + "description varchar(512) NULL, " - + "keyID bigint, " - + "PRIMARY KEY (key_id), " - + "FOREIGN KEY (from_table) REFERENCES " + tapschemaName + ".tables (table_name), " - + "FOREIGN KEY (target_table) REFERENCES " + tapschemaName + ".tables (table_name));"; - statement.executeUpdate(queryString); - - //creates key_columns table - queryString = "CREATE TABLE IF NOT EXISTS " + tapschemaName + ".key_columns (" - + "key_id varchar(64), " - + "from_column varchar(64) NOT NULL, " - + "target_column varchar(64) NOT NULL, " - + "key_columnID bigint, " - + "FOREIGN KEY (key_id) REFERENCES " + tapschemaName + ".keys (key_id));"; - statement.executeUpdate(queryString); - } catch (SQLException e) { - throw e; - } finally { - if (statement != null) { - statement.close(); - } - } - } - - public void update() { - - // Separate changes in specific lists - for (DbEntity schemaDbEntity : tapSchema.getAllEntities()) { - Schema schema = (Schema) schemaDbEntity; - - if (schema.getStatus() != Status.NOT_SELECTED) { - - switch (schema.getStatus()) { - case TO_REMOVE: - schemasToRemove.add(schema.getName()); - break; - case SELECTED_TO_SAVE: - schemasToAdd.add(schema); - break; - case SELECTED_SAVED: - if (schema.hasChanges()) { - schemasToUpdate.add(schema); - } - break; - } - - for (DbEntity tableDbEntity : schema.getAllEntities()) { - Table table = (Table) tableDbEntity; - - if (table.getStatus() != Status.NOT_SELECTED) { - - String tableName = table.getFullName(); - - switch (table.getStatus()) { - case TO_REMOVE: - tablesToRemove.add(tableName); - break; - case SELECTED_TO_SAVE: - if (schema.getStatus() == Status.SELECTED_SAVED || schema.getStatus() == Status.SELECTED_TO_SAVE) { - tablesToAdd.add(table); - } - break; - case SELECTED_SAVED: - if (schema.getStatus() == Status.TO_REMOVE) { - tablesToRemove.add(tableName); - } else if (table.hasChanges()) { - tablesToUpdate.add(table); - } - break; - } - - for (DbEntity columnDbEntity : table.getAllEntities()) { - Column column = (Column) columnDbEntity; - - if (column.getStatus() != Status.NOT_SELECTED) { - - String columnName = column.getName(); - - switch (column.getStatus()) { - case TO_REMOVE: - columnsToRemove.add(columnName); - break; - case SELECTED_TO_SAVE: - if ((schema.getStatus() == Status.SELECTED_SAVED || schema.getStatus() == Status.SELECTED_TO_SAVE) - && (table.getStatus() == Status.SELECTED_SAVED || table.getStatus() == Status.SELECTED_TO_SAVE)) { - columnsToAdd.add(column); - } - break; - case SELECTED_SAVED: - if (schema.getStatus() == Status.TO_REMOVE || table.getStatus() == Status.TO_REMOVE) { - columnsToRemove.add(columnName); - } else if (column.hasChanges()) { - columnsToUpdate.add(column); - } - break; - } - } - } - } - } - } - } - - Connection connection = null; - PreparedStatement statement = null; - ResultSet resultSet = null; - - try { - - connection = credentials.getConnection(); - - /* ---------- Find keys to add ---------- */ - HashSet schemasToCheck = new HashSet(); // schema in which could be keys to add. - ArrayList keysToCheck = new ArrayList(); - for (Table table : tablesToAdd) { - String schemaName = table.getSchemaName(); - if (!schemasToCheck.contains(schemaName)) { - schemasToCheck.add(schemaName); - keysToCheck.addAll(tapSchema.getSchema(schemaName).getKeys()); - } - } - - ArrayList keysToAdd = new ArrayList(); - for (Key key : keysToCheck) { - for (Table table : tablesToAdd) { - String tableName = table.getFullName(); - if (key.getFromTable().equals(tableName) || key.getTargetTable().equals(tableName)) { - keysToAdd.add(key); - } - } - } - - if (tapSchema.toCreate()) { - createTapSchema(connection); - } - - // Use tapSchema database - connection.setCatalog(tapSchema.getName()); - - /* ---------- Find keys to remove ---------- */ - if (tablesToRemove.size() > 0) { - - String tablesToRemoveStr = ""; - for (int i = 0; i < tablesToRemove.size(); i++) { - tablesToRemoveStr += "'" + tablesToRemove.get(i) + "'"; - if (i < tablesToRemove.size() - 1) { - tablesToRemoveStr += ","; - } - } - - (new ResultSetReader("SELECT CAST(key_id AS UNSIGNED) key_id FROM `keys`\n" - + "WHERE from_table IN (" + tablesToRemoveStr + ") OR target_table IN (" + tablesToRemoveStr + ")") { - - @Override - public void manipulateItem(ResultSet resultSet) throws SQLException { - keysToRemove.add(resultSet.getInt("key_id")); - } - }).read(connection); - - } - - int newKeyId = 1; // key id is varchar and needs to be incremented manually. This is the start value. - - /* ---------- Find max key id after keys removal ---------- */ - // if some keys are already saved in the database we need to find their max value - if (!tapSchema.toCreate()) { - String query = "SELECT MAX(CAST(key_id AS UNSIGNED)) max_key from `keys`"; - - if (keysToRemove.size() > 0) { - String keysToRemoveStr = ""; - for (int i = 0; i < keysToRemove.size(); i++) { - keysToRemoveStr += "'" + keysToRemove.get(i) + "'"; - if (i < keysToRemove.size() - 1) { - keysToRemoveStr += ","; - } - } - - query += " WHERE key_id NOT IN (" + keysToRemoveStr + ")"; - } - - Statement s = null; - ResultSet rs = null; - try { - s = connection.createStatement(); - rs = s.executeQuery(query); - while (rs.next()) { - newKeyId = rs.getInt("max_key") + 1; - } - } catch (SQLException e) { - throw e; - } finally { - if (rs != null) { - rs.close(); - } - if (s != null) { - s.close(); - } - } - } - - // Start update - connection.setAutoCommit(false); // start transaction - - // REMOVE ELEMENTS - if (!tapSchema.toCreate()) { - for (int keyId : keysToRemove) { - statement = connection.prepareStatement("DELETE FROM key_columns WHERE key_id = ?"); - statement.setString(1, keyId + ""); - statement.executeUpdate(); - - statement = connection.prepareStatement("DELETE FROM `keys` WHERE key_id = ?"); - statement.setString(1, keyId + ""); - statement.executeUpdate(); - } - - for (String columnName : columnsToRemove) { - statement = connection.prepareStatement("DELETE FROM `columns` WHERE column_name = ?"); - statement.setString(1, columnName); - statement.executeUpdate(); - } - - for (String tableFullName : tablesToRemove) { - statement = connection.prepareStatement("DELETE FROM `tables` WHERE table_name = ?"); - statement.setString(1, tableFullName); - statement.executeUpdate(); - } - - for (String schemaName : schemasToRemove) { - statement = connection.prepareStatement("DELETE FROM `schemas` WHERE schema_name = ?"); - statement.setString(1, schemaName); - statement.executeUpdate(); - } - } - - // INSERT ELEMENTS - for (Schema schema : schemasToAdd) { - schema.insert(connection); - } - - for (Table table : tablesToAdd) { - table.insert(connection); - } - - for (Column column : columnsToAdd) { - column.insert(connection); - } - - for (Key key : keysToAdd) { - statement = connection.prepareStatement("INSERT INTO `keys` " - + "(key_id, from_table, target_table, utype, description, keyID) " - + "VALUES(?,?,?,null,null,null)"); - statement.setString(1, newKeyId + ""); - statement.setString(2, key.getFromTable()); - statement.setString(3, key.getTargetTable()); - statement.executeUpdate(); - statement.close(); - - for (KeyColumn kc : key.getKeyColumns()) { - statement = connection.prepareStatement("INSERT INTO key_columns " - + "(key_id, from_column, target_column, key_columnID) " - + "VALUES(?,?,?,null)"); - statement.setString(1, newKeyId + ""); - statement.setString(2, kc.getFromColumn()); - statement.setString(3, kc.getTargetColumn()); - statement.executeUpdate(); - statement.close(); - } - - newKeyId++; - } - - //UPDATE ELEMENTS - if (!tapSchema.toCreate()) { - for (Schema schema : schemasToUpdate) { - schema.update(connection); - } - - for (Table table : tablesToUpdate) { - table.update(connection); - } - - for (Column column : columnsToUpdate) { - column.update(connection); - } - } - - connection.commit(); - - tapSchema.update(); - } catch (SQLException e) { - try { - if (connection != null && !connection.getAutoCommit()) { - connection.rollback(); - } - } catch (SQLException ex) { - ex.printStackTrace(System.err); - } - e.printStackTrace(System.err); - } finally { - try { - if (resultSet != null) { - resultSet.close(); - } - if (statement != null) { - statement.close(); - } - if (connection != null) { - connection.close(); - } - } catch (SQLException ex) { - ex.printStackTrace(System.err); - } - } - } -} diff --git a/TapSchemaModel/src/test/java/BadMockDbException.java b/TapSchemaModel/src/test/java/BadMockDbException.java deleted file mode 100644 index 46d8bf36e92e1013e31815d67a957246da988d9c..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/test/java/BadMockDbException.java +++ /dev/null @@ -1,9 +0,0 @@ -/** - * - * @author Sonia Zorba - */ -public class BadMockDbException extends Exception { - public BadMockDbException() { - super("Desired value not found in test database :("); - } -} diff --git a/TapSchemaModel/src/test/java/DLTest.java b/TapSchemaModel/src/test/java/DLTest.java deleted file mode 100644 index 1a3ef3e8acb5440ca279752d7d53b502aca8ab56..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/test/java/DLTest.java +++ /dev/null @@ -1,194 +0,0 @@ - -import it.inaf.oats.ia2.tapschemamodel.*; -import java.sql.Connection; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.List; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; -import static org.junit.Assert.*; -import org.junit.Ignore; - -/** - * - * @author Sonia Zorba - */ -@Ignore -public class DLTest { - - Connection connection; - - public DLTest() { - } - - @BeforeClass - public static void setUpClass() { - } - - @AfterClass - public static void tearDownClass() { - } - - @Before - public void setUp() throws SQLException { - connection = TestUtils.getCredentials().getConnection(); - } - - @After - public void tearDown() throws SQLException { - connection.close(); - } - - @Test - public void loadAllSchemas() throws SQLException { - List allSchemas = TapSchemaDL.getAllSchemasNames(connection); - assertTrue(allSchemas.size() > 0); - - System.out.println("All schemas:"); - printArray(allSchemas); - } - - @Test - public void loadAllTAPSchemas() throws SQLException { - List allTAPSchemas = TapSchemaDL.getAllTAPSchemasNames(connection, TapSchemaDL.getAllSchemasNames(connection)); - assertTrue(allTAPSchemas.size() > 0); - - System.out.println("All TAP schemas:"); - printArray(allTAPSchemas); - } - - @Test - public void loadNewEmptyTAPSchema() throws SQLException { - TapSchema tapSchema = new TapSchema(connection, "TEST", new ArrayList()); - - boolean allSchemasNull = true; - for (DbEntity schema : tapSchema.getAllEntities()) { - if (schema != null) { - allSchemasNull = false; - break; - } - } - - assertTrue(tapSchema.getAllEntities().size() > 0 && allSchemasNull); - } - - @Test - public TapSchema loadNewTAPSchemaOneSchemaSelected() throws SQLException { - - TapSchema tapSchema = TestUtils.getNewTAPSchemaOneSchemaSelected(connection); - - int schemasNotNulls = 0; - Schema schema = null; - for (DbEntity s : tapSchema.getAllEntities()) { - schemasNotNulls++; - schema = (Schema) s; - } - - assertEquals(schemasNotNulls, 1); - assertNotNull(schema); - assertTrue(schema.getAddables().size() > 0); - - // Check that only tableNames are loaded -// boolean allTablesNull = true; -// for (IDbEntity t : schema.getAllEntities()) { -// if (t != null) { -// allTablesNull = false; -// break; -// } -// } -// assertTrue(allTablesNull); - // Test load first table - String firstTableName = schema.getAddables().iterator().next(); - ArrayList selectedTables = new ArrayList(); - selectedTables.add(firstTableName); - schema.loadEntities(connection, selectedTables); - Table table = schema.getTable(firstTableName); - assertNotNull(table); - assertEquals(table.getStatus(), Status.SELECTED_TO_SAVE); - - // Check that all columns are loaded - assertTrue(table.getAllEntities().size() > 0); - for (DbEntity column : table.getAllEntities()) { - assertEquals(column.getStatus(), Status.SELECTED_TO_SAVE); - } - - return tapSchema; - } - - @Test - public void loadExistentTAPSchema() throws SQLException { - String tapSchemaName = TapSchemaDL.getAllTAPSchemasNames(connection, TapSchemaDL.getAllSchemasNames(connection)).get(0); - TapSchema tapSchema = new TapSchema(connection, tapSchemaName); - assertNotNull(tapSchema); - - System.out.println("Loaded " + tapSchema.getAllEntities().size() + " schemas."); - - // Test loading saved schemas and tables - for (DbEntity schema : tapSchema.getAllEntities()) { - if (schema != null) { - assertEquals(schema.getStatus(), Status.SELECTED_SAVED); - System.out.println("Loaded " + ((Schema) schema).getAllEntities().size() + " tables in the first schema (" + schema.getName() + ")."); - for (DbEntity table : ((Schema) schema).getAllEntities()) { - if (table != null) { - assertEquals(table.getStatus(), Status.SELECTED_SAVED); - System.out.println("Loaded " + ((Table) table).getAllEntities().size() + " columns in first table (" + table.getName() + ")"); - for (DbEntity column : ((Table) table).getAllEntities()) { - System.out.println(column.getName() + " " + ((Column) column).getDatatype()); - assertTrue(column.getStatus() == Status.SELECTED_SAVED || column.getStatus() == Status.NOT_SELECTED); - } - break; - } - } - - break; - } - } - - // Test loading new schema and table (first empty result) - boolean hasLoadedTable = false; - for (String schemaName : tapSchema.getSchemasNames()) { - Schema schema = tapSchema.getSchema(schemaName); - if (schema == null) { - ArrayList selectedSchemas = new ArrayList(); - selectedSchemas.add(schemaName); - tapSchema.loadEntities(connection, selectedSchemas); - schema = tapSchema.getSchema(schemaName); - assertEquals(schema.getStatus(), Status.SELECTED_TO_SAVE); - - for (String tableName : schema.getAddables()) { - Table table = schema.getTable(tableName); - if (table == null) { - ArrayList selectedTables = new ArrayList(); - selectedTables.add(tableName); - schema.loadEntities(connection, selectedTables); - table = schema.getTable(tableName); - assertEquals(table.getStatus(), Status.SELECTED_TO_SAVE); - - for (DbEntity column : table.getAllEntities()) { - assertEquals(column.getStatus(), Status.SELECTED_TO_SAVE); - } - - hasLoadedTable = true; - break; - } - } - - break; - } - } - assertTrue(hasLoadedTable); - } - - private static void printArray(List list) { - for (int i = 0; i < list.size(); i++) { - System.out.print(list.get(i)); - if (i < list.size() - 1) { - System.out.print(", "); - } - } - System.out.print("\n\n"); - } -} diff --git a/TapSchemaModel/src/test/java/TestUtils.java b/TapSchemaModel/src/test/java/TestUtils.java deleted file mode 100644 index 346ec7cb782e2ff839b874d716b77570bf519fd1..0000000000000000000000000000000000000000 --- a/TapSchemaModel/src/test/java/TestUtils.java +++ /dev/null @@ -1,60 +0,0 @@ - -import it.inaf.oats.ia2.tapschemamodel.*; -import java.sql.Connection; -import java.sql.SQLException; -import java.util.ArrayList; -import java.util.List; - -/** - * - * @author Sonia Zorba - */ -public class TestUtils { - - public static Credentials getCredentials() { - Credentials credentials = new Credentials(); - credentials.setHostname("localhost"); - credentials.setUsername("root"); - credentials.setPassword("root"); - return credentials; - } - - public static TapSchema getNewTAPSchemaOneSchemaSelected(Connection connection) throws SQLException { - String firstSchema = TapSchemaDL.getAllSchemasNames(connection).get(0); - ArrayList selectedSchemas = new ArrayList(); - selectedSchemas.add(firstSchema); - - return new TapSchema(connection, "TEST", selectedSchemas); - } - - public static Schema getFirstNotNullSchema(TapSchema tapSchema) throws BadMockDbException { - for (DbEntity schema : tapSchema.getAllEntities()) { - return (Schema) schema; - } - throw new BadMockDbException(); - } - - public static String getFirstNullSchema(TapSchema tapSchema) throws BadMockDbException { - for (String schemaName : tapSchema.getSchemasNames()) { - if (tapSchema.getSchema(schemaName) == null) { - return schemaName; - } - } - throw new BadMockDbException(); - } - - public static Table getFirstTableNotNull(Schema schema) throws BadMockDbException { - for (DbEntity table : schema.getAllEntities()) { - return (Table) table; - } - throw new BadMockDbException(); - } - - public static String getFirstNullTable(Schema schema) throws BadMockDbException { - List addablesTables = schema.getAddables(); - if (addablesTables.size() > 0) { - return addablesTables.get(0); - } - throw new BadMockDbException(); - } -}