Drop the the triggers and RTree table for the table and geometry column

@param tableName
table name
@param geometryColumnName
geometry column name
970079
public void drop(String tableName, String geometryColumnName) {

		dropAllTriggers(tableName, geometryColumnName);
		dropRTreeIndex(tableName, geometryColumnName);

	}
112152
@Override
    public void deleteByColumn(String schemaName, String tableName, String columnName, Object columnValue)
    {

        if (!isOpen())
        {
            throw new PersistenceException("PelopsClient is closed.");
        }

        RowDeletor rowDeletor = clientFactory.getRowDeletor(pool);
        rowDeletor.deleteRow(tableName,
                Bytes.fromByteBuffer(CassandraUtilities.toBytes(columnValue, columnValue.getClass())),
                getConsistencyLevel());

    }
391793
public void deleteColumnFamily(DBConn dbConn, String cfName) {
        m_logger.info("Deleting ColumnFamily: {}", cfName);
        try {
            dbConn.getClientSession().system_drop_column_family(cfName);
            waitForSchemaPropagation(dbConn);
        } catch (Exception ex) {
            throw new RuntimeException("drop_column_family failed", ex);
        }
    }
953264
public void createAllTriggers(String tableName, String geometryColumnName,
			String idColumnName) {

		createInsertTrigger(tableName, geometryColumnName, idColumnName);
		createUpdate1Trigger(tableName, geometryColumnName, idColumnName);
		createUpdate2Trigger(tableName, geometryColumnName, idColumnName);
		createUpdate3Trigger(tableName, geometryColumnName, idColumnName);
		createUpdate4Trigger(tableName, geometryColumnName, idColumnName);
		createDeleteTrigger(tableName, geometryColumnName, idColumnName);

	}
502226
public <T> void dropColumn(Attribute<T, ?> attribute) {
        Type<T> type = attribute.getDeclaringType();
        if (attribute.isForeignKey()) {
            // TODO MySQL need to drop FK constraint first
        }
        QueryBuilder qb = createQueryBuilder();
        qb.keyword(ALTER, TABLE)
            .tableName(type.getName())
            .keyword(DROP, COLUMN)
            .attribute(attribute);
        try (Connection connection = getConnection()) {
            executeSql(connection, qb);
        } catch (SQLException e) {
            throw new TableModificationException(e);
        }
    }
965415
public void hideColumn(Object columnName) {
		if (columnName == null) {
			return;
		}

		for (int i = 0; i < columnModel.getColumnCount(); i++) {
			TableColumn column = columnModel.getColumn(i);

			if (columnName.equals(column.getHeaderValue())) {
				hideColumn(column);
				break;
			}
		}
	}
1234154
public int deleteByTableName(String tableName) throws SQLException {
		DeleteBuilder<FeatureTileLink, FeatureTileLinkKey> db = deleteBuilder();

		db.where().eq(FeatureTileLink.COLUMN_FEATURE_TABLE_NAME, tableName)
				.or().eq(FeatureTileLink.COLUMN_TILE_TABLE_NAME, tableName);

		PreparedDelete<FeatureTileLink> deleteQuery = db.prepare();
		int deleted = delete(deleteQuery);
		return deleted;
	}
209049
public void deleteColumn(K key, N columnName) {
    createMutator().addDeletion(key, columnFamily, columnName, topSerializer).execute();
  }
851445
private void deleteTable(String tableName) {
        m_logger.info("Deleting table: {}", tableName);
        try {
            m_ddbClient.deleteTable(new DeleteTableRequest(tableName));
            for (int seconds = 0; seconds < 10; seconds++) {
                try {
                    m_ddbClient.describeTable(tableName);
                    Thread.sleep(1000);
                } catch (ResourceNotFoundException e) {
                    break;  // Success
                }   // All other exceptions passed to outer try/catch
            }
        } catch (ResourceNotFoundException e) {
            // Already deleted.
        } catch (Exception e) {
            throw new RuntimeException("Error deleting table: " + tableName, e);
        }
    }
763163
public void dropTrigger(String tableName, String geometryColumnName,
			String triggerName) {

		String sqlName = GeoPackageProperties.getProperty(TRIGGER_PROPERTY,
				TRIGGER_DROP_PROPERTY);
		executeSQL(sqlName, tableName, geometryColumnName, null, triggerName);
	}
1094114
def drop_column(self, name):
        
        self._check_dropped()
        if name in list(self.table.columns.keys()):
            self.op.drop_column(self.table.name, name, schema=self.schema)
            self.table = self._update_table(self.table.name)
1332
public boolean dropTableIfExists(final String tableName) {
        Connection conn = getConnection();

        try {
            return JdbcUtil.dropTableIfExists(conn, tableName);
        } finally {
            closeQuietly(conn);
        }
    }
1202070
void deleteRow(String storeName, Map<String, AttributeValue> key) {
        String tableName = storeToTableName(storeName);
        m_logger.debug("Deleting row from table {}, key={}", tableName, DynamoDBService.getDDBKey(key));
        
        Timer timer = new Timer();
        boolean bSuccess = false;
        for (int attempts = 1; !bSuccess; attempts++) {
            try {
                m_ddbClient.deleteItem(tableName, key);
                if (attempts > 1) {
                    m_logger.info("deleteRow() succeeded on attempt #{}", attempts);
                }
                bSuccess = true;
                m_logger.debug("Time to delete table {}, key={}: {}",
                               new Object[]{tableName, DynamoDBService.getDDBKey(key), timer.toString()});
            } catch (ProvisionedThroughputExceededException e) {
                if (attempts >= m_max_commit_attempts) {
                    String errMsg = "All retries exceeded; abandoning deleteRow() for table: " + tableName;
                    m_logger.error(errMsg, e);
                    throw new RuntimeException(errMsg, e);
                }
                m_logger.warn("deleteRow() attempt #{} failed: {}", attempts, e);
                try {
                    Thread.sleep(attempts * m_retry_wait_millis);
                } catch (InterruptedException ex2) {
                    // ignore
                }
            }
        }
    }
1296643
public void dropRTreeIndex(String tableName, String geometryColumnName) {

		String sqlName = GeoPackageProperties.getProperty(SQL_PROPERTY,
				DROP_PROPERTY);
		try {
			executeSQL(sqlName, tableName, geometryColumnName);
		} catch (Exception e) {
			// If no rtree module, try to delete manually
			if (e.getMessage().indexOf("no such module: rtree") > -1) {
				sqlName = GeoPackageProperties.getProperty(SQL_PROPERTY,
						DROP_FORCE_PROPERTY);
				executeSQL(sqlName, tableName, geometryColumnName);
			} else {
				throw e;
			}
		}

	}
1316014
public static void removeTrigger(String triggerName) throws SundialSchedulerException {

    try {
      getScheduler().unscheduleJob(triggerName);
    } catch (SchedulerException e) {
      throw new SundialSchedulerException("ERROR REMOVING TRIGGER!!!", e);
    }
  }
850600
@Override
    public void deleteByColumn(String schemaName, String tableName, String columnName, Object columnValue)
    {
        if (!isOpen())
        {
            throw new PersistenceException("ThriftClient is closed.");
        }

        Connection conn = null;
        try
        {
            conn = getConnection();
            ColumnPath path = new ColumnPath(tableName);
            conn.getClient().remove(CassandraUtilities.toBytes(columnValue, columnValue.getClass()), path,
                    generator.getTimestamp(), getConsistencyLevel());

        }
        catch (InvalidRequestException e)
        {
            log.error("Error while deleting of column family {} for row key {}, Caused by: .", tableName, columnValue,
                    e);
            throw new KunderaException(e);
        }
        catch (TException e)
        {
            log.error("Error while deleting of column family {} for row key {}, Caused by: .", tableName, columnValue,
                    e);
            throw new KunderaException(e);
        }
        finally
        {
            releaseConnection(conn);
        }

    }
1333903
protected synchronized void removeShapeGeometryChangeListener(ShapeGeometryChangeListener listener) {
		assert listener != null : AssertMessages.notNullParameter();
		if (this.geometryListeners != null) {
			this.geometryListeners.remove(listener);
			if (this.geometryListeners.isEmpty()) {
				this.geometryListeners = null;
			}
		}
	}