精华内容
下载资源
问答
  • insertSQL = new ArrayList();ResultSet rs = null;try {rs = getColumnNameAndColumeValue(sm, listSQL, rs);} catch (SQLException e) {e.printStackTrace();} finally {rs.close();sm.close();conn.close();}}/**...

    insertSQL = new ArrayList();

    ResultSet rs = null;

    try {

    rs = getColumnNameAndColumeValue(sm, listSQL, rs);

    } catch (SQLException e) {

    e.printStackTrace();

    } finally {

    rs.close();

    sm.close();

    conn.close();

    }

    }

    /**

    * 获取列名和列值

    *

    * @return

    * @paramsm

    * @paramlistSQL

    * @paramrs

    * @throwsSQLException

    */

    private static ResultSet getColumnNameAndColumeValue(Statement sm, List listSQL, ResultSet rs) throws SQLException {

    if (listSQL.size() > 0) {

    for (int j = 0; j < listSQL.size(); j++) {

    String sql = String.valueOf(listSQL.get(j));

    rs = sm.executeQuery(sql);

    ResultSetMetaData rsmd = rs.getMetaData();

    int columnCount = rsmd.getColumnCount();

    while (rs.next()) {

    StringBuffer ColumnName = new StringBuffer();

    StringBuffer ColumnValue = new StringBuffer();

    for (int i = 1; i <= columnCount; i++) {

    String value = rs.getString(i).trim();

    if ("".equals(value)) {

    value = "";

    }

    if (i == 1 || i == columnCount) {

    if(i==columnCount){

    ColumnName.append(",");

    }

    ColumnName.append(rsmd.getColumnName(i));

    if( i== 1){

    if (Types.CHAR == rsmd.getColumnType(i) || Types.VARCHAR == rsmd.getColumnType(i) || Types.LONGVARCHAR == rsmd.getColumnType(i)) {

    ColumnValue.append("'").append(value).append("',");

    } else if (Types.SMALLINT == rsmd.getColumnType(i) || Types.INTEGER == rsmd.getColumnType(i) || Types.BIGINT == rsmd.getColumnType(i) || Types.FLOAT == rsmd.getColumnType(i) || Types.DOUBLE == rsmd.getColumnType(i) || Types.NUMERIC == rsmd.getColumnType(i) || Types.DECIMAL == rsmd.getColumnType(i)|| Types.TINYINT == rsmd.getColumnType(i)) {

    ColumnValue.append(value).append(",");

    } else if (Types.DATE == rsmd.getColumnType(i) || Types.TIME == rsmd.getColumnType(i) || Types.TIMESTAMP == rsmd.getColumnType(i)) {

    ColumnValue.append("timestamp'").append(value).append("',");

    } else {

    ColumnValue.append(value).append(",");

    }

    }else{

    if (Types.CHAR == rsmd.getColumnType(i) || Types.VARCHAR == rsmd.getColumnType(i) || Types.LONGVARCHAR == rsmd.getColumnType(i)) {

    ColumnValue.append("'").append(value);

    } else if (Types.SMALLINT == rsmd.getColumnType(i) || Types.INTEGER == rsmd.getColumnType(i) || Types.BIGINT == rsmd.getColumnType(i) || Types.FLOAT == rsmd.getColumnType(i) || Types.DOUBLE == rsmd.getColumnType(i) || Types.NUMERIC == rsmd.getColumnType(i) || Types.DECIMAL == rsmd.getColumnType(i)|| Types.TINYINT == rsmd.getColumnType(i)) {

    ColumnValue.append(value);

    } else if (Types.DATE == rsmd.getColumnType(i) || Types.TIME == rsmd.getColumnType(i) || Types.TIMESTAMP == rsmd.getColumnType(i)) {

    ColumnValue.append("timestamp'").append(value);

    } else {

    ColumnValue.append(value);

    }

    }

    } else {

    ColumnName.append("," + rsmd.getColumnName(i));

    if (Types.CHAR == rsmd.getColumnType(i) || Types.VARCHAR == rsmd.getColumnType(i) || Types.LONGVARCHAR == rsmd.getColumnType(i)) {

    ColumnValue.append("'").append(value).append("'").append(",");

    } else if (Types.SMALLINT == rsmd.getColumnType(i) || Types.INTEGER == rsmd.getColumnType(i) || Types.BIGINT == rsmd.getColumnType(i) || Types.FLOAT == rsmd.getColumnType(i) || Types.DOUBLE == rsmd.getColumnType(i) || Types.NUMERIC == rsmd.getColumnType(i) || Types.DECIMAL == rsmd.getColumnType(i)|| Types.TINYINT == rsmd.getColumnType(i)) {

    ColumnValue.append(value).append(",");

    } else if (Types.DATE == rsmd.getColumnType(i) || Types.TIME == rsmd.getColumnType(i) || Types.TIMESTAMP == rsmd.getColumnType(i)) {

    ColumnValue.append("timestamp'").append(value).append("',");

    } else {

    ColumnValue.append(value).append(",");

    }

    }

    }

    System.out.println(ColumnName.toString());

    System.out.println(ColumnValue.toString());

    insertSQL(ColumnName, ColumnValue,table[j]);

    }

    }

    }

    return rs;

    }

    /**

    * 拼装insertsql放到全局list里面

    * @paramColumnName

    * @paramColumnValue

    */

    private static void insertSQL(StringBuffer ColumnName, StringBuffer ColumnValue,String tableName) {

    StringBuffer insertSQL = new StringBuffer();

    insertSQL.append(insert).append(" ").append(schema).append(".")

    .append(tableName).append("(").append(ColumnName.toString()).append(")").append(values).append("(").append(ColumnValue.toString()).append(");");

    insertList.add(insertSQL.toString());

    System.out.println(insertSQL.toString());

    }

    }

    展开全文
  • java导出数据库sql脚本

    2021-06-15 10:55:47
    private static Connection conn = null; private static Statement sm = null; private static String schema = "lp_...//查询sql private static String insert = "INSERT INTO";//插入sql private static String .
    private static Connection conn = null;
    private static Statement sm = null;
    private static String schema = "lp_library";//模式名
    private static String select = "SELECT * FROM";//查询sql
    private static String insert = "INSERT INTO";//插入sql
    private static String values = "VALUES";//values关键字
    private static String[] table = {"dispose_manner","gift_type","introduction","status_manage","sys_user","t_lp","t_sh"};//table数组
    private static List insertList = new ArrayList();//全局存放insertsql文件的数据
    
    private static String URL = "jdbc:mysql://127.0.0.1:3306/lp_library?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf-8&autoReconnect=true";
    private static String DRIVER = "com.mysql.jdbc.Driver";
    private static String USERNAME = "root";
    private static String PASSWORD = "123456";

     

    @Autowired
    private DataSource dataSource;
    
    @RequestMapping("/download_sql")
    public void downloadSql(HttpServletRequest request, HttpServletResponse response, ModelMap model) {
        SimpleDateFormat ymd = new SimpleDateFormat("yyyy-MM-dd");
        String filePath = sysConfig.getFullUploadPath()+"/lpDB.sql";
        String fileName = "lpDB.sql";
        try {
            List listSQL = new ArrayList();
            conn = dataSource.getConnection();
            sm = conn.createStatement();
            listSQL = createSQL();//创建查询语句
            executeSQL(conn, sm, listSQL);//执行sql并拼装
            createFile(filePath);//创建文件
    
            File file = null;
            if(filePath!=null && filePath != "") {
                file = new File(filePath);
                download(request, response, fileName, file, false);
                file.delete();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    
    
    /**
     * 导出数据库表*@paramargs *@throwsSQLException
     */
    public static void main(String[] args) throws SQLException {
        List listSQL = new ArrayList();
        connectSQL(DRIVER, URL, USERNAME, PASSWORD);//连接数据库
    
    }
    
    /**
     * 创建insertsql.txt并导出数据
     */
    private static void createFile(String filePath) {
        File file = new File(filePath);
        if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                System.out.println("创建文件名失败!!");
                e.printStackTrace();
            }
        }
        FileWriter fw = null;
        BufferedWriter bw = null;
        try {
            fw = new FileWriter(file);
            bw = new BufferedWriter(fw);
            if (insertList.size() > 0) {
                for (int i = 0; i < insertList.size(); i++) {
                    bw.write(insertList.get(i).toString());
                    bw.write("\n");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bw.close();
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 拼装查询语句
     *
     * @return返回 select集合
     */
    private static List createSQL() {
        List listSQL = new ArrayList();
        for (int i = 0; i < table.length; i++) {
            StringBuffer sb = new StringBuffer();
            sb.append(select).append(" ").append(schema).append(".").append(table[i]);
            listSQL.add(sb.toString());
        }
        return listSQL;
    }
    
    /**
     * 连接数据库创建statement对象
     * *@paramdriver
     * *@paramurl
     * *@paramUserName
     * *@paramPassword
     */
    public static void connectSQL(String driver, String url, String UserName, String Password) {
        try {
            Class.forName(driver).newInstance();
            conn = DriverManager.getConnection(url, UserName, Password);
            sm = conn.createStatement();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 执行sql并返回插入sql
     *
     * @paramconn
     * @paramsm
     * @paramlistSQL *
     * @throwsSQLException
     */
    public static void executeSQL(Connection conn, Statement sm, List listSQL) throws SQLException {
        List insertSQL = new ArrayList();
        ResultSet rs = null;
        try {
            rs = getColumnNameAndColumeValue(sm, listSQL, rs);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            rs.close();
            sm.close();
            conn.close();
        }
    }
    
    /**
     * 获取列名和列值
     *
     * @return
     * @paramsm
     * @paramlistSQL
     * @paramrs
     * @throwsSQLException
     */
    private static ResultSet getColumnNameAndColumeValue(Statement sm, List listSQL, ResultSet rs) throws SQLException {
        if (listSQL.size() > 0) {
            for (int j = 0; j < listSQL.size(); j++) {
                String sql = String.valueOf(listSQL.get(j));
                rs = sm.executeQuery(sql);
                ResultSetMetaData rsmd = rs.getMetaData();
                int columnCount = rsmd.getColumnCount();
                while (rs.next()) {
                    StringBuffer ColumnName = new StringBuffer();
                    StringBuffer ColumnValue = new StringBuffer();
                    for (int i = 1; i <= columnCount; i++) {
                        String value = null;
                        if(rs.getString(i) != null){
                            value = rs.getString(i).trim();
                        }
    
                        if ("".equals(value)) {
                            value = "";
                        }
                        if (i == 1 || i == columnCount) {
                            if(i==columnCount){
                                ColumnName.append(",");
                            }
                            ColumnName.append(rsmd.getColumnName(i));
                            if( i== 1){
                                if (Types.CHAR == rsmd.getColumnType(i) || Types.VARCHAR == rsmd.getColumnType(i) || Types.LONGVARCHAR == rsmd.getColumnType(i)) {
                                    ColumnValue.append("'").append(value).append("',");
                                } else if (Types.SMALLINT == rsmd.getColumnType(i) || Types.INTEGER == rsmd.getColumnType(i) || Types.BIGINT == rsmd.getColumnType(i) || Types.FLOAT == rsmd.getColumnType(i) || Types.DOUBLE == rsmd.getColumnType(i) || Types.NUMERIC == rsmd.getColumnType(i) || Types.DECIMAL == rsmd.getColumnType(i)|| Types.TINYINT == rsmd.getColumnType(i)) {
                                    ColumnValue.append(value).append(",");
                                } else if (Types.DATE == rsmd.getColumnType(i) || Types.TIME == rsmd.getColumnType(i) || Types.TIMESTAMP == rsmd.getColumnType(i)) {
                                    if(StringUtils.isNotBlank(value)){
                                        ColumnValue.append("'").append(value).append("',");
                                    }else{
                                        ColumnValue.append("null,");
                                    }
                                } else {
                                    ColumnValue.append(value).append(",");
    
                                }
                            }else{
                                if (Types.CHAR == rsmd.getColumnType(i) || Types.VARCHAR == rsmd.getColumnType(i) || Types.LONGVARCHAR == rsmd.getColumnType(i)) {
                                    ColumnValue.append("'").append(value).append("'");
                                } else if (Types.SMALLINT == rsmd.getColumnType(i) || Types.INTEGER == rsmd.getColumnType(i) || Types.BIGINT == rsmd.getColumnType(i) || Types.FLOAT == rsmd.getColumnType(i) || Types.DOUBLE == rsmd.getColumnType(i) || Types.NUMERIC == rsmd.getColumnType(i) || Types.DECIMAL == rsmd.getColumnType(i)|| Types.TINYINT == rsmd.getColumnType(i)) {
                                    ColumnValue.append(value);
                                } else if (Types.DATE == rsmd.getColumnType(i) || Types.TIME == rsmd.getColumnType(i) || Types.TIMESTAMP == rsmd.getColumnType(i)) {
                                    if(StringUtils.isNotBlank(value)){
                                        ColumnValue.append("'").append(value).append("'");
                                    }else{
                                        ColumnValue.append("null");
                                    }
                                } else {
                                    ColumnValue.append(value);
                                }
                            }
    
                        } else {
                            ColumnName.append("," + rsmd.getColumnName(i));
                            if (Types.CHAR == rsmd.getColumnType(i) || Types.VARCHAR == rsmd.getColumnType(i) || Types.LONGVARCHAR == rsmd.getColumnType(i)) {
                                ColumnValue.append("'").append(value).append("'").append(",");
                            } else if (Types.SMALLINT == rsmd.getColumnType(i) || Types.INTEGER == rsmd.getColumnType(i) || Types.BIGINT == rsmd.getColumnType(i) || Types.FLOAT == rsmd.getColumnType(i) || Types.DOUBLE == rsmd.getColumnType(i) || Types.NUMERIC == rsmd.getColumnType(i) || Types.DECIMAL == rsmd.getColumnType(i)|| Types.TINYINT == rsmd.getColumnType(i)) {
                                ColumnValue.append(value).append(",");
                            } else if (Types.DATE == rsmd.getColumnType(i) || Types.TIME == rsmd.getColumnType(i) || Types.TIMESTAMP == rsmd.getColumnType(i)) {
                                //ColumnValue.append("timestamp'").append(value).append("',");
                                if(StringUtils.isNotBlank(value)){
                                    ColumnValue.append("'").append(value).append("',");
                                }else{
                                    ColumnValue.append("null,");
                                }
                            } else {
                                ColumnValue.append(value).append(",");
                            }
                        }
                    }
                    System.out.println(ColumnName.toString());
                    System.out.println(ColumnValue.toString());
                    insertSQL(ColumnName, ColumnValue,table[j]);
                }
            }
        }
        return rs;
    }
    
    /**
     * 拼装insertsql放到全局list里面
     * @paramColumnName
     * @paramColumnValue
     */
    private static void insertSQL(StringBuffer ColumnName, StringBuffer ColumnValue,String tableName) {
        StringBuffer insertSQL = new StringBuffer();
        //insertSQL.append(insert).append(" ").append(schema).append(".")
                //.append(tableName).append("(").append(ColumnName.toString()).append(")").append(values).append("(").append(ColumnValue.toString()).append(");");
        insertSQL.append(insert).append(" ").append(schema).append(".")
                .append(tableName).append(" ").append(values).append("(").append(ColumnValue.toString()).append(");");
        insertList.add(insertSQL.toString());
        System.out.println(insertSQL.toString());
    
    }

    //文件下载

    public static void download(HttpServletRequest request, HttpServletResponse response, String filename, File file, boolean del) throws IOException {
       OutputStream outp = null;
       FileInputStream in = null;
       try {
          String userAgent = request.getHeader("user-agent");
          response.setCharacterEncoding("UTF-8");
          response.setContentType("application/octet-stream");
          // 针对不同的浏览器需要有不同的编码,否则文件名会出现乱码
          if (userAgent.toLowerCase().indexOf("firefox") > 0) {
             filename = new String(filename.getBytes("UTF-8"), "ISO8859-1");
          } else if (userAgent.toUpperCase().indexOf("MSIE") > 0) {
             filename = URLEncoder.encode(filename, "UTF-8");
          } else if (userAgent.toUpperCase().indexOf("CHORM") > 0) {
             filename = new String(filename.getBytes("UTF-8"), "ISO8859-1");
          } else {
             filename = URLEncoder.encode(filename, "UTF-8");
          }
          response.addHeader("Content-disposition", "attachment;filename=" + filename);
          outp = response.getOutputStream();
          in = new FileInputStream(file);
          byte[] b = new byte[1024];
          int i = 0;
          while ((i = in.read(b)) > 0) {
             outp.write(b, 0, i);
          }
          outp.flush();
       }
       finally {
          if (in != null) {
             try {
                in.close();
                in = null;
             }
             catch (IOException e) {
                e.printStackTrace();
             }
          }
          if (outp != null) {
             try {
                outp.close();
                outp = null;
             }
             catch (IOException e) {
                e.printStackTrace();
             }
          }
          if (file != null && del) {
             if (file.exists()) {
                file.delete();
             }
          }
       }
    }

     

    展开全文
  • SQL脚本生成器

    2017-03-29 16:27:21
    因为在数据库升级或者迁移的时候,为了保证不同环境不同数据库数据保持同步,故数据库SQL脚本非常作用。比如:数据库主脚本,副脚本,增量脚本。 3、 什么是主脚本、副脚本、增量脚本呢? 3.1、主脚本指数据库...
  • 通过sql语句查询,获取数据集,通过程序,导出insert或其他语句,生成sql文件。 库名,表名,条件,sql动作,都可进行指定,或直接写全sql。 具体代码如下: package com; import java.io.BufferedWriter; ...

    通过sql语句查询,获取数据集,通过程序,导出insert或其他语句,生成sql文件。

    库名,表名,条件,sql动作,都可进行指定,或直接写全sql。

    具体代码如下:

    package com;
    
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.sql.*;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author 
     * @title: ExportSqlController
     * @description: TODO
     * @date 2021/11/8 10:33
     */
    public class ExportSqlController {
        private static Connection conn = null;
        private static Statement sm = null;
        private static String schema = "库名";//模式名
        private static String select = "SELECT * FROM";//查询sql
        private static String term = "where 1=1";//查询sql条件
        private static String insert = "INSERT INTO";//插入sql
        private static String values = "VALUES";//values关键字
        private static String[] table = {"表名"};//table数组
        private static List<String> insertList = new ArrayList<String>();//全局存放insertsql文件的数据
        private static String filePath = "C:\\Users\\Desktop\\export.sql";//绝对路径导出数据的文件
    
        /**
         * 导出数据库表*@paramargs *@throwsSQLException
         */
        public static void main(String[] args) throws SQLException {
            List<String> listSQL = new ArrayList<String>();
            connectSQL("com.mysql.cj.jdbc.Driver",
                    "jdbc:mysql://*.*.*.*:3306/库名?serverTimezone=GMT%2b8&useUnicode=true&characterEncoding=utf-8&useSSL=true&allowMultiQueries=true",
                    "username", "password");//连接数据库
            listSQL = createSQL();//创建查询语句
            executeSQL(conn, sm, listSQL);//执行sql并拼装
            createFile();//创建文件
        }
    
        /**
         * 创建insertsql.txt并导出数据
         */
        private static void createFile() {
            File file = new File(filePath);
            if (!file.exists()) {
                try {
                    file.createNewFile();
                } catch (IOException e) {
                    System.out.println("创建文件名失败!!");
                    e.printStackTrace();
                }
            }
            FileWriter fw = null;
            BufferedWriter bw = null;
            try {
                fw = new FileWriter(file);
                bw = new BufferedWriter(fw);
                if (insertList.size() > 0) {
                    for (int i = 0; i < insertList.size(); i++) {
                        bw.append(insertList.get(i));
                        bw.append("\n");
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    bw.close();
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 拼装查询语句
         *
         * @return返回 select集合
         */
        private static List<String> createSQL() {
            List<String> listSQL = new ArrayList<String>();
            for (int i = 0; i < table.length; i++) {
                StringBuffer sb = new StringBuffer();
                sb.append(select).append(" ").append(schema).append(".").append(table[i]);
                if (term!=null){
                    sb.append(" ").append(term);
                }
                listSQL.add(sb.toString());
            }
            return listSQL;
        }
    
        /**
         * 连接数据库创建statement对象
         * *@paramdriver
         * *@paramurl
         * *@paramUserName
         * *@paramPassword
         */
        public static void connectSQL(String driver, String url, String UserName, String Password) {
            try {
                Class.forName(driver).newInstance();
                conn = DriverManager.getConnection(url, UserName, Password);
                sm = conn.createStatement();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 执行sql并返回插入sql
         *
         * @paramconn
         * @paramsm
         * @paramlistSQL *
         * @throwsSQLException
         */
        public static void executeSQL(Connection conn, Statement sm, List listSQL) throws SQLException {
            List<String> insertSQL = new ArrayList<String>();
            ResultSet rs = null;
            try {
                rs = getColumnNameAndColumeValue(sm, listSQL, rs);
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                rs.close();
                sm.close();
                conn.close();
            }
        }
    
        /**
         * 获取列名和列值
         *
         * @return
         * @paramsm
         * @paramlistSQL
         * @paramrs
         * @throwsSQLException
         */
        private static ResultSet getColumnNameAndColumeValue(Statement sm, List listSQL, ResultSet rs) throws SQLException {
            if (listSQL.size() > 0) {
                for (int j = 0; j < listSQL.size(); j++) {
                    String sql = String.valueOf(listSQL.get(j));
                    rs = sm.executeQuery(sql);
                    ResultSetMetaData rsmd = rs.getMetaData();
                    int columnCount = rsmd.getColumnCount();
                    while (rs.next()) {
                        StringBuffer ColumnName = new StringBuffer();
                        StringBuffer ColumnValue = new StringBuffer();
                        for (int i = 1; i <= columnCount; i++) {
                            String value = null;
                            if (rs.getString(i)!=null){
                                value = rs.getString(i).trim();
                            }
                            if (null!=value && "".equals(value)) {
                                value = "";
                            }
                            if (i == 1 || i == columnCount) {
                                if(i==columnCount){
                                    ColumnName.append(",");
                                }
                                ColumnName.append(rsmd.getColumnName(i));
                                if( i== 1){
                                    if (Types.CHAR == rsmd.getColumnType(i) || Types.VARCHAR == rsmd.getColumnType(i) || Types.LONGVARCHAR == rsmd.getColumnType(i)) {
                                        ColumnValue.append("'").append(value).append("',");
                                    } else if (Types.SMALLINT == rsmd.getColumnType(i) || Types.INTEGER == rsmd.getColumnType(i) || Types.BIGINT == rsmd.getColumnType(i) || Types.FLOAT == rsmd.getColumnType(i) || Types.DOUBLE == rsmd.getColumnType(i) || Types.NUMERIC == rsmd.getColumnType(i) || Types.DECIMAL == rsmd.getColumnType(i)|| Types.TINYINT == rsmd.getColumnType(i)) {
                                        ColumnValue.append(value).append(",");
                                    } else if (Types.DATE == rsmd.getColumnType(i) || Types.TIME == rsmd.getColumnType(i) || Types.TIMESTAMP == rsmd.getColumnType(i)) {
                                        ColumnValue.append("'").append(value).append("',");
                                    } else {
                                        ColumnValue.append(value).append(",");
    
                                    }
                                }else{
                                    if (Types.CHAR == rsmd.getColumnType(i) || Types.VARCHAR == rsmd.getColumnType(i) || Types.LONGVARCHAR == rsmd.getColumnType(i)) {
                                        ColumnValue.append("'").append(value).append("',");
                                    } else if (Types.SMALLINT == rsmd.getColumnType(i) || Types.INTEGER == rsmd.getColumnType(i) || Types.BIGINT == rsmd.getColumnType(i) || Types.FLOAT == rsmd.getColumnType(i) || Types.DOUBLE == rsmd.getColumnType(i) || Types.NUMERIC == rsmd.getColumnType(i) || Types.DECIMAL == rsmd.getColumnType(i)|| Types.TINYINT == rsmd.getColumnType(i)) {
                                        ColumnValue.append(value);
                                    } else if (Types.DATE == rsmd.getColumnType(i) || Types.TIME == rsmd.getColumnType(i) || Types.TIMESTAMP == rsmd.getColumnType(i)) {
                                        ColumnValue.append("'").append(value).append("',");
                                    } else {
                                        ColumnValue.append(value);
    
                                    }
                                }
    
                            } else {
                                ColumnName.append("," + rsmd.getColumnName(i));
                                if (Types.CHAR == rsmd.getColumnType(i) || Types.VARCHAR == rsmd.getColumnType(i) || Types.LONGVARCHAR == rsmd.getColumnType(i)) {
                                    if (null==value){
                                        ColumnValue.append(value).append(",");
                                    }else {
                                        ColumnValue.append("'").append(value).append("'").append(",");
                                    }
                                } else if (Types.SMALLINT == rsmd.getColumnType(i) || Types.INTEGER == rsmd.getColumnType(i) || Types.BIGINT == rsmd.getColumnType(i) || Types.FLOAT == rsmd.getColumnType(i) || Types.DOUBLE == rsmd.getColumnType(i) || Types.NUMERIC == rsmd.getColumnType(i) || Types.DECIMAL == rsmd.getColumnType(i)|| Types.TINYINT == rsmd.getColumnType(i)) {
                                    ColumnValue.append(value).append(",");
                                } else if (Types.DATE == rsmd.getColumnType(i) || Types.TIME == rsmd.getColumnType(i) || Types.TIMESTAMP == rsmd.getColumnType(i)) {
                                    ColumnValue.append("'").append(value).append("',");
                                } else {
                                    ColumnValue.append(value).append(",");
                                }
                            }
                        }
                        System.out.println(ColumnName.toString());
                        System.out.println(ColumnValue.toString());
                        insertSQL(ColumnName, ColumnValue,table[j]);
                    }
                }
            }
            return rs;
        }
    
        /**
         * 拼装insertsql放到全局list里面
         * @paramColumnName
         * @paramColumnValue
         */
        private static void insertSQL(StringBuffer ColumnName, StringBuffer ColumnValue,String tableName) {
            StringBuffer insertSQL = new StringBuffer();
            insertSQL.append(insert).append(" ").append(schema).append(".")
                    .append(tableName).append("(").append(ColumnName.toString()).append(")").append(values).append("(").append(ColumnValue.toString()).append(");");
            insertList.add(insertSQL.toString());
            System.out.println(insertSQL.toString());
    
        }
    }
    

    展开全文
  • java 实现数据库导出 sql文件

    千次阅读 2020-01-07 14:48:34
     在java中调用cmd,使用 > (重定向的意思)会出现错误,导致导出sql文件为空;   另附上mysqldump常用参数,是复制来的: 1、 --all-databases, -A //导出全部数据库。 #mysqldump -uroot -p...
            String commod = "mysqldump -u"+username+" -p"+password+" -h"+host+" -P"+port+" --single-transaction " +
                            "--master-data=2 --events --routines  --databases " +dataBaseName+"  -n -t " +
                            "--result-file="+sqlPath+dataBaseName+".sql";
            //调用系统黑窗口,运行命令
            Process p = null;
            try {
    //            synchronized (this){
                    p = Runtime.getRuntime().exec(commod);
    //            }
            } catch (IOException e) {
                e.printStackTrace();
            }

    遇到的坑 注意: "mysqldump -u"+username+" -p"+password+" -h"+host+" -P"+port+" --single-transaction " +
                            "--master-data=2 --events --routines  --databases " +dataBaseName+"  -n -t " +
                            "--result-file="+sqlPath+dataBaseName+".sql";

    网上大部分是 > 而不是--result-file=   在java中调用cmd,使用 > (重定向的意思)会出现错误,导致导出的sql文件为空;

     

    另附上mysqldump常用参数,是复制来的:

    1、    --all-databases, -A    //导出全部数据库。

    #mysqldump  -uroot -p --all-databases>outfile.sql

    #mysqldump  -uroot -p -A>outfile.sql      //等同于上句

    2、    --all-tablespaces, -Y     //导出全部表空间。

    #mysqldump  -uroot -p --all-databases --all-tablespaces>outfile.sql

    #mysqldump  -uroot -p –A -Y>outfile.sql      //等同于上句

    3、    --no-tablespaces, -y   //不导出任何表空间信息。

    #mysqldump  -uroot -p --all-databases --no-tablespaces

    #mysqldump  -uroot -p --A –y>outfile.sql  //等同于上句

    4、    --add-drop-database

    //每个数据库创建之前添加drop数据库语句。

    mysqldump  -uroot -p --all-databases --add-drop-database

    5、    --add-drop-table

    每个数据表创建之前添加drop数据表语句。(默认为打开状态,使用--skip-add-drop-table取消选项)

    mysqldump  -uroot -p --all-databases  (默认添加drop语句)

    mysqldump  -uroot -p --all-databases –skip-add-drop-table  (取消drop语句)

    6、    --add-locks

    /在每个表导出之前增加LOCK TABLES并且之后UNLOCK  TABLE。(默认为打开状态,使用--skip-add-locks取消选项)

    mysqldump  -uroot -p --all-databases  (默认添加LOCK语句)

    mysqldump  -uroot -p --all-databases –skip-add-locks   (取消LOCK语句)

    7、    --allow-keywords

    //允许创建是关键词的列名字。这由表名前缀于每个列名做到。

    mysqldump  -uroot -p --all-databases --allow-keywords

    8、    --apply-slave-statements

    在'CHANGE MASTER'前添加'STOP SLAVE',并且在导出的最后添加'START SLAVE'。

    mysqldump  -uroot -p --all-databases --apply-slave-statements

    9、    --character-sets-dir   //字符集文件的目录

    mysqldump  -uroot -p --all-databases  --character-sets-dir=/usr/local/mysql/share/mysql/charsets

    10、  --comments

    附加注释信息。默认为打开,可以用--skip-comments取消

    mysqldump  -uroot -p --all-databases  (默认记录注释)

    mysqldump  -uroot -p --all-databases --skip-comments   (取消注释)

    11、  --compatible

    导出的数据将和其它数据库或旧版本的MySQL 相兼容。值可以为ansi、mysql323、mysql40、postgresql、oracle、mssql、db2、maxdb、no_key_options、no_tables_options、no_field_options等,要使用几个值,用逗号将它们隔开。它并不保证能完全兼容,而是尽量兼容。

    mysqldump  -uroot -p --all-databases --compatible=ansi

    12、  --compact 

    //导出更少的输出信息(用于调试)。去掉注释和头尾等结构。可以使用选项:--skip-add-drop-table  --skip-add-locks --skip-comments --skip-disable-keys

    mysqldump  -uroot -p --all-databases --compact

    13、  --complete-insert,  -c

    使用完整的insert语句(包含列名称)。这么做能提高插入效率,但是可能会受到max_allowed_packet参数的影响而导致插入失败。

    mysqldump  -uroot -p --all-databases --complete-insert

    14、  --compress, -C 

    //在客户端和服务器之间启用压缩传递所有信息

    mysqldump  -uroot -p --all-databases --compress

    15、  --create-options,  -a 

    //在CREATE TABLE语句中包括所有MySQL特性选项。(默认为打开状态)

    mysqldump  -uroot -p --all-databases

    16、  --databases,  -B

    //导出几个数据库。参数后面所有名字参量都被看作数据库名。

    mysqldump  -uroot -p --databases test mysql

    17、  --debug

    输出debug信息,用于调试。默认值为:d:t:o,/tmp/mysqldump.trace

    mysqldump  -uroot -p --all-databases --debug

    mysqldump  -uroot -p --all-databases --debug=” d:t:o,/tmp/debug.trace”

    18、  --debug-check

    检查内存和打开文件使用说明并退出。

    mysqldump  -uroot -p --all-databases --debug-check

    19、  --debug-info

    输出调试信息并退出

    mysqldump  -uroot -p --all-databases --debug-info

    20、  --default-character-set 

    //设置默认字符集,默认值为utf8

    mysqldump  -uroot -p --all-databases --default-character-set=latin1

    21、  --delayed-insert 

    //采用延时插入方式(INSERT DELAYED)导出数据

    mysqldump  -uroot -p --all-databases --delayed-insert

    22、  --delete-master-logs

    //master备份后删除日志. 这个参数将自动激活--master-data。

    mysqldump  -uroot -p --all-databases --delete-master-logs

    23、  --disable-keys

    对于每个表,用/*!40000 ALTER TABLE tbl_name DISABLE KEYS */;和/*!40000 ALTER TABLE tbl_name ENABLE KEYS */;语句引用INSERT语句。这样可以更快地导入dump出来的文件,因为它是在插入所有行后创建索引的。该选项只适合MyISAM表,默认为打开状态。

    mysqldump  -uroot -p --all-databases 

    24、  --dump-slave

    该选项将导致主的binlog位置和文件名追加到导出数据的文件中。设置为1时,将会以CHANGE MASTER命令输出到数据文件;设置为2时,在命令前增加说明信息。该选项将会打开--lock-all-tables,除非--single-transaction被指定。该选项会自动关闭--lock-tables选项。默认值为0。

    mysqldump  -uroot -p --all-databases --dump-slave=1

    mysqldump  -uroot -p --all-databases --dump-slave=2

    25、  --events, -E     //导出事件。

    mysqldump  -uroot -p --all-databases --events

    26、  --extended-insert,  -e

    使用具有多个VALUES列的INSERT语法。这样使导出文件更小,并加速导入时的速度。默认为打开状态,使用--skip-extended-insert取消选项。

    mysqldump  -uroot -p --all-databases

    mysqldump  -uroot -p --all-databases--skip-extended-insert   (取消选项)

    27、  --fields-terminated-by

    导出文件中忽略给定字段。与--tab选项一起使用,不能用于--databases和--all-databases选项

    mysqldump  -uroot -p test test --tab=”/home/mysql” --fields-terminated-by=”#”

    28、  --fields-enclosed-by

    输出文件中的各个字段用给定字符包裹。与--tab选项一起使用,不能用于--databases和--all-databases选项

    mysqldump  -uroot -p test test --tab=”/home/mysql” --fields-enclosed-by=”#”

    29、  --fields-optionally-enclosed-by

    //输出文件中的各个字段用给定字符选择性包裹。与--tab选项一起使用,不能用于--databases和--all-databases选项

    mysqldump  -uroot -p test test --tab=”/home/mysql”  --fields-enclosed-by=”#” --fields-optionally-enclosed-by  =”#”

    30、  --fields-escaped-by

    输出文件中的各个字段忽略给定字符。与--tab选项一起使用,不能用于--databases和--all-databases选项

    mysqldump  -uroot -p mysql user --tab=”/home/mysql” --fields-escaped-by=”#”

    31、  --flush-logs

    开始导出之前刷新日志。

    请注意:假如一次导出多个数据库(使用选项--databases或者--all-databases),将会逐个数据库刷新日志。除使用--lock-all-tables或者--master-data外。在这种情况下,日志将会被刷新一次,相应的所以表同时被锁定。因此,如果打算同时导出和刷新日志应该使用--lock-all-tables 或者--master-data 和--flush-logs。

    mysqldump  -uroot -p --all-databases --flush-logs

    32、  --flush-privileges

    在导出mysql数据库之后,发出一条FLUSH  PRIVILEGES 语句。为了正确恢复,该选项应该用于导出mysql数据库和依赖mysql数据库数据的任何时候。

    mysqldump  -uroot -p --all-databases --flush-privileges

    33、  --force   //在导出过程中忽略出现的SQL错误。

    mysqldump  -uroot -p --all-databases --force

    34、  --help     //显示帮助信息并退出。

    mysqldump  --help

    35、  --hex-blob

    //使用十六进制格式导出二进制字符串字段。如果有二进制数据就必须使用该选项。影响到的字段类型有BINARY、VARBINARY、BLOB。

    mysqldump  -uroot -p --all-databases --hex-blob

    36、  --host, -h          //需要导出的主机信息

    mysqldump  -uroot -p --host=localhost --all-databases

    37、  --ignore-table

    不导出指定表。指定忽略多个表时,需要重复多次,每次一个表。每个表必须同时指定数据库和表名。例如:--ignore-table=database.table1 --ignore-table=database.table2 ……

    mysqldump  -uroot -p --host=localhost --all-databases --ignore-table=mysql.user

    38、  --include-master-host-port

    在--dump-slave产生的'CHANGE  MASTER TO..'语句中增加'MASTER_HOST=<host>,MASTER_PORT=<port>'  

    mysqldump  -uroot -p --host=localhost --all-databases --include-master-host-port

    39、  --insert-ignore

    在插入行时使用INSERT IGNORE语句.

    mysqldump  -uroot -p --host=localhost --all-databases --insert-ignore

    40、  --lines-terminated-by

    输出文件的每行用给定字符串划分。与--tab选项一起使用,不能用于--databases和--all-databases选项。

    mysqldump  -uroot -p --host=localhost test test --tab=”/tmp/mysql”  --lines-terminated-by=”##”

    41、  --lock-all-tables,  -x

    提交请求锁定所有数据库中的所有表,以保证数据的一致性。这是一个全局读锁,并且自动关闭--single-transaction 和--lock-tables 选项。

    mysqldump  -uroot -p --host=localhost --all-databases --lock-all-tables

    42、  --lock-tables,  -l

    开始导出前,锁定所有表。用READ  LOCAL锁定表以允许MyISAM表并行插入。对于支持事务的表例如InnoDB和BDB,--single-transaction是一个更好的选择,因为它根本不需要锁定表。

    请注意当导出多个数据库时,--lock-tables分别为每个数据库锁定表。因此,该选项不能保证导出文件中的表在数据库之间的逻辑一致性。不同数据库表的导出状态可以完全不同。

    mysqldump  -uroot -p --host=localhost --all-databases --lock-tables

    43、  --log-error

    附加警告和错误信息到给定文件

    mysqldump  -uroot -p --host=localhost --all-databases  --log-error=/tmp/mysqldump_error_log.err

    44、  --master-data

    该选项将binlog的位置和文件名追加到输出文件中。如果为1,将会输出CHANGE MASTER 命令;如果为2,输出的CHANGE  MASTER命令前添加注释信息。该选项将打开--lock-all-tables 选项,除非--single-transaction也被指定(在这种情况下,全局读锁在开始导出时获得很短的时间;其他内容参考下面的--single-transaction选项)。该选项自动关闭--lock-tables选项。

    mysqldump  -uroot -p --host=localhost --all-databases --master-data=1;

    mysqldump  -uroot -p --host=localhost --all-databases --master-data=2;

    45、  --max_allowed_packet

    服务器发送和接受的最大包长度。

    mysqldump  -uroot -p --host=localhost --all-databases --max_allowed_packet=10240

    46、  --net_buffer_length

    TCP/IP和socket连接的缓存大小。

    mysqldump  -uroot -p --host=localhost --all-databases --net_buffer_length=1024

    47、  --no-autocommit

    使用autocommit/commit 语句包裹表。

    mysqldump  -uroot -p --host=localhost --all-databases --no-autocommit

    48、  --no-create-db,  -n

    只导出数据,而不添加CREATE DATABASE 语句。

    mysqldump  -uroot -p --host=localhost --all-databases --no-create-db

    49、  --no-create-info,  -t

    只导出数据,而不添加CREATE TABLE 语句。

    mysqldump  -uroot -p --host=localhost --all-databases --no-create-info

    50、  --no-data, -d

    不导出任何数据,只导出数据库表结构。

    mysqldump  -uroot -p --host=localhost --all-databases --no-data

    51、  --no-set-names,  -N

    等同于--skip-set-charset

    mysqldump  -uroot -p --host=localhost --all-databases --no-set-names

    52、  --opt

    等同于--add-drop-table,  --add-locks, --create-options, --quick, --extended-insert, --lock-tables,  --set-charset, --disable-keys 该选项默认开启,  可以用--skip-opt禁用.

    mysqldump  -uroot -p --host=localhost --all-databases --opt

    53、  --order-by-primary

    如果存在主键,或者第一个唯一键,对每个表的记录进行排序。在导出MyISAM表到InnoDB表时有效,但会使得导出工作花费很长时间。 

    mysqldump  -uroot -p --host=localhost --all-databases --order-by-primary

    54、  --password, -p    //连接数据库密码

    55、  --pipe(windows系统可用)

    //使用命名管道连接mysql

    mysqldump  -uroot -p --host=localhost --all-databases --pipe

    56、  --port, -P        //连接数据库端口号

    57、  --protocol 

    //使用的连接协议,包括:tcp, socket, pipe, memory.

    mysqldump  -uroot -p --host=localhost --all-databases --protocol=tcp

    58、  --quick, -q

    //不缓冲查询,直接导出到标准输出。默认为打开状态,使用--skip-quick取消该选项。

    mysqldump  -uroot -p --host=localhost --all-databases 

    mysqldump  -uroot -p --host=localhost --all-databases --skip-quick

    59、  --quote-names,-Q

    使用(`)引起表和列名。默认为打开状态,使用--skip-quote-names取消该选项。

    mysqldump  -uroot -p --host=localhost --all-databases

    mysqldump  -uroot -p --host=localhost --all-databases --skip-quote-names

    60、  --replace

    使用REPLACE INTO 取代INSERT INTO.

    mysqldump  -uroot -p --host=localhost --all-databases --replace

    61、  --result-file,  -r

    直接输出到指定文件中。该选项应该用在使用回车换行对(\\r\\n)换行的系统上(例如:DOS,Windows)。该选项确保只有一行被使用。

    mysqldump  -uroot -p --host=localhost --all-databases --result-file=/tmp/mysqldump_result_file.txt

    62、  --routines, -R

    导出存储过程以及自定义函数。

    mysqldump  -uroot -p --host=localhost --all-databases --routines

    63、  --set-charset

    添加'SET NAMES  default_character_set'到输出文件。默认为打开状态,使用--skip-set-charset关闭选项。

    mysqldump  -uroot -p --host=localhost --all-databases 

    mysqldump  -uroot -p --host=localhost --all-databases --skip-set-charset

    64、  --single-transaction

    该选项在导出数据之前提交一个BEGIN SQL语句,BEGIN 不会阻塞任何应用程序且能保证导出时数据库的一致性状态。它只适用于多版本存储引擎,仅InnoDB。本选项和--lock-tables 选项是互斥的,因为LOCK  TABLES 会使任何挂起的事务隐含提交。要想导出大表的话,应结合使用--quick 选项。

    mysqldump  -uroot -p --host=localhost --all-databases --single-transaction

    65、  --dump-date

    将导出时间添加到输出文件中。默认为打开状态,使用--skip-dump-date关闭选项。

    mysqldump  -uroot -p --host=localhost --all-databases

    mysqldump  -uroot -p --host=localhost --all-databases --skip-dump-date

    66、  --skip-opt       //禁用–opt选项.

    mysqldump  -uroot -p --host=localhost --all-databases --skip-opt

    67、  --socket,-S

    指定连接mysql的socket文件位置,默认路径/tmp/mysql.sock

    mysqldump  -uroot -p --host=localhost --all-databases --socket=/tmp/mysqld.sock

    68、  --tab,-T

    为每个表在给定路径创建tab分割的文本文件。注意:仅仅用于mysqldump和mysqld服务器运行在相同机器上。

    mysqldump  -uroot -p --host=localhost test test --tab="/home/mysql"

    69、  --tables

    覆盖--databases (-B)参数,指定需要导出的表名。

    mysqldump  -uroot -p --host=localhost --databases test --tables test

    70、  --triggers

    导出触发器。该选项默认启用,用--skip-triggers禁用它。

    mysqldump  -uroot -p --host=localhost --all-databases --triggers

    71、  --tz-utc

    在导出顶部设置时区TIME_ZONE='+00:00' ,以保证在不同时区导出的TIMESTAMP 数据或者数据被移动其他时区时的正确性。

    mysqldump  -uroot -p --host=localhost --all-databases --tz-utc

    72、  --user, -u         //指定连接的用户名。

    73、  --verbose, --v    //输出多种平台信息。

    74、  --version, -V

    输出mysqldump版本信息并退出

    75、  --where, -w

    只转储给定的WHERE条件选择的记录。请注意如果条件包含命令解释符专用空格或字符,一定要将条件引用起来。

    mysqldump  -uroot -p --host=localhost --all-databases --where=” user=’root’”

    76、  --xml, -X     //导出XML格式.

    mysqldump  -uroot -p --host=localhost --all-databases --xml

    77、  --plugin_dir

    客户端插件的目录,用于兼容不同的插件版本。

    mysqldump  -uroot -p --host=localhost --all-databases --plugin_dir=”/usr/local/lib/plugin”

    78、  --default_auth

    客户端插件默认使用权限。

    mysqldump  -uroot -p --host=localhost --all-databases --default-auth=”/usr/local/lib/plugin/<PLUGIN>”

    展开全文
  • java导出sql文件

    2021-02-12 13:30:34
    } } sql=sql.substring(0,sql.length()-2)+"'"; sql += " || ' );' from " + tableName+ where; rs.close(); // System.out.println("DEBUG: SQL="+sql); //执行 statement = conn.createStatement(); rs = ...
  • java执行sql脚本

    2021-03-09 00:10:21
    java执行sql脚本使用工具:ibatis(目前以集成在MyBatis3.0.1或更高版本中部分3.x.x版本已移除ibatis,本文使用MyBatis3.0.1MyBatis2.5.x同样集成ibatis,但无法使用支持JDK版本:1.5及以上import org.apache.ibatis....
  • Java读取sql脚本并写入数据库

    千次阅读 2019-07-28 02:02:51
    在做软件部署或者安装的时候,有时候需要手动去导入数据库的sql脚本,涉及到多个库的时候手动太low,这里做了一个简单的建表建库操作。我们这里主要用到的方法是:mybatis ScriptRunner: 这里我们直接通过jdbc去...
  • 最近遇到需要将SQLServer数据库中的数据...于是在下经过各种尝试终于实现了使用java代码实现导入导出的功能,希望能够遇到这种需求的开发人员一点帮助。talk is cheap,show you the code! 导入功能: 直接使用j...
  • 实际原理是利用java中的runtime类来开启操作系统的命令行进程执行导出导入数据库的dos命令来完成的1.了解相关的导入和导出的dos命令简单介绍一下MYSQL命令: mysql-&gt;CREATE DATABASE dbname;//创建数据库 ...
  • SQLServer2008的导出脚本方法:数据库名-->右键 任务-->生存脚本之后弹出SQLServer脚本生成向导选择数据库把编写...结构、表的选择整合到了第一个界面,脚本选项隐藏到的最后脚本导出界面的高级选项里但是脚...
  • 我有一个脚本,通过命令行将数据(包括CLOB)从Oracle SQL导出到CSV . 当我执行脚本然后通过Python查看数据时,我获得每行的正确列数以及正确的数据 . 但是,每个单元格中都有额外的空格 . 我的方法:file.sql :spool...
  • 直接上代码package ...import java.io.File;import java.io.FileReader;import java.io.Reader;import java.nio.charset.Charset;import java.sql.Connection;import java.sql.DriverManager;import org.apache...
  • 线上服务器一般都禁止直接访问,所以无法用工具直接导出数据到excel。这个小工具项目为了方便导出
  • 1 @IocBean2 public classSqlCommandModel{34 //用户名5 @Inject("java:$conf.get('jdbc.username')")6 privateString username;7 //用户密码8 @Inject("java:$conf.get('jdbc.password')")9 priva...
  • SQL脚本导出器(可直接导出成insert形式的语句) 如: insert TABLENAME() values()
  • 从 Oracle数据库中导出数据库对象创建和申明的SQL脚本
  • java查询sql导出到excel方法

    千次阅读 2018-03-31 10:59:44
    1、首先,我们需要知道的是:可以直接使用sql语句(命令行)查询之后导出到excelmysql -uroot -ppassword -e"select * from XXX " tase_db &gt; /home/A.xls准备篇:2、实验室的需求,需要每天执行一...
  • SQL Server导出和导入大数据量SQL脚本

    千次阅读 2020-01-15 18:39:56
    1、使用SQLServerManagement Studio导出SQL脚本 2、使用命令行导入大数据量SQL脚本 用SQLServerManagement Studio导入大数据量SQL脚本时,很容易出现了out of memory异常,可用命令行导入 打开cmd执行...
  • 使用Java实现导出导入数据库的sql文件 实际原理是利用java中的runtime类来开启操作系统的命令行进程执行导出导入数据库的dos命令来完成的 1.了解相关的导入和导出的dos命令 简单介绍一下MYSQL命令: mysql->...
  • 可用第三方工具PLSQL Developer将oracle的数据导成SQL脚本。 使用工具:PLSQL Developer 步骤: 1、打开PLSQL Developer,并登录到要导出数据的库里。 2、进入后,点击上方菜单栏的“工具”—“导出表”。 3、然后...
  • java+servlet+mysql实现条件筛选(详情见文件sql脚本)
  • java生成sql文件

    2021-03-16 11:18:20
    java生成sql文件场景 场景 用于清理数据库数据,生成sql语句脚本,方便DBA执行 @RequestMapping("/cleanQuestion") @ResponseBody public AjaxResult cleanQuestion(@ModelAttribute("common") Common common, ...
  • 脚本功能简述1、导出远程mysql数据库表数据到本地并保存为文件2、支持将要导出数据的表信息配置到配置文件中,脚本会循环配置文件并解析配置文件,然后完成后续数据导出。3、支持按时间的增量导出,内置时间变量${...
  • 在MySQL workbench 中导出sql脚本文件 1.有两种进入数据导出的方式,点击data expoert 2.进入到这个页面 3.选择数据库和表 4.选择导出内容 dump stored procedure and functions: 导出存储过程和功能 dump even: ...
  • 因为初始化数据来自于sql脚本,所以我得读取sql脚本的内容并解析成相关的sql语句通过java的jdbc执行sql语句。那就开始做吧。不多说,上代码:      1   package  com.infopatent.juangetljc.core; ...
  • NULL 博文链接:https://zhouwenjun.iteye.com/blog/526159
  • 可以把oracle中大量数据导出为txt格式,便于在线下载、存储等后续处理。已经测试过,可以执行。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,279
精华内容 8,911
关键字:

java实现sql脚本导出

java 订阅