PG & GP: schema pre-cache fix + model refactoring

Former-commit-id: f89357ed

plugins/org.jkiss.dbeaver.ext.greenplum/src/org/jkiss/dbeaver/ext/greenplum/edit/GreenplumFunctionManager.java

@@ -18,7 +18,6 @@
 package org.jkiss.dbeaver.ext.greenplum.edit;
 
 import org.jkiss.code.Nullable;
-import org.jkiss.dbeaver.ext.greenplum.model.GreenplumSchema;
 import org.jkiss.dbeaver.ext.postgresql.edit.PostgreProcedureManager;
 import org.jkiss.dbeaver.ext.postgresql.model.PostgreProcedure;
 import org.jkiss.dbeaver.ext.postgresql.model.PostgreSchema;
@@ -29,6 +28,6 @@ public class GreenplumFunctionManager extends PostgreProcedureManager {
     @Override
     public DBSObjectCache<PostgreSchema, PostgreProcedure> getObjectsCache(PostgreProcedure object)
     {
-        return ((GreenplumSchema) object.getContainer()).getGreenplumFunctionsCache();
+        return object.getContainer().getProceduresCache();
     }
 }

plugins/org.jkiss.dbeaver.ext.greenplum/src/org/jkiss/dbeaver/ext/greenplum/model/GreenplumSchema.java

@@ -35,11 +35,8 @@ import org.jkiss.dbeaver.model.runtime.DBRProgressMonitor;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.stream.Collectors;
 
 public class GreenplumSchema extends PostgreSchema {
-    private GreenplumTableCache greenplumTableCache = new GreenplumTableCache();
-    private GreenplumFunctionsCache greenplumFunctionsCache = new GreenplumFunctionsCache();
 
     public GreenplumSchema(PostgreDatabase owner, String name, JDBCResultSet resultSet) throws SQLException {
         super(owner, name, resultSet);
@@ -47,64 +44,29 @@ public class GreenplumSchema extends PostgreSchema {
 
     @NotNull
     @Override
-    public GreenplumDataSource getDataSource() {
-        return (GreenplumDataSource) super.getDataSource();
-    }
-
-    @Override
-    public Collection<? extends JDBCTable> getChildren(@NotNull DBRProgressMonitor monitor) throws DBException {
-        return greenplumTableCache.getTypedObjects(monitor, this, PostgreTableReal.class);
-    }
-
-    @Override
-    public JDBCTable getChild(@NotNull DBRProgressMonitor monitor, @NotNull String childName) throws DBException {
-        return greenplumTableCache.getObject(monitor, this, childName);
+    protected ProceduresCache createProceduresCache() {
+        return new GreenplumFunctionsCache();
     }
 
+    @NotNull
     @Override
-    public Collection<GreenplumTable> getTables(DBRProgressMonitor monitor) throws DBException {
-        return greenplumTableCache.getTypedObjects(monitor, this, GreenplumTable.class)
-                .stream()
-                .filter(table -> !table.isPartition())
-                .collect(Collectors.toCollection(ArrayList::new));
-    }
-
-    public Collection<? extends JDBCTable> getExternalTables(DBRProgressMonitor monitor) throws DBException {
-        return new ArrayList<>(greenplumTableCache.getTypedObjects(monitor, this, GreenplumExternalTable.class));
+    protected TableCache createTableCache() {
+        return new GreenplumTableCache();
     }
 
+    @NotNull
     @Override
-    public TableCache getTableCache() {
-        return this.greenplumTableCache;
+    public GreenplumDataSource getDataSource() {
+        return (GreenplumDataSource) super.getDataSource();
     }
 
     @Association
-    public Collection<PostgreProcedure> getProcedures(DBRProgressMonitor monitor)
-            throws DBException {
-        return greenplumFunctionsCache.getAllObjects(monitor, this);
-    }
-
-    public PostgreProcedure getProcedure(DBRProgressMonitor monitor, String procName)
-            throws DBException {
-        return greenplumFunctionsCache.getObject(monitor, this, procName);
-    }
-
-    public PostgreProcedure getProcedure(DBRProgressMonitor monitor, long oid)
-            throws DBException {
-        for (PostgreProcedure proc : greenplumFunctionsCache.getAllObjects(monitor, this)) {
-            if (proc.getObjectId() == oid) {
-                return proc;
-            }
-        }
-        return null;
-    }
-
-    public GreenplumFunctionsCache getGreenplumFunctionsCache() {
-        return this.greenplumFunctionsCache;
+    public Collection<? extends JDBCTable> getExternalTables(DBRProgressMonitor monitor) throws DBException {
+        return new ArrayList<>(getTableCache().getTypedObjects(monitor, this, GreenplumExternalTable.class));
     }
 
     public class GreenplumTableCache extends TableCache {
-        protected GreenplumTableCache() {
+        GreenplumTableCache() {
             super();
         }
 

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/edit/PostgreConstraintManager.java

@@ -51,7 +51,7 @@ public class PostgreConstraintManager extends SQLConstraintManager<PostgreTableC
     @Override
     public DBSObjectCache<PostgreTableContainer, PostgreTableConstraintBase> getObjectsCache(PostgreTableConstraintBase object)
     {
-        return object.getTable().getContainer().getSchema().constraintCache;
+        return object.getTable().getContainer().getSchema().getConstraintCache();
     }
 
     @Override

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/edit/PostgreIndexManager.java

@@ -46,7 +46,7 @@ public class PostgreIndexManager extends SQLIndexManager<PostgreIndex, PostgreTa
     @Override
     public DBSObjectCache<PostgreTableContainer, PostgreIndex> getObjectsCache(PostgreIndex object)
     {
-        return object.getTable().getContainer().getSchema().indexCache;
+        return object.getTable().getContainer().getSchema().getIndexCache();
     }
 
     @Override
@@ -116,7 +116,7 @@ public class PostgreIndexManager extends SQLIndexManager<PostgreIndex, PostgreTa
         }
     }
 
-    static void addIndexCommentAction(List<DBEPersistAction> actions, PostgreIndex index) {
+    private static void addIndexCommentAction(List<DBEPersistAction> actions, PostgreIndex index) {
         actions.add(new SQLDatabasePersistAction(
             "Comment index",
             "COMMENT ON INDEX " + index.getFullyQualifiedName(DBPEvaluationContext.DDL) +

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/edit/PostgreSequenceManager.java

@@ -47,7 +47,7 @@ public class PostgreSequenceManager extends SQLObjectEditor<PostgreTableBase, Po
 
     @Override
     public DBSObjectCache<? extends DBSObject, PostgreTableBase> getObjectsCache(PostgreTableBase object) {
-        return object.getContainer().getSchema().tableCache;
+        return object.getContainer().getSchema().getTableCache();
     }
 
     @Override

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/edit/PostgreTableManager.java

@@ -56,7 +56,7 @@ public class PostgreTableManager extends PostgreTableManagerBase implements DBEO
     @Override
     public DBSObjectCache<PostgreTableContainer, PostgreTableBase> getObjectsCache(PostgreTableBase object)
     {
-        return object.getContainer().getSchema().tableCache;
+        return object.getContainer().getSchema().getTableCache();
     }
 
     @Override

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/edit/PostgreViewManager.java

@@ -53,7 +53,7 @@ public class PostgreViewManager extends PostgreTableManagerBase implements DBEOb
     @Override
     public DBSObjectCache<PostgreTableContainer, PostgreTableBase> getObjectsCache(PostgreTableBase object)
     {
-        return object.getContainer().getSchema().tableCache;
+        return object.getContainer().getSchema().getTableCache();
     }
 
     @Override

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/model/PostgreDatabase.java

@@ -468,7 +468,7 @@ public class PostgreDatabase extends JDBCRemoteInstance
     public Collection<PostgreDataType> getLocalDataTypes() {
         final PostgreSchema schema = getCatalogSchema();
         if (schema != null) {
-            return schema.dataTypeCache.getCachedObjects();
+            return schema.getDataTypeCache().getCachedObjects();
         }
         return null;
     }
@@ -688,7 +688,7 @@ public class PostgreDatabase extends JDBCRemoteInstance
             return dataType;
         }
         for (PostgreSchema schema : schemaCache.getCachedObjects()) {
-            dataType = schema.dataTypeCache.getDataType(typeId);
+            dataType = schema.getDataTypeCache().getDataType(typeId);
             if (dataType != null) {
                 dataTypeCache.put(typeId, dataType);
                 return dataType;
@@ -697,7 +697,7 @@ public class PostgreDatabase extends JDBCRemoteInstance
         // Type not found. Let's resolve it
         try {
             dataType = PostgreDataTypeCache.resolveDataType(monitor, this, typeId);
-            dataType.getParentObject().dataTypeCache.cacheObject(dataType);
+            dataType.getParentObject().getDataTypeCache().cacheObject(dataType);
             return dataType;
         } catch (Exception e) {
             log.debug("Can't resolve data type " + typeId, e);
@@ -714,7 +714,7 @@ public class PostgreDatabase extends JDBCRemoteInstance
             // First check system catalog
             final PostgreSchema schema = getCatalogSchema();
             if (schema != null) {
-                final PostgreDataType dataType = schema.dataTypeCache.getCachedObject(typeName);
+                final PostgreDataType dataType = schema.getDataTypeCache().getCachedObject(typeName);
                 if (dataType != null) {
                     return dataType;
                 }
@@ -726,7 +726,7 @@ public class PostgreDatabase extends JDBCRemoteInstance
         for (String schemaName : searchPath) {
             final PostgreSchema schema = schemaCache.getCachedObject(schemaName);
             if (schema != null) {
-                final PostgreDataType dataType = schema.dataTypeCache.getCachedObject(typeName);
+                final PostgreDataType dataType = schema.getDataTypeCache().getCachedObject(typeName);
                 if (dataType != null) {
                     return dataType;
                 }
@@ -737,7 +737,7 @@ public class PostgreDatabase extends JDBCRemoteInstance
             if (searchPath.contains(schema.getName())) {
                 continue;
             }
-            final PostgreDataType dataType = schema.dataTypeCache.getCachedObject(typeName);
+            final PostgreDataType dataType = schema.getDataTypeCache().getCachedObject(typeName);
             if (dataType != null) {
                 return dataType;
             }
@@ -750,7 +750,7 @@ public class PostgreDatabase extends JDBCRemoteInstance
         // Type not found. Let's resolve it
         try {
             PostgreDataType dataType = PostgreDataTypeCache.resolveDataType(monitor, this, typeName);
-            dataType.getParentObject().dataTypeCache.cacheObject(dataType);
+            dataType.getParentObject().getDataTypeCache().cacheObject(dataType);
             return dataType;
         } catch (Exception e) {
             log.debug("Can't resolve data type '" + typeName + "' in database '" + getName() + "'");

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/model/PostgreIndex.java

@@ -119,7 +119,7 @@ public class PostgreIndex extends JDBCTableIndex<PostgreSchema, PostgreTableBase
 
         // Make index name unique
         int postfix = 1;
-        while (owner.getSchema().indexCache.getObject(monitor, owner.getSchema(), getName()) != null) {
+        while (owner.getSchema().getIndexCache().getObject(monitor, owner.getSchema(), getName()) != null) {
             setName(srcIndex.getName() + "_" + postfix);
             postfix++;
         }

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/model/PostgreMaterializedView.java

@@ -60,7 +60,7 @@ public class PostgreMaterializedView extends PostgreViewBase
     @Override
     public Collection<PostgreIndex> getIndexes(DBRProgressMonitor monitor) throws DBException
     {
-        return getSchema().indexCache.getObjects(monitor, getSchema(), this);
+        return getSchema().getIndexCache().getObjects(monitor, getSchema(), this);
     }
 
     @Override

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/model/PostgreSchema.java

@@ -82,26 +82,52 @@ public class PostgreSchema implements
     private Object schemaAcl;
     protected boolean persisted;
 
-    public final ExtensionCache extensionCache = new ExtensionCache();
-    public final AggregateCache aggregateCache = new AggregateCache();
-    public final TableCache tableCache = new TableCache();
-    public final ConstraintCache constraintCache = new ConstraintCache();
-    private final ProceduresCache proceduresCache = new ProceduresCache();
-    public final IndexCache indexCache = new IndexCache();
-    public final PostgreDataTypeCache dataTypeCache = new PostgreDataTypeCache();
+    private final ExtensionCache extensionCache;
+    private final AggregateCache aggregateCache;
+    private final TableCache tableCache;
+    private final ConstraintCache constraintCache;
+    private final ProceduresCache proceduresCache;
+    private final IndexCache indexCache;
+    private final PostgreDataTypeCache dataTypeCache;
     protected volatile boolean hasStatistics;
 
-    public PostgreSchema(PostgreDatabase database, String name, ResultSet dbResult)
-        throws SQLException {
+    private PostgreSchema(PostgreDatabase database, String name) {
         this.database = database;
         this.name = name;
 
+        extensionCache = new ExtensionCache();
+        aggregateCache = new AggregateCache();
+        tableCache = createTableCache();
+        constraintCache = createConstraintCache();
+        indexCache = new IndexCache();
+        proceduresCache = createProceduresCache();
+        dataTypeCache = new PostgreDataTypeCache();
+    }
+
+    @NotNull
+    protected TableCache createTableCache() {
+        return new TableCache();
+    }
+
+    @NotNull
+    protected ConstraintCache createConstraintCache() {
+        return new ConstraintCache();
+    }
+
+    @NotNull
+    protected ProceduresCache createProceduresCache() {
+        return new ProceduresCache();
+    }
+
+    public PostgreSchema(PostgreDatabase database, String name, ResultSet dbResult)
+        throws SQLException {
+        this(database, name);
+
         this.loadInfo(dbResult);
     }
 
     public PostgreSchema(PostgreDatabase database, String name, PostgreRole owner) {
-        this.database = database;
-        this.name = name;
+        this(database, name);
         this.ownerId = owner == null ? 0 : owner.getObjectId();
     }
 
@@ -246,6 +272,14 @@ public class PostgreSchema implements
         return this.proceduresCache;
     }
 
+    public IndexCache getIndexCache() {
+        return indexCache;
+    }
+
+    public PostgreDataTypeCache getDataTypeCache() {
+        return dataTypeCache;
+    }
+
     @Association
     public Collection<? extends PostgreTable> getTables(DBRProgressMonitor monitor)
         throws DBException {
@@ -282,17 +316,17 @@ public class PostgreSchema implements
     @Association
     public Collection<PostgreProcedure> getProcedures(DBRProgressMonitor monitor)
         throws DBException {
-        return proceduresCache.getAllObjects(monitor, this);
+        return getProceduresCache().getAllObjects(monitor, this);
     }
 
     public PostgreProcedure getProcedure(DBRProgressMonitor monitor, String procName)
         throws DBException {
-        return proceduresCache.getObject(monitor, this, procName);
+        return getProceduresCache().getObject(monitor, this, procName);
     }
 
     public PostgreProcedure getProcedure(DBRProgressMonitor monitor, long oid)
         throws DBException {
-        for (PostgreProcedure proc : proceduresCache.getAllObjects(monitor, this)) {
+        for (PostgreProcedure proc : getProceduresCache().getAllObjects(monitor, this)) {
             if (proc.getObjectId() == oid) {
                 return proc;
             }
@@ -684,7 +718,7 @@ public class PostgreSchema implements
      */
     public class ConstraintCache extends JDBCCompositeCache<PostgreTableContainer, PostgreTableBase, PostgreTableConstraintBase, PostgreTableConstraintColumn> {
         protected ConstraintCache() {
-            super(tableCache, PostgreTableBase.class, "tabrelname", "conname");
+            super(getTableCache(), PostgreTableBase.class, "tabrelname", "conname");
         }
 
         @NotNull
@@ -838,7 +872,7 @@ public class PostgreSchema implements
      */
     class IndexCache extends JDBCCompositeCache<PostgreTableContainer, PostgreTableBase, PostgreIndex, PostgreIndexColumn> {
         protected IndexCache() {
-            super(tableCache, PostgreTableBase.class, "tabrelname", "relname");
+            super(getTableCache(), PostgreTableBase.class, "tabrelname", "relname");
         }
 
         @NotNull

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/model/PostgreStructureAssistant.java

@@ -269,7 +269,7 @@ public class PostgreStructureAssistant extends JDBCStructureAssistant<PostgreExe
                     objects.add(new AbstractObjectReference(constrName, constrSchema, null, PostgreTableConstraintBase.class, RelationalObjectType.TYPE_CONSTRAINT) {
                         @Override
                         public DBSObject resolveObject(DBRProgressMonitor monitor) throws DBException {
-                            final PostgreTableConstraintBase constraint = PostgreUtils.getObjectById(monitor, constrSchema.constraintCache, constrSchema, constrId);
+                            final PostgreTableConstraintBase constraint = PostgreUtils.getObjectById(monitor, constrSchema.getConstraintCache(), constrSchema, constrId);
                             if (constraint == null) {
                                 throw new DBException("Constraint '" + constrName + "' not found in schema '" + constrSchema.getName() + "'");
                             }
@@ -314,7 +314,7 @@ public class PostgreStructureAssistant extends JDBCStructureAssistant<PostgreExe
                     objects.add(new AbstractObjectReference(attributeName, constrSchema, null, PostgreTableBase.class, RelationalObjectType.TYPE_TABLE_COLUMN) {
                         @Override
                         public DBSObject resolveObject(DBRProgressMonitor monitor) throws DBException {
-                            final PostgreTableBase table = PostgreUtils.getObjectById(monitor, constrSchema.tableCache, constrSchema, tableId);
+                            final PostgreTableBase table = PostgreUtils.getObjectById(monitor, constrSchema.getTableCache(), constrSchema, tableId);
                             if (table == null) {
                                 throw new DBException("Table '" + tableId + "' not found in schema '" + constrSchema.getName() + "'");
                             }

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/model/PostgreTable.java

@@ -101,7 +101,7 @@ public abstract class PostgreTable extends PostgreTableReal implements PostgreTa
                 continue;
             }
             PostgreIndex constr = new PostgreIndex(monitor, this, srcIndex);
-            getSchema().indexCache.cacheObject(constr);
+            getSchema().getIndexCache().cacheObject(constr);
         }
 
 /*
@@ -195,7 +195,7 @@ public abstract class PostgreTable extends PostgreTableReal implements PostgreTa
 
     @Override
     public Collection<PostgreIndex> getIndexes(DBRProgressMonitor monitor) throws DBException {
-        return getSchema().indexCache.getObjects(monitor, getSchema(), this);
+        return getSchema().getIndexCache().getObjects(monitor, getSchema(), this);
     }
 
     @Override
@@ -237,7 +237,7 @@ public abstract class PostgreTable extends PostgreTableReal implements PostgreTa
         // This is dummy implementation
         // Get references from this schema only
         final Collection<PostgreTableForeignKey> allForeignKeys =
-            getContainer().getSchema().constraintCache.getTypedObjects(monitor, getContainer(), PostgreTableForeignKey.class);
+            getContainer().getSchema().getConstraintCache().getTypedObjects(monitor, getContainer(), PostgreTableForeignKey.class);
         for (PostgreTableForeignKey constraint : allForeignKeys) {
             if (constraint.getAssociatedEntity() == this) {
                 refs.add(constraint);
@@ -248,7 +248,7 @@ public abstract class PostgreTable extends PostgreTableReal implements PostgreTa
 
     @Association
     public Collection<PostgreTableForeignKey> getForeignKeys(@NotNull DBRProgressMonitor monitor) throws DBException {
-        return getSchema().constraintCache.getTypedObjects(monitor, getSchema(), this, PostgreTableForeignKey.class);
+        return getSchema().getConstraintCache().getTypedObjects(monitor, getSchema(), this, PostgreTableForeignKey.class);
     }
 
     @Nullable

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/model/PostgreTableBase.java

@@ -241,8 +241,8 @@ public abstract class PostgreTableBase extends JDBCTable<PostgreDataSource, Post
     @Override
     public DBSObject refreshObject(@NotNull DBRProgressMonitor monitor) throws DBException
     {
-        getContainer().getSchema().constraintCache.clearObjectCache(this);
-        getContainer().getSchema().indexCache.clearObjectCache(this);
+        getContainer().getSchema().getConstraintCache().clearObjectCache(this);
+        getContainer().getSchema().getIndexCache().clearObjectCache(this);
         return getContainer().getSchema().getTableCache().refreshObject(monitor, getContainer().getSchema(), this);
     }
 

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/model/impls/redshift/RedshiftExternalSchema.java

@@ -47,7 +47,7 @@ public class RedshiftExternalSchema extends PostgreSchema {
     private static final Log log = Log.getLog(RedshiftExternalSchema.class);
 
     private String esOptions;
-    public final ExternalTableCache externalTableCache = new ExternalTableCache();
+    private final ExternalTableCache externalTableCache = new ExternalTableCache();
 
     public RedshiftExternalSchema(PostgreDatabase database, String name, String esOptions, ResultSet dbResult) throws SQLException {
         super(database, name, dbResult);
@@ -58,6 +58,10 @@ public class RedshiftExternalSchema extends PostgreSchema {
         super(database, name, owner);
     }
 
+    public ExternalTableCache getExternalTableCache() {
+        return externalTableCache;
+    }
+
     @Override
     public boolean isExternal() {
         return true;

plugins/org.jkiss.dbeaver.ext.postgresql/src/org/jkiss/dbeaver/ext/postgresql/model/impls/redshift/RedshiftExternalTable.java

@@ -179,12 +179,12 @@ public class RedshiftExternalTable extends PostgreTable implements DBPRefreshabl
     public List<RedshiftExternalTableColumn> getAttributes(@NotNull DBRProgressMonitor monitor)
         throws DBException
     {
-        return getContainer().externalTableCache.getChildren(monitor, getContainer(), this);
+        return getContainer().getExternalTableCache().getChildren(monitor, getContainer(), this);
     }
 
     public List<RedshiftExternalTableColumn> getCachedAttributes()
     {
-        final DBSObjectCache<RedshiftExternalTable, RedshiftExternalTableColumn> childrenCache = getContainer().externalTableCache.getChildrenCache(this);
+        final DBSObjectCache<RedshiftExternalTable, RedshiftExternalTableColumn> childrenCache = getContainer().getExternalTableCache().getChildrenCache(this);
         if (childrenCache != null) {
             return childrenCache.getCachedObjects();
         }
@@ -195,7 +195,7 @@ public class RedshiftExternalTable extends PostgreTable implements DBPRefreshabl
     public RedshiftExternalTableColumn getAttribute(@NotNull DBRProgressMonitor monitor, @NotNull String attributeName)
         throws DBException
     {
-        return getContainer().externalTableCache.getChild(monitor, getContainer(), this, attributeName);
+        return getContainer().getExternalTableCache().getChild(monitor, getContainer(), this, attributeName);
     }
 
     @Override
@@ -238,7 +238,7 @@ public class RedshiftExternalTable extends PostgreTable implements DBPRefreshabl
     @Override
     public DBSObject refreshObject(@NotNull DBRProgressMonitor monitor) throws DBException
     {
-        return getContainer().externalTableCache.refreshObject(monitor, getContainer(), this);
+        return getContainer().getExternalTableCache().refreshObject(monitor, getContainer(), this);
     }
 
     @Override