从MYSQL到oracle的迁移以及备份的方法

40次阅读

共计 8601 个字符，预计需要花费 22 分钟才能阅读完成。

本篇内容介绍了“从 MYSQL 到 oracle 的迁移以及备份的方法”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让丸趣 TV 小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

一、MYSQL 可以导入导出脚本，本来应该准备好数据库的备份的初始化数据库和初始化数据的两个初始化脚本，经由 MYSQL 导出为一个 full.sql 的总的初始化脚本，用过 mysql 的都知道，导出的数据库脚本中，包含了建库、建表、以及插入数据的语句。需要分割成两个：建库、建表的初始化脚本和插入数据的初始化脚本。于是我写了一个类，用于分割 SQL 脚本，在类中，我查找到 create table 开头的后面紧跟着的字符串，就是表的名字，取出 insert 开头的语句，改行就是插入数据的，于是，通过文件流读取文件的每一行，如果是插入的取出来放入一个方法 convertInsertSQL 处理后写入一个脚本文件 insert_data.sql 中，剩下的写入一个脚本文件 create_table.sql 中, 方法 convertInsertSQL 对于插入语句做处理，因为脚本中的插入语句是批量插入的，insert into 表名 (列名) values(对应值),(对应值),(对应值)，所以需要拆分成 insert into 表名(列名) values (对应值) 这样的语句，所以我通过将前面 values(前的值截取后，对剩下的所有对应数据，进行通过),(用正则分割成 String 数组，对数组进行循环，每次追加组成插入语句，最后将插入语句全部返回后写入文件流。
package com.test.file;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.HashMap;
import java.util.Map;

/**
* 将 mysql 数据库导出的脚本
* 分割成为建库和建表的两个脚本
* @author gaofei
*
*/
public class MyFileReader {

/**
* @param args
*/
public static void main(String[] args) {
String full_sql_path= C:/Documents and Settings/gaofei/ 桌面 / 最终 mysql 脚本(12.15).sql
String create_sql_path= C:/Documents and Settings/gaofei/ 桌面 / 建立数据库初始化.sql
String insert_sql_path= C:/Documents and Settings/gaofei/ 桌面 / 数据初始化.sql
try {
readFull_to_insert(full_sql_path, create_sql_path, insert_sql_path);
} catch (IOException e) {
System.out.println(文件读取或写入出错
e.printStackTrace();
}

// String aa= insert into `templatetype`(`id`,`templatetypename`,`deflong`,`defdate`,`defvar`) values (0, 通用模板类型 ,0,NULL,NULL),(1, 首页模板类型 ,0,NULL,NULL),(2, 栏目模板类型 ,0,NULL,NULL),(3, 专题模板类型 ,0,NULL,NULL),(4, 内容模板类型 ,0,NULL,NULL),(5, 留言模板类型 ,0,NULL,NULL),(6, 投票模板类型 ,0,NULL,NULL),(7, 特殊模板类型 ,0,NULL,NULL);
// String bb=full_to_part(aa);
// System.out.println(bb);
}
/**
* 将整体的导出的 mysql 脚本，拆分为建库建表和插入数据的脚本
* 将其中的批量插入数据语句转换为每条插入数据语句的脚本
* @param full_sql_path 原始全部导出的 mysql 脚本
* @param create_sql_path 拆出来的建库建表的脚本
* @param insert_sql_path 拆出来的插入数据脚本
* @throws IOException
*/
private static void readFull_to_insert(String full_sql_path,String create_sql_path,String insert_sql_path) throws IOException{
File fullFile=new File(full_sql_path);
File createFile=new File(create_sql_path);
if(!createFile.exists())
createFile.createNewFile();
File insertFile=new File(insert_sql_path);
if(!insertFile.exists())
insertFile.createNewFile();
InputStreamReader isr=new InputStreamReader(new FileInputStream(fullFile), UTF-8
BufferedReader br=new BufferedReader(isr);
OutputStreamWriter osw_create=new OutputStreamWriter(new FileOutputStream(createFile), UTF-8
OutputStreamWriter osw_insert=new OutputStreamWriter(new FileOutputStream(insertFile), UTF-8
BufferedWriter bw_create=new BufferedWriter(osw_create);
BufferedWriter bw_insert=new BufferedWriter(osw_insert);
Map Integer, String allData=new HashMap Integer,String
String line=null;
int num=17;
while((line=br.readLine())!=null){
String lowerLine=line.toLowerCase();
if(lowerLine.startsWith( insert)){ // 在该语句下用来判断插入数据的先后顺序
if(lowerLine.indexOf( `sequenceblock`)!=-1){
allData.put(1, line);
}else if(lowerLine.indexOf( `operationlogtype`)!=-1){
allData.put(2, line);
}else if(lowerLine.indexOf( `website`)!=-1){
allData.put(3, line);
}else if(lowerLine.indexOf( `fucdefine`)!=-1){
allData.put(4, line);
}else if(lowerLine.indexOf( `role`)!=-1){
allData.put(5, line);
}else if(lowerLine.indexOf( `department`)!=-1){
allData.put(6, line);
}else if(lowerLine.indexOf( `cmsuser`)!=-1){
allData.put(7, line);
}else if(lowerLine.indexOf( `account`)!=-1){
allData.put(8, line);
}else if(lowerLine.indexOf( `accountrole`)!=-1){
allData.put(9, line);
}else if(lowerLine.indexOf( `flowdefine`)!=-1){
allData.put(10, line);
}else if(lowerLine.indexOf( `flowtask`)!=-1){
allData.put(11, line);
}else if(lowerLine.indexOf( `rolefucperm`)!=-1){
allData.put(12, line);
}else if(lowerLine.indexOf( `templategroup`)!=-1){
allData.put(13, line);
}else if(lowerLine.indexOf( `templatetype`)!=-1){
allData.put(14, line);
}else if(lowerLine.indexOf( `template`)!=-1){
allData.put(15, line);
}else if(lowerLine.indexOf( `contenttype`)!=-1){
allData.put(16, line);
}else{
allData.put(num++, line);
}
}else{
bw_create.append(line+ \r\n
}
}
for (int i = 1; i num; i++) {
if(allData.containsKey(i)){
bw_insert.append(full_to_part(allData.get(i)));
}
}

bw_create.flush();
bw_insert.flush();
br.close();
bw_create.close();
bw_insert.close();
}
// private static void setSequence(){
//
// }

/**
* 将一行批量插入的数据转换为多行插入
* @param line
* @return
*/
private static String full_to_part(String line){
StringBuffer sb=new StringBuffer();
String lowerLine=line.toLowerCase();
int firstDan=lowerLine.indexOf(`
int firstQuot=lowerLine.indexOf((
String tableName=lowerLine.substring(firstDan, firstQuot);
System.out.println(————————– 开始转换插入 —- +tableName+ — 的数据 ———-
int values_position=lowerLine.indexOf(values)+7;
String forward_line=line.substring(0, values_position);

String datas_line=line.substring(values_position,line.length()-1); // 得到后面插入的数据
String[] datas=datas_line.split( \\)\\,\\(// 根据),(分割为一个字符串数组

for (int i = 0; i datas.length; i++) {
String data=null;
if(datas.length==1){ // 如果只有一条数据，不会被分割的，数组就会只有一条数据
data=datas[i];
}else{
if(i==0) // 如果是第一条，那么后面需要追加一个括号
data=datas[i]+ )
else if(i==datas.length-1) // 如果是最后一条，需要在前面加一个括号
data= (+datas[i];
else // 如果是中间的数据，前后都需要加括号
data= (+datas[i]+ )
}
sb.append(forward_line); // 将 insert 字段名和 values 先行加入
sb.append(data+
sb.append(\r\n
}
sb.append(\r\n
return sb.toString();
}

}
这是通用方法，以后需要得到 MYSQL 的两个初始化脚本就通过这个方法已转换就可以。
二、Oracle 建表的问题没有通过这个解决，可以通过 Hibernate 逆向生成。建表和表结构，表关系，都有了。
下面就是插入数据了：
关于 MYSQL 的 insert 脚本基本上和 Oracle 的一致，但是也有不一致，对于日期，对于一些符号 rsquo; 都是问题。将 MYSQL 的 insert 语句转换成 ORACLE 的 insert 语句。
1、需要将 rsquo; 去掉，这个符号是在插入数据时的表名上括起来的，所以，将表名上的 rsquo; 都替换掉。
2、需要将 date 日期，经过函数 to_date(date,”yyyy-MM-dd”)转换一下，所以我通过正则表达式来查找到所有的日期，还有一种日期，携带时分秒的日期，需要另一个正则，最后当然都是替换成为年月日就可以了。
package com.sql.convert;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class FromMYSQLInsertToOracleInsert {
/**
* 需要转换一下地方：
* 将所有的表名以及列名中的去掉
* @param args
* @throws IOException
*/

public static void main(String[] args) throws IOException {
String mysql_file= C:/Documents and Settings/gaofei/ 桌面 /insertData.sql
String oracle_file= C:/Documents and Settings/gaofei/ 桌面 /oracle_insertData.sql

turnSQL(mysql_file, oracle_file);

}
private static void turnSQL(String mysql_file,String oracle_file) throws IOException{
File mysqlFile=new File(mysql_file);
File oracleFile=new File(oracle_file);
if(!oracleFile.exists())
oracleFile.createNewFile();
InputStreamReader isr=new InputStreamReader(new FileInputStream(mysqlFile), UTF-8
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream(oracleFile), UTF-8

BufferedReader br=new BufferedReader(isr);
BufferedWriter bw=new BufferedWriter(osw);

String line=null;
while((line=br.readLine())!=null){
bw.append(convertString(line));
bw.append(\r\n
}
bw.flush();
br.close();
bw.close();
isr.close();
osw.close();
}
private static String convertString(String line){
line=line.replace(` ,
Pattern p=Pattern.compile(\\d{4}\\-\\d+\\-\\d+
Matcher m=p.matcher(line);
String date=null;
while(m.find()){
date=m.group(0);
line=line.replace(date, to_date( +date+ , yyyy-MM-dd)
}
p=Pattern.compile(\\d{4}\\-\\d+\\-\\d+\\s\\d+\\:\\d+\\:\\d+
m=p.matcher(line);
date=null;
while(m.find()){
date=m.group(0);
String newDate=date.substring(0,date.indexOf());
line=line.replace(date, to_date( +newDate+ , yyyy-MM-dd)
}
return line;
}
}

三、看似没有问题了，直接执行脚本就没问题了，但是问题又来了：
我是直接用控制开的 sqlplus 来访问 Oracle 的，没有工具，每次执行脚本，是通过 @脚本名.sql 来执行的，但是请注意如果是路径太长，比如 @”C:/Documents and Settings/gaofei/ 桌面 /oracle_insertData.sql”路径中间有空格需要加上””的，
执行报错。很多错：
1、关于数据中的 nbsp; 等这类的特殊，oracle 会认为是 plsql 中自定义的变量，当然会出问题了，所以需要设置 set define off，关掉自定义变量。
2、一个问题很少会有人用到，就是关于 Oracle 的插入数据，一个字段最多插入 2999 个字符。太多将会插入不进的。而我的数据都是模板或新闻，很多多是上万，所以问题来了。没有想到办法。最后我是将很多的数据删除的很短，插入成功后，通过程序一条条插入的。

迁移完成了，下面就是关于 Oracle 的备份问题了。www.2cto.com

说是可以准备 SQL 脚本，但是脚本到时候还会是 INSERT 语句，到时候又不能插入了。
所以是通过 ORACLE 的备份命令，备份出 DMP 文件。
刚开始是用 SYSTEM 用户直接备份的，但是会有很多的系统表，这是不符合要求的。于是建立一个用户 future，用 future 用户逆向生成表结构、表关系。然后通过赋予 futureDBA 权限，通过 insert into sequenceblock select * from system.sequenceblock; 将所有表中有数据的表都从 system 导入到 future 用户中。
这样表就再 future 用户的指定表空间中建立出来了。
通过 future 直接备份数据。有两种备份方式。
$exp future/ylzxdb1219@ylzxdb file=D:/future_final.dmp full=y;
以 future 身份导出了所有库的信息
$exp future/ylzxdb1219@ylzxdb file=D:/future_user.dmp owner=future;
以 future 的身份导出了 future 用户中所有的数据。
但是 future 有 DBA 权限，所以会再备份时将系统表备份。所以推荐第二种方式。导出的只是当前用户 future 的所有表的备份。
导入数据：
$imp future/ylzxdb1219@ylzxdb fromuser=future touser=future ignore=y file=D:/future_user.dmp;
（注：例句是将的备份文件放在了 D: 盘下的 future.user.dmp 文件）

“从 MYSQL 到 oracle 的迁移以及备份的方法”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注丸趣 TV 网站，丸趣 TV 小编将为大家输出更多高质量的实用文章！

正文完