GEOT-2333: removeSchema

modules/extension/app-schema/app-schema/src/main/java/org/geotools/data/complex/AppSchemaDataAccess.java

@@ -653,6 +653,15 @@ public void updateSchema(Name typeName, FeatureType featureType) throws IOExcept
         throw new UnsupportedOperationException();
     }
 
+    /**
+     * Not a supported operation.
+     * 
+     * @see org.geotools.data.DataAccess#removeSchema(org.opengis.feature.type.Name)
+     */
+    public void removeSchema(Name typeName) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+
     /**
      * Return a feature source that can be used to obtain features of a particular name. This name
      * would be the mappingName in the TypeMapping if it exists, otherwise it's the target element

modules/extension/app-schema/sample-data-access/src/main/java/org/geotools/data/SampleDataAccess.java

@@ -129,4 +129,13 @@ public void updateSchema(Name typeName, FeatureType featureType) throws IOExcept
         throw new UnsupportedOperationException();
     }
 
+
+    /**
+     * Unsupported operation.
+     * 
+     * @see org.geotools.data.DataAccess#removeSchema(org.opengis.feature.type.Name)
+     */
+    public void removeSchema(Name typeName) throws IOException {
+        throw new UnsupportedOperationException("Schema removal not supported");
+    }
 }

modules/extension/transform/src/main/java/org/geotools/data/transform/SingleFeatureSourceDataStore.java

@@ -100,6 +100,16 @@ public void updateSchema(String typeName, SimpleFeatureType featureType) throws
         throw new UnsupportedOperationException();
     }
 
+    @Override
+    public void removeSchema(Name typeName) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void removeSchema(String typeName) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+
     @Override
     public String[] getTypeNames() throws IOException {
         return new String[] { source.getSchema().getName().getLocalPart() };

modules/library/api/src/main/java/org/geotools/data/DataAccess.java

@@ -131,7 +131,18 @@ public interface DataAccess<T extends FeatureType, F extends Feature> {
      */
     void updateSchema(Name typeName, T featureType)
         throws IOException;
-
+
+    /**
+     * Used to permanently remove a schema from the underlying storage
+     * <p>
+     * This functionality is similar to an "drop table" statement in SQL. Implementation
+     * is optional; it may not be supported by all servers or files.
+     * @param typeName
+     * @throws IOException if the operation failed
+     * @throws UnsupportedOperation if functionality is not available
+     */
+    void removeSchema(Name typeName) throws IOException;
+
     /**
      * Names of the available Resources.
      * <p>

modules/library/api/src/main/java/org/geotools/data/DataStore.java

@@ -56,6 +56,17 @@ public interface DataStore extends DataAccess<SimpleFeatureType, SimpleFeature>{
     void updateSchema(String typeName, SimpleFeatureType featureType)
         throws IOException;
 
+    /**
+     * Used to permanently remove a schema from the underlying storage
+     * <p>
+     * This functionality is similar to an "drop table" statement in SQL. Implementation
+     * is optional; it may not be supported by all servers or files.
+     * @param typeName
+     * @throws IOException if the operation failed
+     * @throws UnsupportedOperation if functionality is not available
+     */
+    void removeSchema(String typeName) throws IOException;
+
     /**
      * Gets the names of feature types available in this {@code DataStore}.
      * Please note that this is not guaranteed to return a list of unique

modules/library/data/src/main/java/org/geotools/data/directory/DirectoryDataStore.java

@@ -193,4 +193,15 @@ public DataStore getDataStore(String typeName) throws IOException {
         return store;
     }
 
+    @Override
+    public void removeSchema(Name name) throws IOException {
+        removeSchema(name.getLocalPart());
+
+    }
+
+    @Override
+    public void removeSchema(String name) throws IOException {
+        getDataStore(name).removeSchema(name);
+    }
+
 }

modules/library/data/src/main/java/org/geotools/data/store/ContentDataStore.java

@@ -598,7 +598,18 @@ final protected ContentEntry ensureEntry(Name name)
 
         return entry;
     }
-
+
+    /**
+     * Helper method to remove an entry from the cached entry map.
+     *
+     * @param name The name of the entry.
+     */
+    final protected void removeEntry(Name name) {
+        if (entries.containsKey(name)) {
+            entries.remove(name);
+        }
+    }
+
     /**
      * Creates a set of qualified names corresponding to the types that the
      * datastore provides.
@@ -688,4 +699,18 @@ public SimpleFeatureType getSchema(Name name) throws IOException {
     public void updateSchema(Name typeName, SimpleFeatureType featureType) throws IOException {
         updateSchema(typeName.getLocalPart(), featureType);
     }
+
+    /**
+     * @see DataAccess#removeSchema(Name)
+     */
+    public void removeSchema(Name typeName) throws IOException {
+        throw new UnsupportedOperationException("Schema removal not supported");
+    }
+
+    /**
+     * @see DataStore#removeSchema(String)
+     */
+    public void removeSchema(String typeName) throws IOException {
+        throw new UnsupportedOperationException("Schema removal not supported");
+    }
 }

modules/library/jdbc/src/main/java/org/geotools/jdbc/JDBCDataStore.java

@@ -81,6 +81,7 @@
 import org.opengis.feature.simple.SimpleFeatureType;
 import org.opengis.feature.type.AttributeDescriptor;
 import org.opengis.feature.type.GeometryDescriptor;
+import org.opengis.feature.type.Name;
 import org.opengis.filter.Filter;
 import org.opengis.filter.Id;
 import org.opengis.filter.PropertyIsLessThanOrEqualTo;
@@ -687,6 +688,53 @@ public void createSchema(final SimpleFeatureType featureType)
         }
     }
 
+    public void removeSchema(String typeName) throws IOException {
+        removeSchema(name(typeName));
+    }
+
+    public void removeSchema(Name typeName) throws IOException {
+        if (entry(typeName) == null) {
+            String msg = "Schema '" + typeName + "' does not exist";
+            throw new IllegalArgumentException(msg);
+        }
+
+        //check for virtual table
+        if (virtualTables.containsKey(typeName.getLocalPart())) {
+            removeVirtualTable(typeName.getLocalPart());
+            return;
+        }
+
+        SimpleFeatureType featureType = getSchema(typeName);
+
+        //execute the drop table statement
+        Connection cx = createConnection();
+        try {
+            //give the dialect a chance to cleanup pre
+            dialect.preDropTable(databaseSchema, featureType, cx);
+
+            String sql = dropTableSQL(featureType, cx);
+            LOGGER.log(Level.FINE, "Drop schema: {0}", sql);
+
+            Statement st = cx.createStatement();
+
+            try {
+                st.execute(sql);
+            } finally {
+                closeSafe(st);
+            }
+
+            dialect.postDropTable(databaseSchema, featureType, cx);
+            removeEntry(typeName);
+        }
+        catch(Exception e) {
+            String msg = "Error occurred dropping table";
+            throw (IOException) new IOException(msg).initCause(e);
+        }
+        finally {
+            closeSafe(cx);
+        }
+    }
+
     /**
      * 
      */
@@ -1980,6 +2028,19 @@ protected String findPrimaryKeyColumnName(SimpleFeatureType featureType) {
         return "fid";
     }
 
+    /**
+     * Generates a 'DROP TABLE' sql statement.
+     */
+    protected String dropTableSQL(SimpleFeatureType featureType, Connection cx)
+        throws Exception {
+        StringBuffer sql = new StringBuffer();
+        sql.append("DROP TABLE ");
+
+        encodeTableName(featureType.getTypeName(), sql, null);
+
+        return sql.toString();
+    }
+
     /**
      * Ensures that that the specified transaction has access to features specified by a filter.
      * <p>

modules/library/jdbc/src/main/java/org/geotools/jdbc/SQLDialect.java

@@ -978,6 +978,31 @@ public void postCreateFeatureType(SimpleFeatureType featureType, DatabaseMetaDat
 
     }
 
+    /**
+     * Callback which executes before a table is about to be dropped.
+     * <p>
+     * This base implementation does nothing, subclasses should override as need be.
+     * </p>
+     * @param schemaName The database schema containing the table.
+     * @param featureType The featureType/table being dropped.
+     * @param cx The database connection.
+     */
+    public void preDropTable(String schemaName, SimpleFeatureType featureType, Connection cx) throws SQLException {
+    }
+
+    /**
+     * Callback which executes after a table has been dropped.
+     *
+     * <p>
+     * This base implementation does nothing, subclasses should override as need be.
+     * </p>
+     * @param schemaName The database schema containing the table.
+     * @param featureType The featureType/table being dropped.
+     * @param cx The database connection.
+     */
+    public void postDropTable(String schemaName, SimpleFeatureType featureType, Connection cx) throws SQLException {
+    }
+
     /**
      * Controls whether keys are looked up post or pre insert.
      * <p>

modules/library/jdbc/src/test/java/org/geotools/jdbc/JDBCDataStoreTest.java

@@ -128,24 +128,24 @@ public void testCreateSchemaWithConstraints() throws Exception {
         builder.setCRS(CRS.decode("EPSG:4326"));
         builder.add(aname("geometry"), Geometry.class);
         builder.nillable(false).add(aname("intProperty"), Integer.class);
-        
+
         builder.length(5).add(aname("stringProperty"), String.class);
-        
+
         SimpleFeatureType featureType = builder.buildFeatureType();
         dataStore.createSchema(featureType);
-        
+
         SimpleFeatureType ft2 = dataStore.getSchema(tname("ft2"));
         //assertEquals(ft2, featureType);
-        
+
         //grab a writer
         FeatureWriter w = dataStore.getFeatureWriter( tname("ft2"),Transaction.AUTO_COMMIT);
         w.hasNext();
-        
+
         SimpleFeature f = (SimpleFeature) w.next();
         f.setAttribute( 1, new Integer(0));
         f.setAttribute( 2, "hello");
         w.write();
-        
+
         w.hasNext();
         f = (SimpleFeature) w.next();
         f.setAttribute( 1, null );
@@ -155,7 +155,7 @@ public void testCreateSchemaWithConstraints() throws Exception {
         }
         catch( Exception e ) {
         }
-        
+
         f.setAttribute( 1, new Integer(1) );
         f.setAttribute( 2, "hello!");
         try {
@@ -164,10 +164,23 @@ public void testCreateSchemaWithConstraints() throws Exception {
         }
         catch( Exception e ) {
         }
-        
+
         w.close();
     }
 
+    public void testRemoveSchema() throws Exception {
+        SimpleFeatureType ft = dataStore.getSchema(tname("ft1"));
+        assertNotNull(ft);
+
+        dataStore.removeSchema(tname("ft1"));
+        try {
+            dataStore.getSchema(tname("ft1"));
+            fail("getSchema() should fail if table was deleted");
+        }
+        catch(Exception e) {
+        }
+    }
+
     public void testCreateSchemaUTMCRS() throws Exception {
         SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder();
         builder.setName(tname("ft2"));

modules/library/main/src/main/java/org/geotools/data/AbstractDataStore.java

@@ -634,4 +634,19 @@ public SimpleFeatureType getSchema(Name name) throws IOException {
     public void updateSchema(Name typeName, SimpleFeatureType featureType) throws IOException {
         updateSchema(typeName.getLocalPart(), featureType);
     }
+
+    /**
+     * @see DataAccess#removeSchema(Name)
+     */
+    public void removeSchema(Name typeName) throws IOException {
+        throw new UnsupportedOperationException("Schema removal not supported");
+    }
+
+    /**
+     * @see DataStore#removeSchema(String)
+     */
+    public void removeSchema(String typeName) throws IOException {
+        throw new UnsupportedOperationException("Schema removal not supported");
+    }
+
 }

modules/library/main/src/test/java/org/geotools/data/DataAccessFinderTest.java

@@ -347,6 +347,9 @@ public FeatureType getSchema(Name name) throws IOException {
 
         public void updateSchema(Name typeName, FeatureType featureType) throws IOException {
         }
+
+        public void removeSchema(Name typeName) throws IOException {
+        }
     };
 
     /**
@@ -394,6 +397,9 @@ public String[] getTypeNames() throws IOException {
         public void updateSchema(String typeName, SimpleFeatureType featureType) throws IOException {
         }
 
+        public void removeSchema(String typeName) throws IOException {
+        }
+
         public void createSchema(SimpleFeatureType featureType) throws IOException {
         }
 
@@ -419,5 +425,8 @@ public SimpleFeatureType getSchema(Name name) throws IOException {
 
         public void updateSchema(Name typeName, SimpleFeatureType featureType) throws IOException {
         }
+
+        public void removeSchema(Name typeName) throws IOException {
+        }
     };
 }

modules/plugin/arcsde/datastore/src/main/java/org/geotools/arcsde/data/ArcSDEDataStore.java

@@ -798,4 +798,14 @@ private void verifyUnsupportedSqlConstruct(List<Object> errors, Object construct
             errors.add(construct);
         }
     }
+
+    @Override
+    public void removeSchema(Name typeName) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void removeSchema(String typeName) throws IOException {
+        throw new UnsupportedOperationException();
+    }
 }

modules/plugin/feature-pregeneralized/src/main/java/org/geotools/data/gen/PreGeneralizedDataStore.java

@@ -206,4 +206,13 @@ public void updateSchema(Name typeName, SimpleFeatureType featureType) throws IO
 
     }
 
+    @Override
+    public void removeSchema(Name typeName) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void removeSchema(String typeName) throws IOException {
+        throw new UnsupportedOperationException();
+    }
 }