清空数据库数据（表）的一个解决方案

中东 — Thu, 09 Nov 2006 09:18:00 GMT

在做数据库开发中，经常都要清空（delete）数据或删除（drop）所有的表。然而，外键的存在，给这个工作带来了很大的不便。这里用jdbc写一个通用的类，产生出清空或删除表的顺序。
以下代码在mysql与oracle下面运行正常

(在同行的建议下作了一些改进，又增加了一些功能，见类注释)
代码：

package createData.tryDemo;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
* 外键工具
* 1，返回清空（删除）数据库表的先后顺序
* 2，找出数据库中的外键环
* 3，找出数据库中的对同一个表的重复外键关联
*
* 注：外键环（不知道在数据库中，对此情况有没有别的命名）
* 情况1，外键表是自己（自外键环、小外键环、单外键环）
* 情况2，aTable的外键表是bTable，而bTable的外键表又是aTable（双外键环）
* 情况3，就是多个表之间形成的外键环（多外键环）
* @author wpeace
*
*/
public class ExportedKeysTools
{
    public static void main(String[] args)
    {
        //得到一个数据库的连接，这里就不细说了
        Connection connection = null;

        List tables = ExportedKeysTools.getDeleteOrder(connection);

        System.out.print(tables);
        //清空数据,以oracle为例
        StringBuilder scrip = new StringBuilder();
        for(String it : tables)
        {
            scrip.append(String.format("delete from %s;\r\n", it));
        }
        System.out.print(scrip);
        //删除所有表,以oracle为例

        for(String it : tables)
        {
            scrip.append(String.format("drop table %s;\r\n", it));
        }
        System.out.print(scrip);

        //提示关闭连接！！！

    }
    public static List getDeleteOrder(Connection connection)
    {
        String userName = null;
        try
        {
            userName = connection.getMetaData().getUserName();
        }
        catch (SQLException e)
        {
            e.printStackTrace();
        }
        return ExportedKeysTools.getDeleteOrder(connection, userName);
    }
    /**
     * 返回清空（删除）数据库表的先后顺序
     * @param connection jdbc连接
     * @param userName 如果为null的话，在oracle数据库下面是所有的用户的所有表。
     * 在mysql下是当前用用户的，这个与数据库厂商的jdbc驱动有关系
     * @return 返回清空（删除）数据库表的先后顺序
     */
    public static List getDeleteOrder(Connection connection,String userName)
    {
        ResultSet reTables = null;
        ResultSet refk = null;
        try
        {
            DatabaseMetaData dm = connection.getMetaData();
            //如果是oracle数据库的话，清空闪回表
            if(dm.getDatabaseProductName().toUpperCase().indexOf("ORACLE")>=0)
            {
                Statement state = connection.createStatement();
                state.execute("PURGE RECYCLEBIN");
                state.close();
            }
            //取得表
            reTables = dm.getTables(null, userName, null, new String[]{"TABLE","VIEW"});
            List tableMetaList = new ArrayList();
            while(reTables.next())
            {
                String tableName = reTables.getString("TABLE_NAME").trim();
                if(tableName == null || tableName.length()<1)
                {
                    continue;
                }
                TableMeta tem = new TableMeta(tableName);
                tableMetaList.add(tem);
                //取得外键表
                refk = dm.getExportedKeys(null, userName, tableName);
                while(refk.next())
                {
                    String fkTableName = refk.getString("FKTABLE_NAME").trim();
                    if(fkTableName == null || fkTableName.length() < 1 ||
                            fkTableName.equals(tableName)) //去掉主外键是自己的小环
                    {
                        continue;
                    }
                    tem.addFK(fkTableName);
                }
                if(refk != null)refk.close();
            }

            Iterator iterator = tableMetaList.iterator();
            TableMeta tableMeta = iterator.next();
            List deleteOrder = new ArrayList();
            int counts = tableMetaList.size();
            for(;true;)
            {
                //没有外键了
                if(!tableMeta.isFKTable())
                {
                    iterator.remove();
                    deleteOrder.add(tableMeta.tableName);

                    //清除表所使用的所有外键表
                    for(TableMeta it : tableMetaList)
                    {
                        it.deleteFK(tableMeta.tableName);
                    }
                }

                if(!iterator.hasNext())
                {
                    //一次循环完成后，如果tableMeta的长度（也不为零）没有减少，
                    //那么说明在tableMeta中的表之间有循环外键关联的“环”，要退出整个循环
                    //不然此处就会有一个死循环，此时在tableMeta中的表的设计也许是有问题的
                    //如果要分析
                    if(tableMetaList.size() == counts || tableMetaList.size() < 1)
                    {
                        break;
                    }
                    iterator = tableMetaList.iterator();
                }
                tableMeta = iterator.next();
            }
           return deleteOrder;
        }
        catch (SQLException e)
        {
            if(refk != null)
                try
                {
                    refk.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            if(reTables != null)
                try
                {
                    reTables.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 返回外键环
     * @param connection 连接
     * @param userName 用户名，可以为空
     * @return 返回外键环
     */
    public static List getExportedKeysLoop(Connection connection,String userName)
    {
        ResultSet reTables = null;
        ResultSet refk = null;
        try
        {
            DatabaseMetaData dm = connection.getMetaData();
            //如果是oracle数据库的话，清空闪回表
            if(dm.getDatabaseProductName().toUpperCase().indexOf("ORACLE")>=0)
            {
                Statement state = connection.createStatement();
                state.execute("PURGE RECYCLEBIN");
                state.close();
            }
            //取得表
            reTables = dm.getTables(null, userName, null, new String[]{"TABLE","VIEW"});
            List tableMetaList = new ArrayList();
            while(reTables.next())
            {
                String tableName = reTables.getString("TABLE_NAME").trim();
                if(tableName == null || tableName.length()<1)
                {
                    continue;
                }
                TableMeta tem = new TableMeta(tableName);
                tableMetaList.add(tem);
                //取得外键表
                refk = dm.getExportedKeys(null, userName, tableName);
                while(refk.next())
                {
                    String fkTableName = refk.getString("FKTABLE_NAME").trim();
                    if(fkTableName == null || fkTableName.length() < 1 ||
                            fkTableName.equals(tableName)) //去掉主外键是自己的小环
                    {
                        continue;
                    }
                    tem.addFK(fkTableName);
                }
                if(refk != null)refk.close();
            }

            Iterator iterator = tableMetaList.iterator();
            TableMeta tableMeta = iterator.next();
            List exportedKeysLoop = new ArrayList();
            int counts = tableMetaList.size();
            for(;true;)
            {
                //没有外键了
                if(!tableMeta.isFKTable())
                {
                    iterator.remove();
                    //清除表所使用的所有外键表
                    for(TableMeta it : tableMetaList)
                    {
                        it.deleteFK(tableMeta.tableName);
                    }
                }

                if(!iterator.hasNext())
                {
                    //一次循环完成后，如果tableMeta的长度（也不为零）没有减少，
                    //那么说明在tableMeta中的表之间有循环外键关联的“环”，要退出整个循环
                    //不然此处就会有一个死循环，此时在tableMeta中的表的设计也许是有问题的
                    //如果要分析
                    if(tableMetaList.size() == counts || tableMetaList.size() < 1)
                    {
                        for(TableMeta it : tableMetaList)
                        {
                            exportedKeysLoop.add(it.tableName);
                        }
                        break;
                    }
                    iterator = tableMetaList.iterator();
                }
                tableMeta = iterator.next();
            }
           return exportedKeysLoop;
        }
        catch (SQLException e)
        {
            if(refk != null)
                try
                {
                    refk.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            if(reTables != null)
                try
                {
                    reTables.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 有重复外键的表
     * @param connection 连接
     * @param userName 用户名，可以为空
     * @return 有重复外键的表
     */
    public static List getRepeatExportedKeys(Connection connection,String userName)
    {
        ResultSet reTables = null;
        ResultSet refk = null;
        try
        {
            DatabaseMetaData dm = connection.getMetaData();
            //如果是oracle数据库的话，清空闪回表
            if(dm.getDatabaseProductName().toUpperCase().indexOf("ORACLE")>=0)
            {
                Statement state = connection.createStatement();
                state.execute("PURGE RECYCLEBIN");
                state.close();
            }

            List repeatExportedKeys = new ArrayList();
            //取得表
            reTables = dm.getTables(null, userName, null, new String[]{"TABLE","VIEW"});
            while(reTables.next())
            {
                String tableName = reTables.getString("TABLE_NAME").trim();
                if(tableName == null || tableName.length()<1)
                {
                    continue;
                }
                TableMeta tem = new TableMeta(tableName);
                //取得外键表
                refk = dm.getExportedKeys(null, userName, tableName);
                while(refk.next())
                {
                    String fkTableName = refk.getString("FKTABLE_NAME").trim();
                    if(fkTableName == null || fkTableName.length() < 1)
                    {
                        continue;
                    }
                    if(tem.findFK(fkTableName))
                    {
                        repeatExportedKeys.add(tem.tableName);
                        break;
                    }
                 }
                if(refk != null)refk.close();
            }
           return repeatExportedKeys;
        }
        catch (SQLException e)
        {
            if(refk != null)
                try
                {
                    refk.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            if(reTables != null)
                try
                {
                    reTables.close();
                }
                catch (SQLException e1)
                {
                    e1.printStackTrace();
                }
            e.printStackTrace();
        }
        return null;
    }
    public static class TableMeta{
        //表名
        public String tableName;
        //外键表
        private List fkTable = new ArrayList(1);
        public TableMeta(String table)
        {
            this.tableName = table;
        }
        public boolean findFK(String table)
        {
            return fkTable.contains(table);
        }
        public void deleteFK(String table)
        {
            fkTable.remove(table);
        }
        //是否存在外键表
        public boolean isFKTable()
        {
            return fkTable.size() > 0;
        }
        public void addFK(String table)
        {
            //重名处理
            if(!findFK(table))
            {
                fkTable.add(table);
            }
        }
    }

}

中东 2006-11-09 17:18 发表评论

gwt在eclipse、tomcat（数据库连接池）---tomcat数据连接池（oracle10g）

中东 — Thu, 29 Jun 2006 08:43:00 GMT

tomcat5.5 数据库连接池配置（oracle10g）

注：引用自什么地方的不记得的（在原来的基础上作了大量改变），所以没有给出引用的地方

在webapps下有如下目录结构与文件（如果没有就自己建一个）

+---tt
|   test.jsp
|   +---META-INF
|   \---WEB-INF
|            web.xml
|       +---classes
|       \---lib


1，把oracle的jdbc驱动（jdbc14.jar，对于不同的配置方式驱动可以不一样，这是一个纯java的驱动）
   复制到tomcat的目录“common/lin”下

2，打开文件“conf/server.xml” 加入以下的配置
              name="jdbc/webEDI"
      type="javax.sql.DataSource"
      password="webEDI"                                           登陆数据库的密码
      driverClassName="oracle.jdbc.OracleDriver"
      maxIdle="2"
      maxWait="5000"
      username="webEDI"                                         数据库的用户名
      url="jdbc:oracle:thin:@192.168.1.11:1521:KFERP"           数据库的url
      maxActive="4"/>
    具体对每一个参数的说明，见tomcat的帮助文档

    这里还有别外的一个方法（要求已经下载并部署了“admin”）
       A 在浏览器中输入“http://local:8080/admin”,并输入tomcat的密码进入下一界面
       B 单击根分支（一定是根分支）下的“resources”
       C 单击 “data sources”
       D 在右边的“data source actions” 中选择“create new datasource”
       E 接下写入正确的内容与上面的手动配置的内容相同
       F 保存（“save”）
       G 提交改变（“commit change”）

3，打开文件“conf/context.xml” 加入以下配置

       注意：“global”的值一定要与步骤2中配置的“name”的值相同，在本步骤中的“name”值可以自义

4，修改web应用的配置文件“web.xml”，加入如下配置

jdbc/webEDI

javax.sql.DataSource

Container

5，编写测试文件“test.jsp” 内容如下
       <%@ page contentType="text/html; charset=GBK"%>
<%@ page import="java.sql.*,
    javax.naming.*"%>
<%
try {
    Context initCtx = new InitialContext();
    Context ctx = (Context) initCtx.lookup("java:comp/env");
    Object obj = (Object) ctx.lookup("jdbc/webEDI");
    javax.sql.DataSource ds = (javax.sql.DataSource)obj;
    Connection conn = ds.getConnection();
    Statement stmt = conn.createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,
        java.sql.ResultSet.CONCUR_READ_ONLY);
    String strSQL = "SELECT * FROM F_FORECAST_LINE";
    ResultSet rs = stmt.executeQuery(strSQL);
    out.println("asdfasdf");
   for(;rs.next();)
   {
       out.println(rs.toString());
   }
%>

...

<%
    rs.close();
    stmt.close();
    conn.close();
} catch (Exception e) {
    e.printStackTrace();
    throw e;
}
%>

6，重起动tomcat

7，在浏览器中输入“http://localhost:8080/tt/test.jsp”

中东 2006-06-29 16:43 发表评论

数据库设计工具选择与比较

中东 — Tue, 16 May 2006 01:42:00 GMT

最后更新时间：2006-5-16

主流工具：powerdesigner、erwin、visio、er/studio
插件工具：together2006、myeclipse、sqlexplore

powerdesigner：易用功能强大，
    专业的数据库设计工具

    试用记录
       1，反向工程（oracle）
          选择表方便，可根据不同的用户来选择
          有运行进度，系统cpu资源使用不多
       2，把一个数据反向出来后，内容太多，看不出什么条理来，对于了解数据库的结构，还没有大的帮助啊
       3，在物理模型中它的脚本操作不太好，没有办法把一个写好的脚本转化为视图
       4，显示功能也不好（物理模型），我没有找到隐藏列的显示方式

visio：简单易用（有中文的），对MS的支持很好
    数据库设计只是他的一小部分内容，是非专业的数据库设计工具
    只能在M的平台上

    试用记录
       1，反向工程（oracle）
          驱动，用oracle service 时出错，最后用了odbc（记住要安装oracle的客户端），这样也只支持数据库的表主外键，视图存储过程都不支持

          选择表，特别的不方便，它会列出所有表，并且只能一个表一个的选择，不支持（shift操作）
          无运行进度，系统cpu资源使用不多
今天就这么多了，后继...

中东 2006-05-16 09:42 发表评论

BlogJava-peacess-随笔分类-数据库设计篇

清空数据库数据（表）的一个解决方案

gwt在eclipse、tomcat（数据库连接池）---tomcat数据连接池（oracle10g）

数据库设计工具选择与比较