为了少写几句SQL语句而奋斗

最近写代码的时候发现经常写一些很简单的SQL语句,比如对一个表的插入,更新,删除或者根据表中某几个字段查询表,下面的这个代码就是我为了帮助程序员改善这种状况想出来的,可以少写几句SQL语句.后来想其实程序员应该80%情况下都是写的这种代码.

    如果数据库结构改变,那么程序员写的这些代码还需要重写一下,最起码要找到对应的SQL再改一下,增加了程序员的工作量.

  下面的这个程序是在Mysql上面测试通过的,其他数据库如果测试有问题,请告诉我,我将会更新代码

  说说这个程序的思路

  1.在程序初始化的时候将数据库表结构,列名称,表的主键名都装入内存.

2.发现insert语句一般来说应该分为两条语句来插入,一个是在数据库中插入主键,一个是对主键更新,以下的插入insert函数就是基于此思想来做的.这样写还有一个好处就是可以在程序里面写的时候少写几条代码,可以将数据库数据插入和更新集成到一个更新类中实现,当然是我目前的一个想法了,大家有不同的想法可以畅所欲言,

3.加入批量，加入SaveOrUpdate方法

 下面是我写的一个insert和update的例子,仅供大家参考, 我感觉这样是代码最起码是看起来简介了不少

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import javax.sql.DataSource;

import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;

import com.csii.ebank.util.CompassUtil;
import com.csii.ebank.util.PropertiesUtils;
import com.csii.ebank.util.database.SqlUpdate;

public class DbUtil ...{
    /** *//**
 * Logger for this class
 */
private static final Log logger = LogFactory.getLog(DbUtil.class);

    private static Map<String, Set> PrimaryKeysMap = new HashMap<String, Set>();

    private static Map<String, Set> ColumnsMap = new HashMap<String, Set>();
    private static java.util.Properties compassrelate=null;
    private boolean batch = false;

    public void startBatch() ...{
        batch = true;
    }

    private java.sql.Connection conn = null;

    public void executeBatch() ...{
        this.commitandclose(conn);
    }

    public void insertOnlyIds(String tablename,
            java.util.Map<String, Object> map) ...{
        if (map == null) ...{
            map = new HashMap<String, Object>();
        }
//        /**
//         * 添加ｃｏｍｐａｓｓ情况
//         */
//            map.putAll(DbUtil.Compassed(tablename));
//        //end
        StringBuilder builder = new StringBuilder();
        builder.append(" insert into ").append(tablename).append(" (");

        StringBuilder end = new StringBuilder(" (");
        List<Object> lparam = new ArrayList<Object>();

        java.util.Set set = PrimaryKeysMap.get(tablename.toUpperCase());

        int primarykeys = 0;
        for (Map.Entry<String, Object> entry : map.entrySet()) ...{
            // 判断是否需要插入的数据
            if (!set.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }
            primarykeys++;
            lparam.add(entry.getValue());

            builder.append(entry.getKey());
            end.append("?");

            builder.append(",");
            end.append(",");

        }
        if (primarykeys != set.size()) ...{
            throw new java.lang.RuntimeException("主键不够,不能赋值");
        }
        builder.deleteCharAt(builder.length() - 1);
        end.deleteCharAt(end.length() - 1);
        builder.append(")");
        end.append(")");
        builder.append(" values ").append(end);
        try ...{
            System.err.println(builder);
            System.err.println(lparam);
            java.sql.Connection conn = getConnection();
            DbUtil.getQueryRunner().update(conn, builder.toString(),
                    lparam.toArray());
            this.commitandclose(conn);
//            CompassperformMirroring(tablename);
        } catch (Exception e) ...{
            e.printStackTrace();
        }
    }

    public static DbUtil getInstance() ...{
        DbUtil util = new DbUtil();
        // util.conn=getConnection();
        return util;
    }
    public int SelectCountOnlyByIds(String tablename,java.util.Map<String,Object>map)...{
        java.util.Set set = PrimaryKeysMap.get(tablename.toUpperCase());
        Map map2=new HashMap();
        for (Map.Entry<String, Object> entry : map.entrySet()) ...{
            // 
            if (!set.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }
            map2.put(entry.getKey(), entry.getValue());
        }
        return this.selectCount(tablename, map2);
        
    }
    public void InsertOrUpdate(String tablename,java.util.Map<String,Object>map)...{
        if(SelectCountOnlyByIds(tablename,map)<=0)...{//执行插入操作
            getInstance().insertOnlyIds(tablename, map);
        }
        //执行更新操作
        getInstance().updateById(tablename, map);
        
    }
    public void updateById(String tablename, java.util.Map<String, Object> map) ...{
        if (map == null) ...{
            map = new HashMap<String, Object>();
        }
        /** *//**
         * 添加ｃｏｍｐａｓｓ情况
         */
            map.putAll(DbUtil.Compassed(tablename));
        //end
        StringBuilder builder = new StringBuilder();
        List lparam = new ArrayList();
        List lendparam = new ArrayList();
        builder.append(" update ").append(tablename).append(" set ");
        java.util.Set primarykeyset = PrimaryKeysMap.get(tablename
                .toUpperCase());
        java.util.Set columnset = ColumnsMap.get(tablename.toUpperCase());
        StringBuilder end = new StringBuilder(" where ");
        int primarykeys = 0;
        System.err.println(columnset);
        for (Map.Entry<String, Object> entry : map.entrySet()) ...{
            // 判断是否需要插入的数据
            System.err.println(entry.getKey());
            if (!columnset.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }

            if (primarykeyset.contains(entry.getKey().toUpperCase())) ...{
                end.append("  ").append(entry.getKey()).append(" = ?  and");
                primarykeys++;
                lendparam.add(entry.getValue());
            } else ...{
                builder.append("  ").append(entry.getKey()).append(" = ?,");

                lparam.add(entry.getValue());
            }

        }

        if (primarykeys != primarykeyset.size()) ...{
            throw new java.lang.RuntimeException("主键不够,不能赋值");
        }

        end.delete(end.length() - 3, end.length());
        builder.deleteCharAt(builder.length() - 1);
        lparam.addAll(lendparam);
        System.err.println(builder.append(end));
        System.err.println(lparam);
        try ...{
            java.sql.Connection conn = getConnection();
            getQueryRunner().update(conn, builder.toString(), lparam.toArray());
            this.commitandclose(conn);
            CompassperformMirroring(tablename);
        } catch (Exception e) ...{
            e.printStackTrace();
        }
    }
    public void deleteById(String tablename,String key,String value)...{
        Map map=new HashMap();
        map.put(key, value);
        delete(tablename,map);
    }
    public void delete(String tablename, Map<String, String> params) ...{
        if (params == null) ...{
            params = new HashMap<String, String>();
        }
        StringBuilder builder = new StringBuilder();
        builder.append("delete from ").append(tablename.toUpperCase());
        builder.append(" where ");
        Set columnset = ColumnsMap.get(tablename);
        List l = new ArrayList();
        for (Map.Entry<String, String> entry : params.entrySet()) ...{

            if (!columnset.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }

            builder.append("   ").append(entry.getKey()).append(" =? and ");
            l.add(entry.getValue());
        }
        builder.delete(builder.length() - 4, builder.length());
        try ...{
            java.sql.Connection conn = getConnection();
            getQueryRunner().update(conn, builder.toString(), l.toArray());
            this.commitandclose(conn);
            
            
        } catch (Exception e) ...{
            e.printStackTrace();
        }
        System.err.println(builder);
    }
    public Object selectObject(String tablename,String key,String value,String resultKey)...{
        Map map=new HashMap();
        map.put(key, value);
        return selectObject(tablename,map,resultKey);
    }
    public Object selectObject(String tablename,Map<String,Object> params,String resultKey)...{
        Map map=this.selectMap(tablename,params);
        if(map==null)...{
            return null;
        }
        return map.get(resultKey);
        }
    public Map selectMap(String tablename,String key,String value)...{
        Map map=new HashMap();
        map.put(key, value);
        return selectMap(tablename,map);
    }
    public Map selectMap(String tablename, Map<String, Object> params) ...{
        if (params == null) ...{
            params = new HashMap<String, Object>();
        }

        StringBuilder builder = new StringBuilder();
        builder.append("select * from ").append(tablename).append("  where");
        Set columnset = ColumnsMap.get(tablename.toUpperCase());
        List l = new ArrayList();

        boolean hasparam = false;
        for (Map.Entry<String, Object> entry : params.entrySet()) ...{

            if (!columnset.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }
            hasparam = true;
            builder.append("   ").append(entry.getKey()).append(" =? and ");
            l.add(entry.getValue());
        }
        if (hasparam) ...{

            builder.delete(builder.length() - 4, builder.length());
        } else ...{
            builder.delete(builder.length() - 5, builder.length());
        }

        System.err.println(builder);
        System.err.println(l);
        try ...{

            java.sql.Connection conn = getConnection();
            Object o = getQueryRunner().query(conn, builder.toString(),
                    l.toArray(), new MapHandler());
            this.commitandclose(conn);
            return (Map) o;

        } catch (Exception e) ...{
            e.printStackTrace();
        }
        return null;

    }
    public int selectCount(String tablename,String key,String value)...{
        Map map=new HashMap();
        map.put(key, value);
        return selectCount(tablename,map);
    }
    public int selectCount(String tablename, Map<String, Object> params) ...{
        if (params == null) ...{
            params = new HashMap<String, Object>();
        }

        StringBuilder builder = new StringBuilder();
        builder.append("select count(*) from ").append(tablename).append("  where");
        Set columnset = ColumnsMap.get(tablename.toUpperCase());
        List l = new ArrayList();

        boolean hasparam = false;
        for (Map.Entry<String, Object> entry : params.entrySet()) ...{

            if (!columnset.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }
            hasparam = true;
            builder.append("   ").append(entry.getKey()).append(" =? and ");
            l.add(entry.getValue());
        }
        if (hasparam) ...{

            builder.delete(builder.length() - 4, builder.length());
        } else ...{
            builder.delete(builder.length() - 5, builder.length());
        }

        System.err.println(builder);
        try ...{

            java.sql.Connection conn = getConnection();
            Object o = getQueryRunner().query(conn, builder.toString(),
                    l.toArray(), new ArrayHandler());
            this.commitandclose(conn);
            return Integer.parseInt(((Object[])o)[0].toString());

        } catch (Exception e) ...{
            e.printStackTrace();
        }
        return 0;

    }

    
    public List selectList(String tablename,String key,String value)...{
        Map map=new HashMap();
        map.put(key, value);
        return this.selectList(tablename, map);
    }
    public List selectList(String tablename, Map<String, String> params) ...{

        if (params == null) ...{
            params = new HashMap<String, String>();
        }

        StringBuilder builder = new StringBuilder();
        builder.append("select * from ").append(tablename).append("  where");
        Set columnset = ColumnsMap.get(tablename.toUpperCase());
        List l = new ArrayList();

        boolean hasparam = false;
        for (Map.Entry<String, String> entry : params.entrySet()) ...{

            if (!columnset.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }
            hasparam = true;
            builder.append("   ").append(entry.getKey()).append(" =? and ");
            l.add(entry.getValue());
        }
        if (hasparam) ...{

            builder.delete(builder.length() - 4, builder.length());
        } else ...{
            builder.delete(builder.length() - 5, builder.length());
        }

        System.err.println(builder);
        System.err.println(l);
        try ...{
            java.sql.Connection conn = getConnection();
            Object o = getQueryRunner().query(conn, builder.toString(),
                    l.toArray(), new MapListHandler());
            this.commitandclose(conn);
            return (List) o;

        } catch (Exception e) ...{
            e.printStackTrace();
        }
        return null;
    }

    private static Set getPrimaryKeys(java.sql.Connection conn, String schema,
            String table) throws Exception ...{
        ResultSet set = conn.getMetaData().getPrimaryKeys("", schema, table);
        java.util.Set<String> hashset = new java.util.HashSet<String>();

        while (set.next()) ...{

            hashset.add(set.getString("COLUMN_NAME").toUpperCase());

        }
        set.close();
        return hashset;
    }

    private static QueryRunner getQueryRunner() ...{
        return new QueryRunner();

    }

    /** *//**
     * 从数据库中取表结构
     * 
     * @return
     */
    private Connection getConnection() ...{
        try ...{
        System.err.println(conn);
            if (conn == null) ...{
                
                java.sql.Connection conn = IbatisSQL.getConnection();
                this.conn = conn;
            }
            return conn;
        } catch (Exception e) ...{
            e.printStackTrace();
            return null;
        }
    }

    private void commitandclose(Connection conn) ...{
        if (batch) ...{// 如果是批量,每次执行关闭操作时将不执行,只有在执行批量提交时才执行
            return ;
        }
        try ...{

            DbUtils.commitAndClose(conn);
            conn = null;
        } catch (Exception e) ...{
            e.printStackTrace();
            conn = null;
        }
    }

    public static void main(String[] args) throws Exception ...{
//        init();
//        Map map = new HashMap();
//        map.put("name", "dddd");
//        map.put("hoteldesc", "ddddddddddddddddddddddddddddd");
//        System.err.println(map.values().getClass());
//        map.put("loginid", "11");
//        map.put("dddd", "aaa");
//        map.put("id", "1111111111");
//        // insertOnlyIds("USERINFO",map);
//        // DbUtil.updateById("USERINFO",map);

        // System.err.println(selectList("viewjsplog", map));

        // }
        // for (Object o : PrimaryKeysMap.entrySet()) {
        // System.err.println(o);
        // }
        //System.err.println(java.lang.Integer.valueOf(System.nanoTime()));
        System.err.println((System.nanoTime()+"").length());
    }

    /** *//**
     * 在程序启动时调用
     * 
     */
    public static void init() ...{
        try ...{
            java.sql.Connection conn = DbUtil.getInstance().getConnection();
            List v = listTables(conn, null, "TABLE");
            for (int i = 0; i < v.size(); i++) ...{
                Set set = getPrimaryKeys(conn, null, v.get(i).toString());
                PrimaryKeysMap.put(((String) v.get(i)).toUpperCase(), set);
                Set set2 = listColumns(conn, null, "TABLE", v.get(i).toString());
                ColumnsMap.put(((String) v.get(i)).toUpperCase(), set2);
            }
            conn.close();

            if (logger.isDebugEnabled()) ...{
                logger.debug("init() - PrimaryKeysMap=" + PrimaryKeysMap + ", ColumnsMap=" + ColumnsMap); //$NON-NLS-1$ //$NON-NLS-2$
            }

            /** *//**
             * 取得ｃｏｍｐａｓｓ需要的表
             */
            compassrelate=new java.util.Properties();
            compassrelate.load(DbUtil.class.getResourceAsStream("/DbUtilCompass.properties"));
            // System.err.println("conn--------------------"+conn);
        } catch (Exception e) ...{
            e.printStackTrace();
        }
        // System.err.println(PrimaryKeysMap);
        // System.err.println(ColumnsMap);
    }
    
    public static Map Compassed(String tablename)...{
        Map map=new HashMap();
         if( compassrelate.containsKey(tablename))...{
             map.put("version", new java.sql.Timestamp(System.currentTimeMillis()));
         };
         return map;
    }
    public static void CompassperformMirroring(String tablename)...{
         if( compassrelate.containsKey(tablename))...{
             CompassUtil.performMirroring();
         }
    }
    private static Set listColumns(java.sql.Connection conn, String schema,
            String type, String table) throws Exception ...{
        java.util.Set<String> hashset = new java.util.HashSet<String>();

        ResultSet set = conn.getMetaData().getColumns("", schema, table, null);
        while (set.next()) ...{
            hashset.add(set.getString("COLUMN_NAME").toUpperCase());

        }
        set.close();
        return hashset;
    }

    private static List listTables(java.sql.Connection conn, String schema,
            String type) ...{
        List<String> retVal = new ArrayList<String>();
        try ...{
            DatabaseMetaData meta = conn.getMetaData();
            ResultSet set = meta.getTableTypes();
            int columnCount = set.getMetaData().getColumnCount();

            set = meta.getTables("", schema, null, null);
            while (set.next()) ...{
                String name = set.getString("TABLE_NAME");
                String tableType = set.getString("TABLE_TYPE");
                // System.out.println(name + ":" + tableType);
                if (tableType.equals(type)) ...{
                    retVal.add(name);
                }
            }
            set.close();
        } catch (SQLException e) ...{
            e.printStackTrace();

        }
        return retVal;
    }

}

以下的代码就是具体实现,做一个说明

1.使用了common-dbuitls组件,大家如果要测试请下载此组件再测试,

2.getConnection是得到连接的方法,需要测试请替换成本机的数据库

3.例子是使用jdk1.5写成的,里面有用stringbuilder,范性等,测试时请将编译器设置为jdk1.5

4.共五个对外被调用的方法,update,delete,insert,selectList和selectMap,第一个参数是需要更新的表的名字,第二个参数Map里面key是需要更新的列的名字,value是准备更新的列的值,除insert外,主键和对应的值将放入where中,不予更新(主要考虑是既然是主键,除了删除,是不能更新的,所以就放入到where中)

5.selectList语句,map参数如果为空,返回对应表所有记录

6.selectMap语句,map参数如果为空,返回对应表第一条记录

7.update只支持根据主键更新

8.实现了只取数据表在Map中对应的值,Map中的其他值将自动过滤掉.

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;

public class DbUtil ...{

    private static Map<String, Set> PrimaryKeysMap = new HashMap<String, Set>();

    private static Map<String, Set> ColumnsMap = new HashMap<String, Set>();

    public static void insertOnlyIds(String tablename,
            java.util.Map<String, String> map) ...{
        if (map == null) ...{
            map = new HashMap<String, String>();
        }
        StringBuilder builder = new StringBuilder();
        builder.append(" insert into ").append(tablename).append(" (");

        StringBuilder end = new StringBuilder(" (");
        List<String> lparam = new ArrayList<String>();

        java.util.Set set = PrimaryKeysMap.get(tablename.toUpperCase());

        int primarykeys = 0;
        for (Map.Entry<String, String> entry : map.entrySet()) ...{
            // 判断是否需要插入的数据
            if (!set.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }
            primarykeys++;
            lparam.add(entry.getValue());

            builder.append(entry.getKey());
            end.append(entry.getValue());

            builder.append(",");
            end.append(",");

        }
        if (primarykeys != set.size()) ...{
            throw new java.lang.RuntimeException("主键不够,不能赋值");
        }
        builder.deleteCharAt(builder.length() - 1);
        end.deleteCharAt(end.length() - 1);
        builder.append(")");
        end.append(")");
        builder.append(" value ").append(end);
        try ...{
            System.err.println(builder);

            // getSqlHandle().update(builder.toString(), lparam.toArray());
        } catch (Exception e) ...{
            e.printStackTrace();
        }
    }

    public static void updateById(String tablename,
            java.util.Map<String, String> map) ...{
        if (map == null) ...{
            map = new HashMap<String, String>();
        }
        StringBuilder builder = new StringBuilder();
        List lparam = new ArrayList();
        builder.append(" update ").append(tablename).append(" set ");
        java.util.Set primarykeyset = PrimaryKeysMap.get(tablename
                .toUpperCase());
        java.util.Set columnset = ColumnsMap.get(tablename.toUpperCase());
        StringBuilder end = new StringBuilder(" where ");
        int primarykeys = 0;

        for (Map.Entry<String, String> entry : map.entrySet()) ...{
            // 判断是否需要插入的数据
            if (!columnset.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }

            if (primarykeyset.contains(entry.getKey().toUpperCase())) ...{
                end.append("  ").append(entry.getKey()).append(" = ?  and");
                primarykeys++;
            } else ...{
                builder.append("  ").append(entry.getKey()).append(" = ?,");

            }
            lparam.add(entry.getValue());
        }

        if (primarykeys != primarykeyset.size()) ...{
            throw new java.lang.RuntimeException("主键不够,不能赋值");
        }

        end.delete(end.length() - 3, end.length());
        builder.deleteCharAt(builder.length() - 1);
        System.err.println(builder.append(end));
        try...{
            QueryRunner runner=new QueryRunner();
            runner.update(builder.toString(),lparam.toArray());
        }catch(Exception e)...{
            e.printStackTrace();
        }
    }

    public static void deletesql(String tablename, Map<String, String> params) ...{
        if (params == null) ...{
            params = new HashMap<String, String>();
        }
        StringBuilder builder = new StringBuilder();
        builder.append("delete from ").append(tablename.toUpperCase());
        builder.append(" where ");
        Set columnset = ColumnsMap.get(tablename);
        List l = new ArrayList();
        for (Map.Entry<String, String> entry : params.entrySet()) ...{

            if (!columnset.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }

            builder.append("   ").append(entry.getKey()).append(" =? and ");
            l.add(entry.getValue());
        }
        builder.delete(builder.length() - 4, builder.length());
        try ...{
            QueryRunner runner = new QueryRunner();
            runner.update(builder.toString(),l.toArray());
        } catch (Exception e) ...{
            e.printStackTrace();
        }
        System.err.println(builder);
    }
    public static Map selectMap(String tablename,Map<String,String> params)...{
        if (params == null) ...{
            params = new HashMap<String, String>();
        }

        StringBuilder builder = new StringBuilder();
        builder.append("select * from ").append(tablename).append("  where");
        Set columnset = ColumnsMap.get(tablename.toUpperCase());
        List l = new ArrayList();

        boolean hasparam = false;
        for (Map.Entry<String, String> entry : params.entrySet()) ...{

            if (!columnset.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }
            hasparam = true;
            builder.append("   ").append(entry.getKey()).append(" =? and ");
            l.add(entry.getValue());
        }
        if (hasparam) ...{

            builder.delete(builder.length() - 4, builder.length());
        } else ...{
            builder.delete(builder.length() - 5, builder.length());
        }

        System.err.println(builder);
        try ...{
             
            
            QueryRunner runner = new QueryRunner();
            Object o = runner.query(getConnection(), builder.toString(), l
                    .toArray(), new MapHandler());
            return (Map)o;
             
        } catch (Exception e) ...{
            e.printStackTrace();
        }
        return null;
        
    }
    public static List selectList(String tablename, Map<String, String> params) ...{

        if (params == null) ...{
            params = new HashMap<String, String>();
        }

        StringBuilder builder = new StringBuilder();
        builder.append("select * from ").append(tablename).append("  where");
        Set columnset = ColumnsMap.get(tablename.toUpperCase());
        List l = new ArrayList();

        boolean hasparam = false;
        for (Map.Entry<String, String> entry : params.entrySet()) ...{

            if (!columnset.contains(entry.getKey().toUpperCase())) ...{
                continue;
            }
            hasparam = true;
            builder.append("   ").append(entry.getKey()).append(" =? and ");
            l.add(entry.getValue());
        }
        if (hasparam) ...{

            builder.delete(builder.length() - 4, builder.length());
        } else ...{
            builder.delete(builder.length() - 5, builder.length());
        }

        System.err.println(builder);
        try ...{
             
            QueryRunner runner = new QueryRunner();
            Object o = runner.query(getConnection(), builder.toString(), l
                    .toArray(), new MapListHandler());
            return (List)o;
         
        } catch (Exception e) ...{
            e.printStackTrace();
        }
        return null;
    }

    public static Set getPrimaryKeys(java.sql.Connection conn, String schema,
            String table) throws Exception ...{
        ResultSet set = conn.getMetaData().getPrimaryKeys("", schema, table);
        java.util.Set<String> hashset = new java.util.HashSet<String>();

        while (set.next()) ...{

            hashset.add(set.getString("COLUMN_NAME").toUpperCase());

        }
        set.close();
        return hashset;
    }

    /** *//**
     * 从数据库中取表结构
     * 
     * @return
     */
    public static Connection getConnection() ...{
        try ...{
            Class.forName("com.mysql.jdbc.Driver");
            Connection conn = DriverManager
                    .getConnection(
                            "jdbc:mysql://localhost/mydb?user=root&password=111111&characterEncoding=gbk",
                            "root", "111111");
            return conn;
            // Connection conn=IbatisSQL.getSqlHandle().getCurrentConnection();
        } catch (Exception e) ...{
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) throws Exception ...{
        Map map = new HashMap();
        // map.put("name", "dddd");
        // map.put("hoteldesc", "ddddddddddddddddddddddddddddd");
        // System.err.println(map.values().getClass());
        // map.put("loginid", "aaaaa");
        // update("USERINFO",map);
        // insertOnlyIds("USERINFO",map);
        System.err.println(selectMap("viewjsplog", map));

        // }
        for (Object o : PrimaryKeysMap.entrySet()) ...{
            System.err.println(o);
        }
    }

    static ...{
        try ...{
            java.sql.Connection conn = getConnection();
            List v = listTables(conn, null, "TABLE");
            for (int i = 0; i < v.size(); i++) ...{
                Set set = getPrimaryKeys(conn, null, v.get(i).toString());
                PrimaryKeysMap.put(((String) v.get(i)).toUpperCase(), set);
                Set set2 = listColumns(conn, null, "TABLE", v.get(i).toString());
                ColumnsMap.put(((String) v.get(i)).toUpperCase(), set2);
            }
        } catch (Exception e) ...{
            e.printStackTrace();
        }
        System.err.println(PrimaryKeysMap);
        System.err.println(ColumnsMap);
    }

    public static Set listColumns(java.sql.Connection conn, String schema,
            String type, String table) throws Exception ...{
        java.util.Set<String> hashset = new java.util.HashSet<String>();

        ResultSet set = conn.getMetaData().getColumns("", schema, null, null);
        while (set.next()) ...{
            hashset.add(set.getString("COLUMN_NAME").toUpperCase());

        }
        set.close();
        return hashset;
    }

    public static List listTables(java.sql.Connection conn, String schema,
            String type) ...{
        List<String> retVal = new ArrayList<String>();
        try ...{
            DatabaseMetaData meta = conn.getMetaData();
            ResultSet set = meta.getTableTypes();
            int columnCount = set.getMetaData().getColumnCount();

            set = meta.getTables("", schema, null, null);
            while (set.next()) ...{
                String name = set.getString("TABLE_NAME");
                String tableType = set.getString("TABLE_TYPE");
                // System.out.println(name + ":" + tableType);
                if (tableType.equals(type)) ...{
                    retVal.add(name);
                }
            }
            set.close();
        } catch (SQLException e) ...{
            e.printStackTrace();

        }
        return retVal;
    }

}