通过jdbc实现Oracle备份到Mysql

最新推荐文章于 2023-02-20 16:47:06 发布
最新推荐文章于 2023-02-20 16:47:06 发布
阅读量2.5k 收藏 1
点赞数
分类专栏： web

一直用的系统是 Oracle的数据库，现在一个客户比较小，不想投入钱购买数据库软件，所以只能使用Mysql，需要将框架中的一些表结构、记录从Oracle导入到Mysql中去。网上没找到好用的软件，所以决定自己弄一个小程序实现异构库备份：
思路比较简单， 先生成建表语句并在mysql库中执行，在生成insert语句在mysql中执行。

一

生成建表语句重点是需要获取表的字段，默认值，是否为空， 字段类型、字段长度等， 万幸的是这些jdbc都有实现，通过Connect获取数据库的DatabaseMetaData–dmd，

               System.out.println("加载Oracle链接0...");
        connect = connect(0);

        System.out.println("加载Mysql链接1...");
        insertConnect = connect(1);

        System.out.println("获取dmd...");
        dmd = connect.getMetaData();

再通过DatabaseMetaData–dmd查询表单字段信息,

ResultSet colrs = dmd.getColumns("%", dmd.getUserName(),table.toUpperCase(), "%");

然后解析获取到的ResultSet信息后即可获取到字段的全部信息，生成建表语句：

二

取生成insert语句类似，需要适用select语句查询表的信息，然后循环解析每一行的记录，生成insert插入，此处执行sql的是PreparedStatement，可以循环适用insert语句，仅需要改变每一次动态设置的值属性即可。

全部代码比较简单，直接上代码：
有两个类：jdbc工具类：JDBCUtil.java

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

public class JDBCUtil {

    public static Connection connect(int type) {
        Connection conn;

        if (type == 0) {//oracle
            conn = connectOracle();
        } else {        //Mysql
            conn = connectMysql();
        }

        return conn;
    }

    /**
     * 连接Oracle
     * 
     * @return
     */
    public static Connection connectMysql() {

        // 连接MySql数据库，用户名和密码
        String username = "111212";
        String password = "2121";
        String url = "jdbc:mysql://192.168.1.1/training?user=" + username+ "&password=" + password + "";
        Connection conn = null;

        try {
            // 加载MySql的驱动类
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(url);
        } catch (ClassNotFoundException e) {
            System.out.println("找不到驱动程序类 ，加载驱动失败！");
            e.printStackTrace();
        } catch (SQLException se) {
            System.out.println("数据库连接失败！");
            se.printStackTrace();
        }

        return conn;
    }

    /**
     * 连接Oracle
     * 
     * @return
     */
    public static Connection connectOracle() {
        String url = "jdbc:oracle:thin:@192.168.1.1:1521:orcl";

        // 连接MySql数据库，用户名和密码都是root
        String username = "abcaf";
        String password = "syjgagagac";
        Connection conn = null;

        try {
            // 加载MySql的驱动类
            Class.forName("oracle.jdbc.OracleDriver");
            conn = DriverManager.getConnection(url, username, password);
        } catch (ClassNotFoundException e) {
            System.out.println("找不到驱动程序类 ，加载驱动失败！");
            e.printStackTrace();
        } catch (SQLException se) {
            System.out.println("数据库连接失败！");
            se.printStackTrace();
        }

        return conn;
    }


    public static List getColumnNames(ResultSetMetaData meta) throws SQLException{
        List list = new ArrayList();
        for (int i = 1; i <= meta.getColumnCount(); i++) {
            list.add(meta.getColumnName(i));
        }
        return list;
    }


    // ResultSetMetaData 使用示例
    // 此方法参考 http://blog.csdn.net/yirentianran/article/details/2950321
    public static void demoResultSetMetaData(ResultSetMetaData data)
            throws SQLException {
        for (int i = 1; i <= data.getColumnCount(); i++) {
            // 获得所有列的数目及实际列数
            int columnCount = data.getColumnCount();
            // 获得指定列的列名
            String columnName = data.getColumnName(i);
            // 获得指定列的列值
            // String columnValue = rs.getString(i);
            // 获得指定列的数据类型
            int columnType = data.getColumnType(i);
            // 获得指定列的数据类型名
            String columnTypeName = data.getColumnTypeName(i);
            // 所在的Catalog名字
            String catalogName = data.getCatalogName(i);
            // 对应数据类型的类
            String columnClassName = data.getColumnClassName(i);
            // 在数据库中类型的最大字符个数
            int columnDisplaySize = data.getColumnDisplaySize(i);
            // 默认的列的标题
            String columnLabel = data.getColumnLabel(i);
            // 获得列的模式
            String schemaName = data.getSchemaName(i);
            // 某列类型的精确度(类型的长度)
            int precision = data.getPrecision(i);
            // 小数点后的位数
            int scale = data.getScale(i);
            // 获取某列对应的表名
            String tableName = data.getTableName(i);
            // 是否自动递增
            boolean isAutoInctement = data.isAutoIncrement(i);
            // 在数据库中是否为货币型
            boolean isCurrency = data.isCurrency(i);
            // 是否为空
            int isNullable = data.isNullable(i);
            // 是否为只读
            boolean isReadOnly = data.isReadOnly(i);
            // 能否出现在where中
            boolean isSearchable = data.isSearchable(i);
            System.out.println(columnCount);
            System.out.println("获得列" + i + "的字段名称:" + columnName);
            // System.out.println("获得列" + i + "的字段值:" + columnValue);
            System.out.println("获得列" + i + "的类型,返回SqlType中的编号:" + columnType);
            System.out.println("获得列" + i + "的数据类型名:" + columnTypeName);
            System.out.println("获得列" + i + "所在的Catalog名字:" + catalogName);
            System.out.println("获得列" + i + "对应数据类型的类:" + columnClassName);
            System.out.println("获得列" + i + "在数据库中类型的最大字符个数:"
                    + columnDisplaySize);
            System.out.println("获得列" + i + "的默认的列的标题:" + columnLabel);
            System.out.println("获得列" + i + "的模式:" + schemaName);
            System.out.println("获得列" + i + "类型的精确度(类型的长度):" + precision);
            System.out.println("获得列" + i + "小数点后的位数:" + scale);
            System.out.println("获得列" + i + "对应的表名:" + tableName);
            System.out.println("获得列" + i + "是否自动递增:" + isAutoInctement);
            System.out.println("获得列" + i + "在数据库中是否为货币型:" + isCurrency);
            System.out.println("获得列" + i + "是否为空:" + isNullable);
            System.out.println("获得列" + i + "是否为只读:" + isReadOnly);
            System.out.println("获得列" + i + "能否出现在where中:" + isSearchable);
        }
    }

    // 演示 DatabaseMetaData
    public static void demoDatabaseMetaData() {
        try {
            Connection con = connect(0);
            //
            DatabaseMetaData dmd = con.getMetaData();
            System.out.println("当前数据库是：" + dmd.getDatabaseProductName());
            System.out.println("当前数据库版本：" + dmd.getDatabaseProductVersion());
            System.out.println("当前数据库驱动：" + dmd.getDriverVersion());
            System.out.println("当前数据库URL：" + dmd.getURL());
            System.out.println("当前数据库是否是只读模式？：" + dmd.isReadOnly());
            System.out.println("当前数据库是否支持批量更新？：" + dmd.supportsBatchUpdates());
            System.out .println("当前数据库是否支持结果集的双向移动（数据库数据变动不在ResultSet体现）？：" + dmd.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE));
            System.out .println("当前数据库是否支持结果集的双向移动（数据库数据变动会影响到ResultSet的内容）？：" + dmd.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE));
            System.out.println("========================================");

            // ResultSet rs = dmd.getTables(null, null, "%", null);
            // System.out.println("表名" + "," + "表类型");
            /*
             * while (rs.next()) { String tname =
             * rs.getString("TABLE_NAME").toLowerCase();
             * if(!tname.startsWith("t_")){ continue; }
             * System.out.println(rs.getString("TABLE_NAME") + ","+
             * rs.getString("TABLE_TYPE")); }
             */
            System.out.println("========================================");

            ResultSet rs = dmd.getPrimaryKeys(null, "SYJC", "t_mz_djlr".toUpperCase());
            while (rs.next()) {
                System.out .println(rs.getString(3) + "表的主键是：" + rs.getString(4));
            }
            System.out.println("========================================");

            rs = dmd.getColumns("%", "SYJC", "t_mz_djlr", "%");
            System.out.println("t_student表包含的字段:");
            while (rs.next()) {
                System.out.println(rs.getString(4) + " " + rs.getString(6) + "(" + rs.getString(7) + ");");
            }
            System.out.println("========================================");

        } catch (Exception e) {
            System.out.println("数据库操作出现异常");
        }
    }

}

还有一个实现 解析字段信息生成建表语句、解析结果生成insert语句的类DBBackUtil.java

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DBBackUtil  extends JDBCUtil{

    public static Connection connect;
    public static Connection insertConnect;
    public static DatabaseMetaData dmd;
    public static Map dataTypesMap = new HashMap();
    public static List<String> types = new ArrayList();
    public static Map<String,Boolean> unneedLength = new HashMap();



    static{
        /**
         * 此处对象的是 jdbcType  将要转换到mysql的数据类型
         */
        dataTypesMap.put(12+"","VARCHAR");
        dataTypesMap.put(3+"","DECIMAL");
        dataTypesMap.put(93+"","TIMESTAMP");
        dataTypesMap.put(1+"","CHAR");
        dataTypesMap.put(6+"","DECIMAL");
        dataTypesMap.put(2005+"","LONGTEXT");
        dataTypesMap.put(1111+"","VARCHAR");

        /***不需要长度的字段， clob（longtext）、TIMESTAMP*/
        unneedLength.put(93+"",true);
        unneedLength.put(2005+"",true);

        types.add("VARCHAR2");
        types.add("NUMBER");
        types.add("DATE");
        types.add("CHAR");
        types.add("FLOAT");
        types.add("CLOB");
        types.add("NCHAR");
    }



    public static void main(String[] args) throws SQLException {

        System.out.println("加载Oracle链接0...");
        connect = connect(0);

        System.out.println("加载Mysql链接1...");
        insertConnect = connect(1);

        System.out.println("获取dmd...");
        dmd = connect.getMetaData();

        String[] tables = { "t_base_zg" };

        String table = null;

        for (int j = 0; j < tables.length; j++) {
            table = tables[j];
            System.out.println("===========================================================");
            createCreateSQL(table);
            System.out.println("===========================================================");
            System.out.println("插入开始表："+table);
            createInsertSQL(table);
            System.out.println("插入表结束："+table);
            System.out.println("===========================================================");
        }

//      System.out.println("*******************************************");
//      for (String ty : types) {
//          System.out.println(ty);
//      }
//      System.out.println("*******************************************");
        connect.close();

    }

    private static void createInsertSQL(String table) throws SQLException {
        Statement stmt = createStmt(connect);
        String sql = "select * from "+table;
        System.out.println("查询表数据  "+table);
        ResultSet rs = stmt.executeQuery(sql);

        System.out.println("获取表字段。。。。"+table);
        List<String> columns = getColumnNames(rs.getMetaData());
        StringBuffer insertSql = new StringBuffer("INSERT INTO  "+table+"(");
        for (String col : columns) {
            insertSql.append(col+",");
        }
        insertSql.delete(insertSql.length()-1, insertSql.length());
        insertSql.append(") \n values(");
        for (String col : columns) {
            insertSql.append("?,");
        }
        insertSql.delete(insertSql.length()-1, insertSql.length());
        insertSql.append(")");
        System.out.println(insertSql.toString());

        System.out.println("循环插入数据......");
        PreparedStatement preStmt = null;
        while(rs.next()){
            preStmt = createPreStmt(insertConnect, insertSql.toString());
            //循环结果集 执行插入操作
            for (int i = 0; i < columns.size(); i++) {
                Object obj = rs.getObject(columns.get(i));

                //System.out.println(obj+"\t"+(obj!=null?obj.getClass():""));
                preStmt.setObject(i+1, obj);
            }

            int count = preStmt.executeUpdate();
            System.out.println("插入 "+count+"条");
            preStmt.clearBatch();
            preStmt.clearParameters();
            preStmt.close();
        }

        rs.close();
    }



    /**
     * 生成建表语句
     * @param table
     * @return
     * @throws SQLException
     */
    public static  String createCreateSQL(String table) throws SQLException{

        ResultSet colrs = dmd.getColumns("%", dmd.getUserName(),table.toUpperCase(), "%");

        StringBuffer sb = new StringBuffer("create table " + table + "(\n");
        System.out.println("获取表 【"+table+"】的字段创建按create语句");
        while (colrs.next()) {
            String columnName = colrs.getString("COLUMN_NAME"); //字段名
            int dataType = colrs.getInt("DATA_TYPE");           //数据类型    数字表示
            String dataTypeName = (String) dataTypesMap.get(dataType+"");
            String typeName = colrs.getString("TYPE_NAME");     //类型名       varchar2等，数据库的实际字段类型
            if(!types.contains(typeName)){
                types.add(typeName);
            }
            int columnSize = colrs.getInt("COLUMN_SIZE");
            String remarks = colrs.getString("REMARKS");
            int nullable  = colrs.getInt("NULLABLE");
            String columnDef  = colrs.getString("COLUMN_DEF");
            sb.append("\t"+columnName.toLowerCase()+"\t");//字段名

            if( columnSize == 4000 && "VARCHAR".equals(dataTypeName)){
                sb.append("Text");//daatype
            }else{
                sb.append(dataTypeName);//daatype
            }

            Boolean unNeedLength = unneedLength.get(dataType+"");
            if(!(unNeedLength!=null && unNeedLength.booleanValue())){
                if("DECIMAL".equals(dataTypeName)){
                    sb.append("("+(columnSize>10?10:columnSize));   //字段长度
                }else{
                    sb.append("("+columnSize);  //字段长度
                }
                sb.append(")");
            }

            sb.append("\t");
            //sb.append("typeName:"+typeName+"\t");
            //sb.append("dataType:"+dataType+"\t");
            if(columnDef!=null && !"".equals(columnDef.trim())){
                sb.append("default "+columnDef+" \t"); //默认值
            }
            //sb.append("remarks:"+remarks+"\t");
            sb.append((nullable == 0 ? " not null " : "")+","); //是否为空
            sb.append("\n");
        }


        //去掉最后的逗号
        sb.replace(sb.length()-3, sb.length(), "");
        System.out.println("获取表 【"+table+"】的主键....");
        /**
         * 生成主键
         */
        String keySql = createKeySqlByTableName(table);
        if(keySql!=null && keySql.length()>0){
            sb.append(",\n");
            sb.append("\t"+keySql+"\n");
        }

        sb.append(") ENGINE=INNODB ;");
        System.out.println(sb.toString());

        Statement stmt = createStmt(insertConnect);
        System.out.println("执行表 【"+table+"】的建表语句 ....");
        boolean runRs = stmt.execute(sb.toString());
        System.out.println("上述建表语句 执行完成");

        return sb.toString();
    }






    /**
     * 获取表主键集合
     * @return
     * @throws SQLException
     */
    private static List getTableKeys(String tableName) throws SQLException{
        ResultSet  rs = dmd.getPrimaryKeys(null, "SYJC", tableName.toUpperCase());//此处旭要将表名设置成大写 oracle 只认大写
        List list = new ArrayList();
        while (rs.next()) {
            list.add(rs.getString(4).toLowerCase());
        }
        rs.close();
        return list;
    }

    /**
     * 将表名拼接成Key sql
     * @param tableName
     * @return
     * @throws SQLException
     */
    public static String createKeySqlByTableName(String tableName) throws SQLException{

        List list = getTableKeys(tableName);

        return createKeySql(list);
    }

    /**
     * 将字段拼接成Key sql
     * @param list
     * @return
     */
    public static String createKeySql(List<String> list){

        if(list==null || list.size()<=0){
            return null;
        }

        StringBuffer keySql = new StringBuffer();
        keySql.append("primary key (");
        for (int i = 0; i < list.size(); i++) {
            if(i!=0 ){
                keySql.append(",");
            }
            keySql.append(list.get(i));
        }
        keySql.append(")");

        return keySql.toString();
    }







    public static PreparedStatement createPreStmt(Connection conn, String sql) {
        PreparedStatement pstmt = null;
        try {
            pstmt = conn.prepareStatement(sql);
        } catch (SQLException e) {
            System.out.println("生成预处理stmt失败");
            e.printStackTrace();
        }
        return pstmt;
    }

    public static Statement createStmt(Connection conn) {
        Statement pstmt = null;
        try {
            pstmt = conn.createStatement();
        } catch (SQLException e) {
            System.out.println("生成预处理stmt失败");
            e.printStackTrace();
        }
        return pstmt;
    }



    /**
     * 解析ResultSet的单条记录,不进行 ResultSet 的next移动处理
     * 
     * @param rs
     * @return
     */
    private static Map<String, Object> parseResultSetToMap(ResultSet rs) {
        //
        if (null == rs) {
            return null;
        }
        //
        Map<String, Object> map = new HashMap<String, Object>();
        //
        try {
            ResultSetMetaData meta = rs.getMetaData();
            //
            int colNum = meta.getColumnCount();
            //
            for (int i = 1; i <= colNum; i++) {
                // 列名
                String name = meta.getColumnLabel(i); // i+1
                Object value = rs.getObject(i);
                // 加入属性
                map.put(name, value);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        //
        return map;
    }


//  /**
//   * varchar2 number date char clob nchar
//   * 
//   * @return
//   */
//  public static Map createMappingRelation() {
//      Map map = new HashMap();
//      map.put("varchar2", "varchar");
//      map.put("number", "varchar");
//      map.put("date", "datetime");
//      map.put("char", "charo");
//      map.put("clob", "mediumtext");
//      map.put("nchar", "varchar");
//      return map;
//  }

}

通过dmd 获取字段信息 请参考：http://blog.sina.com.cn/s/blog_707a9f0601014y1y.html

转载请注明出处：http://314649444.iteye.com/admin/blogs/2307007

撸码小丑
关注
专栏目录
基于JDBC同步Oracle到MySQL
10-18
主程序位置：com.database.main.com.database.main 直接运行main方法即可，使用线程同步，间隔5分钟同步一次 分别有：数据源配置、数据表结构转换、字段更新、数据迁移、根据oracle SQL的UPDATE DELETE 事物执行记录转为Mysql可执行SQL，同步执行到MySql数据库，此项目为个人兴趣爱好练手项目，项目问题欢迎留言，共同进步成长。 说明文档：https://blog.csdn.net/u010636072/article/details/109147827
jdbc(oracle,mysql)
08-03
在Java中，使用JDBC连接MySQL数据库的过程与Oracle类似，但需要加载对应的MySQL JDBC驱动，如mysql-connector-java.jar。MySQL的JDBC驱动支持最新的JDBC 4.2规范，提供更高效的批处理和连接池管理。 JDBC的核心组件...
纯jdbc操作oracle数据库迁移至mysql数据库（测试2000张表，单表数据超过百万，不会出现OOM）
念念不忘，必有回响
01-15 1091
文章目录前言编码前思考实现demo结构引入依赖实现类优化源码 前言 数据迁移向来是麻烦的，如果有oracle转mysql 需求，数据迁移就是一大问题 在数据迁移前曾百度一些方案： 1.使用nacavit的数据传输功能 跑着跑着就失败了，问题难以分析 使用kettle kettle使用起来其实还是挺方便的，但是唯一不好的地方是每个表都要做抽数脚本，要表少，一个一个做倒还好 ，但是现在系统有200...
mysql备份数据库 jdbc,透过jdbc实现Oracle备份到Mysql
weixin_30990711的博客
03-18 212
一直用的系统是 Oracle的数据库，现在一个客户比较小，不想投入钱购买数据库软件，所以只能使用Mysql，需要将框架中的一些表结构、记录从Oracle导入到Mysql中去。网上没找到好用的软件，所以决定自己弄一个小程序实现异构库备份：思路比较简单， 先生成建表语句并在mysql库中执行，在生成insert语句在mysql中执行。一：生成建表语句重点是需要获取表的字段，默认值，是否为空， 字段类型...
JAVA基于JDBC封装编写Oracle数据同步到MySql数据库
u010636072的博客
10-18 1233
此项目为个人练手项目，封装了JDBC工具 相关Jar包 ojdbc6jar不要随意更换，会有日期转换的问题 commons-lang3-3.1.jar fastjson-1.2.58.jar mysql-connector-java-5.1.18-bin.jar ojdbc6.jar
JDBC 备份还原数据库
haocrab的记录本
07-18 2418
jdbcTest.java package test; import java.sql.Connection; import java.sql.SQLException; import org.junit.Test; import service.JdbcUtil; import service.XmlUtil; public class JdbcTest { @Test publ
oracle+MySQL+jdbc数据库教程-视频教程网盘链接提取码下载.txt
最新发布
09-28
- **备份与恢复**：介绍Oracle备份策略、备份工具以及恢复流程。 #### 二、MySQL数据库基础 ##### 2.1 MySQL概述 - **简介**：MySQL是一款开源的关系型数据库管理系统，广泛应用于Web应用。 - **优势**：易于使用...
MySql和Oracle数据库本地或远程备份导出和导入（JAVA版）工具类.rar
06-11
- 如果工具类提供了Oracle的支持，它可能通过JDBC连接到数据库，并执行自定义的SQL查询或PL/SQL存储过程来实现数据的导出和导入。 3. **JAVA编程接口**： - `DatabaseBackup.java` 文件很可能是这个工具类的实现...
mysql和Oracle的多数据源配置demo
03-01
1. **依赖引入**：在`pom.xml`中添加MySQL和Oracle的JDBC驱动依赖，同时确保引入SpringBoot的数据源相关依赖，例如`spring-boot-starter-jdbc`。 2. **配置文件**：在`application.properties`或`application.yml`...
JDBC查询返回数据集一直为空，明明数据库(MySQL)有数据的解决办法
12-14
在使用Java的JDBC进行MySQL数据库操作时，有时可能会遇到这样一个困扰：明明数据库中存在数据，但是通过JDBC执行查询语句后返回的数据集却始终为空。这种情况通常是由于编码问题导致的，具体来说，是项目编码与...
深入ORACLE迁移到MYSQL的总结分析
12-15
这两个星期里一直都在忙于一件事儿，就是数据库的迁移问题。没有做的时候感觉这是一件十分轻松的事儿，可是等到实实在在去做去实现的时候，自己傻眼了。这种纠结啊，在这里先说下遇到的问题：1。数据库的表结构问题：数据类型不同需要解决varchar2——varchar、number—–int、date—-datetime，建表的sql语句字段默认值、注释怎么解决。2. oracle中没有所谓的敏感字段，可是mysql表中的敏感字段有好多。当时出错的时候很奇怪不知道是哪里错了。原来有个describe的字段是mysql的敏感字段。这里我也是在网上找了一个现成的工具：oracletomysql，它是只能为我们
jdbc实现对oracle与mysql数据库的具体操作——java
LIUZHIOJ的博客
11-23 778
结构图：我们能操作:JDBC API(通过包) JDBC API的作用： 完成JDBC API这三个功能需要的类或接口：DriverManager（管理jdbc驱动），Connection（连接），Statement（或PreparedStatement实现增删改查），CallableStatement（调用数据库中的 存储过程/存储函数），ResultSet（返回的结果集）。 j...
java中jdbc,mybatis连接mysql数据库调用oracle存储过程
路飞船长的博客
02-20 667
因为数据库的原因所以一些操作需要在oracle进行,然后进行数据同步的时候需要用到调用存储过程。
使用Streamsets将Oracle数据实时同步到MySQL中
JJBOOM425的博客
12-30 4753
相关环境： Oracle 11g：11.2.0.1.0 MySQL：8.0.22 前期准备： 1、打开Oracle的logminer a.在SQL Shell中，以具有DBA的用户身份登录数据库： sqlplus /nolog; conn / as sysdba; b.检查数据库日志记录模式： select log_mode from v$database; 如果查询结果是ARCHIVELOG，则以下操作都不用执行，如果命令返回NOARCHIVELOG，请继续执行以下步骤： c..
[Oracle-> MySQL] Oracle通过dblink连接MySQL
coco3600的博客
09-07 514
[Oracle-> MySQL] Oracle通过dblink连接MySQL Oracle直连...
Java环境下实现oracle数据库的备份与还原
不积跬步，无以至千里；不积小流，无以成江海。
02-19 994
1.编写测试类TestOracle package com; public class TestOracle { /** * @param args * @throws InterruptedException */ public static void main(String[] args) throws InterruptedException { // TODO
mysql数据库连接oracle_Java实现连接oracle/mysql数据库功能简单示例
weixin_35367646的博客
02-02 331
这篇文章主要介绍了java实现的连接oracle/mysql数据库功能,结合实例形式分析了java基于jdbc连接Oracle与mysql的相关操作技巧,并附带完整实例代码与oracle+mysql数据库驱动包供读者下载参考,需要的朋友可以参考下本文实例讲述了java实现的连接oracle mysql数据库功能。分享给大家供大家参考，具体如下：package com.nuo.test.Connec...
oracle的dump导入mysql,oracle导出导入（数据泵）dump文件到本地
weixin_39888049的博客
03-24 246
EXPDP 通过 NETWORK_LINK 导出远程库到本地：在客户端数据库创建 dblink 和要保存数据文件的目录：使用plsql登录本地数据库conn /如用cawy_cas用户名登录本地数据库，然后用下列语句创建远程数据库桥接create database link connect to identified by using '';create database link ddd ...
手动将oracle数据库迁移至mysql数据库
三木的博客
05-24 774
本文所介绍的如有错误，还请指出！ 从oracle导出数据时： 先导出建表语句，PLSQL中，工具-导出用户对象，选择用户后导出。 再导出数据，首先确定那些表的数据是需要的，然后每张表上右键-导出数据-sql插入 插入到mysql数据库时： 建表语句中： (1)一些mysql的关键字，如MAXVALUE、ORDER，然后用··注释(ESC键下面的键)
Oracle SQL Developer数据迁移指南：MySQL到Oracle
"Oracle SQL Developer 数据迁移教程：从 MySQL 到 Oracle 的详细步骤" Oracle SQL Developer 是一款强大的数据库管理工具，它支持多种数据库平台之间的数据迁移，包括从 MySQL 到 Oracle。下面将详细介绍如何使用 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值