private static void collectTables(
     DBRProgressMonitor monitor, DBSObjectContainer container, Set<DBSEntity> tables)
     throws DBException {
   if (monitor.isCanceled()) {
     return;
   }
   container.cacheStructure(monitor, DBSObjectContainer.STRUCT_ALL);
   final Collection<? extends DBSObject> children = container.getChildren(monitor);
   if (!CommonUtils.isEmpty(children)) {
     Class<? extends DBSObject> childType = container.getChildType(monitor);
     DBSObjectFilter objectFilter =
         container.getDataSource().getContainer().getObjectFilter(childType, container, true);
     for (DBSObject entity : children) {
       if (monitor.isCanceled()) {
         break;
       }
       if (objectFilter != null && !objectFilter.matches(entity.getName())) {
         continue;
       }
       if (entity instanceof DBSEntity) {
         tables.add((DBSEntity) entity);
       } else if (entity instanceof DBSObjectContainer) {
         collectTables(monitor, (DBSObjectContainer) entity, tables);
       }
     }
   }
 }
 @NotNull
 @Override
 public JDBCStatement prepareLookupStatement(
     @NotNull JDBCSession session,
     @NotNull PostgreDatabase database,
     @Nullable PostgreSchema object,
     @Nullable String objectName)
     throws SQLException {
   /*
               // Do not apply filters
               // We need all schemas to have access to types
               return session.prepareStatement(
                   "SELECT n.oid,n.* FROM pg_catalog.pg_namespace n ORDER BY nspname");
   */
   StringBuilder catalogQuery =
       new StringBuilder("SELECT n.oid,n.* FROM pg_catalog.pg_namespace n");
   DBSObjectFilter catalogFilters =
       database.getDataSource().getContainer().getObjectFilter(PostgreSchema.class, null, false);
   if ((catalogFilters != null && !catalogFilters.isNotApplicable())
       || object != null
       || objectName != null) {
     if (object != null || objectName != null) {
       catalogFilters = new DBSObjectFilter();
       catalogFilters.addInclude(object != null ? object.getName() : objectName);
     } else {
       catalogFilters = new DBSObjectFilter(catalogFilters);
       // Always read catalog schema
       catalogFilters.addInclude(PostgreConstants.CATALOG_SCHEMA_NAME);
     }
     JDBCUtils.appendFilterClause(catalogQuery, catalogFilters, "nspname", true);
   }
   catalogQuery.append(" ORDER BY nspname");
   JDBCPreparedStatement dbStat = session.prepareStatement(catalogQuery.toString());
   if (catalogFilters != null) {
     JDBCUtils.setFilterParameters(dbStat, 1, catalogFilters);
   }
   return dbStat;
 }
  /**
   * Extract items using reflect api
   *
   * @param monitor progress monitor
   * @param meta items meta info
   * @param oldList previous child items
   * @param toList list ot add new items @return true on success
   * @return true on success
   * @throws DBException on any DB error
   */
  private boolean loadTreeItems(
      DBRProgressMonitor monitor,
      DBXTreeItem meta,
      final DBNDatabaseNode[] oldList,
      final List<DBNDatabaseNode> toList)
      throws DBException {
    if (this.isDisposed()) {
      // Property reading can take really long time so this node can be disposed at this moment -
      // check it
      return false;
    }
    // Read property using reflection
    Object valueObject = getValueObject();
    if (valueObject == null) {
      return false;
    }
    String propertyName = meta.getPropertyName();
    Object propertyValue = extractPropertyValue(monitor, valueObject, propertyName);
    if (propertyValue == null) {
      return false;
    }
    if (!(propertyValue instanceof Collection<?>)) {
      log.warn(
          "Bad property '"
              + propertyName
              + "' value: "
              + propertyValue.getClass().getName()); // $NON-NLS-1$ //$NON-NLS-2$
      return false;
    }

    DBSObjectFilter filter = getNodeFilter(meta, false);
    this.filtered = filter != null && !filter.isEmpty();

    Collection<?> itemList = (Collection<?>) propertyValue;
    if (itemList.isEmpty()) {
      return false;
    }
    if (this.isDisposed()) {
      // Property reading can take really long time so this node can be disposed at this moment -
      // check it
      return false;
    }

    DBPDataSourceContainer dataSourceContainer = getDataSourceContainer();
    boolean showSystem = dataSourceContainer == null || dataSourceContainer.isShowSystemObjects();
    for (Object childItem : itemList) {
      if (childItem == null) {
        continue;
      }
      if (!(childItem instanceof DBSObject)) {
        log.warn("Bad item type: " + childItem.getClass().getName()); // $NON-NLS-1$
        continue;
      }
      if (DBUtils.isHiddenObject(childItem)) {
        // Skip hidden objects
        continue;
      }
      if (!showSystem
          && childItem instanceof DBPSystemObject
          && ((DBPSystemObject) childItem).isSystem()) {
        // Skip system objects
        continue;
      }
      if (filter != null && !filter.matches(((DBSObject) childItem).getName())) {
        // Doesn't match filter
        continue;
      }
      DBSObject object = (DBSObject) childItem;
      boolean added = false;
      if (oldList != null) {
        // Check that new object is a replacement of old one
        for (DBNDatabaseNode oldChild : oldList) {
          if (oldChild.getMeta() == meta && equalObjects(oldChild.getObject(), object)) {
            oldChild.reloadObject(monitor, object);

            if (oldChild.allowsChildren() && !oldChild.needsInitialization()) {
              // Refresh children recursive
              oldChild.reloadChildren(monitor);
            }
            getModel().fireNodeUpdate(this, oldChild, DBNEvent.NodeChange.REFRESH);

            toList.add(oldChild);
            added = true;
            break;
          }
        }
      }
      if (!added) {
        // Simply add new item
        DBNDatabaseItem treeItem = new DBNDatabaseItem(this, meta, object, oldList != null);
        toList.add(treeItem);
      }
    }

    if (oldList != null) {
      // Now remove all non-existing items
      for (DBNDatabaseNode oldChild : oldList) {
        if (oldChild.getMeta() != meta) {
          // Wrong type
          continue;
        }
        boolean found = false;
        for (Object childItem : itemList) {
          if (childItem instanceof DBSObject
              && equalObjects(oldChild.getObject(), (DBSObject) childItem)) {
            found = true;
            break;
          }
        }
        if (!found) {
          // Remove old child object
          oldChild.dispose(true);
        }
      }
    }
    return true;
  }