开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
MigrationOracle.java
资源名称：mysql-gui-tools-noinstall-5.0-r17-win32.zip　[点击查看]
上传用户：cccombo
上传日期：2021-01-31
资源大小：16445k
文件大小：16k
源码类别：

MySQL数据库

开发平台：

SQL

MigrationOracle.java：源码内容
  1. package com.mysql.grt.modules;
  3. import com.mysql.grt.*;
  4. import com.mysql.grt.db.Catalog;
  5. import com.mysql.grt.db.migration.*;
  6. import com.mysql.grt.db.oracle.*;
  8. /**
  9.  * GRT Migration Class for Oracle 8i/9i
  10.  * 
  11.  * @author Mike
  12.  * @version 1.0, 01/11/05
  13.  * 
  14.  */
  15. public class MigrationOracle extends MigrationGeneric {
  17. /**
  18.  * Static function to return information about this class to the GRT
  19.  * environment
  20.  * 
  21.  * @return returns a GRT XML string containing the info about this class
  22.  */
  23. public static String getModuleInfo() {
  24. return Grt.getModuleInfoXml(MigrationOracle.class, "MigrationGeneric");
  25. }
  27. /**
  28.  * Collects information about the migration methods to let the user choose
  29.  * which one to take
  30.  * 
  31.  * @return returns a Method with predefined migration parameters
  32.  */
  33. public static MethodList migrationMethods() {
  34. MethodList methods = MigrationGeneric.migrationMethods();
  36. // add methods to method list
  37. MigrationOracle mig = new MigrationOracle();
  38. methods.add(mig.getMigrateSchemaToMysqlInfo());
  39. methods.add(mig.getMigrateTableToMysqlInfo());
  40. methods.add(mig.getMigrateColumnToMysqlInfo());
  41. methods.add(mig.getMigrateViewToMysqlInfo());
  42. methods.add(mig.getMigrateRoutineToMysqlInfo());
  44. return methods;
  45. }
  47. /**
  48.  * Performs a migration based on a Migration object
  49.  * 
  50.  * @param migObj
  51.  *            migration object to migrate
  52.  * @param targetPackageName
  53.  *            name of the package that should be used to generate the target
  54.  *            objects, e.g. db.mysql
  55.  */
  56. public static void migrate(com.mysql.grt.db.migration.Migration migObj,
  57. com.mysql.grt.db.mgmt.Rdbms targetRdbms,
  58. com.mysql.grt.db.Version version) throws Exception {
  60. Grt.getInstance().addMsg("Starting Oracle migration...");
  62. new MigrationOracle().migrateCatalog(migObj, targetRdbms, version);
  63. }
  65. /**
  66.  * Performs a data transfer from the given source catalog to the target
  67.  * catalog
  68.  * 
  69.  * @param sourceJdbcDriver
  70.  *            class name of the source jdbc driver
  71.  * @param sourceJdbcConnectionString
  72.  *            jdbc connection string to the source database
  73.  * @param sourceCatalog
  74.  *            the source catalog
  75.  * @param targetJdbcDriver
  76.  *            class name of the target jdbc driver
  77.  * @param targetJdbcConnectionString
  78.  *            jdbc connection string to the target database
  79.  * @param targetCatalog
  80.  *            the target catalog
  81.  * @param params
  82.  *            parameters that define how the migration is performed
  83.  */
  84. public static void dataBulkTransfer(
  85. com.mysql.grt.db.mgmt.Connection sourceDbConn,
  86. Catalog sourceCatalog,
  87. com.mysql.grt.db.mgmt.Connection targetDbConn,
  88. com.mysql.grt.db.Catalog targetCatalog, GrtStringHashMap params,
  89. com.mysql.grt.base.ObjectLogList logList) throws Exception {
  91. new MigrationOracle().doDataBulkTransfer(sourceDbConn, sourceCatalog,
  92. targetDbConn, targetCatalog, params, logList);
  93. }
  95. /**
  96.  * migrates the name of an identifier
  97.  * 
  98.  * @param name
  99.  *            the source name of the identifier
  100.  * @return the migrated identifier name
  101.  */
  102. protected String migrateIdentifier(String name) {
  103. return name.toLowerCase();
  104. }
  106. /**
  107.  * migrates the sourceSchema and stores the targetCatalog in the global
  108.  * migration object
  109.  * 
  110.  * @param migObj
  111.  *            migration object to migrate
  112.  * @param targetPackageName
  113.  *            name of the package that should be used to generate the target
  114.  *            objects, e.g. db.mysql
  115.  * @param sourceSchema
  116.  *            the source schema that should be migrated
  117.  */
  118. protected com.mysql.grt.db.mysql.Schema migrateSchemaToMysql(
  119. com.mysql.grt.db.migration.Migration migObj, Schema sourceSchema,
  120. GrtStringHashMap migrationParams, GrtObject parent) {
  122. // call super migrate function to do basic migration
  123. com.mysql.grt.db.mysql.Schema targetSchema = super
  124. .migrateSchemaToMysql(migObj, sourceSchema, migrationParams,
  125. parent);
  127. // migrate sequences
  128. for (int i = 0; i < sourceSchema.getSequences().size(); i++) {
  129. Sequence sourceSequence = (Sequence) sourceSchema.getSequences()
  130. .get(i);
  132. migUtils.migrateObject(this, migObj, sourceSequence, targetSchema);
  133. }
  135. return targetSchema;
  136. }
  138. /**
  139.  * Migrates an Oracle table to a MySQL table
  140.  * 
  141.  * @param sourceTable
  142.  *            the object to migrate
  143.  * @param migrationParams
  144.  *            parameters used to define the target object
  145.  * 
  146.  * @return returns MySQL table object
  147.  */
  148. protected com.mysql.grt.db.mysql.Table migrateTableToMysql(
  149. com.mysql.grt.db.migration.Migration migObj, Table sourceTable,
  150. GrtStringHashMap migrationParams, GrtObject parent) {
  152. // call migration method from the super class
  153. com.mysql.grt.db.mysql.Table targetTable;
  154. targetTable = super.migrateTableToMysql(migObj, sourceTable,
  155. migrationParams, parent);
  157. // do oracle specific things
  159. // return new created, migrated object
  160. return targetTable;
  161. }
  163. /**
  164.  * Migrates a column to a MySQL column
  165.  * 
  166.  * @param migObj
  167.  *            the migration object
  168.  * @param sourceColumn
  169.  *            the object to migrate
  170.  * @param migrationParams
  171.  *            parameters used to define the target object
  172.  * @param parent
  173.  *            parent object of the migrated object
  174.  * 
  175.  * @return returns a MySQL object
  176.  */
  177. protected com.mysql.grt.db.mysql.Column migrateColumnToMysql(
  178. com.mysql.grt.db.migration.Migration migObj, Column sourceColumn,
  179. GrtStringHashMap migrationParams, GrtObject parent) {
  181. // create target table
  182. com.mysql.grt.db.mysql.Column targetColumn;
  183. targetColumn = new com.mysql.grt.db.mysql.Column(parent);
  185. // log creation of target object
  186. migUtils.addMigrationLogEntry(migObj, sourceColumn, targetColumn);
  188. // do migration
  189. targetColumn.setName(migUtils.getTargetName(migrationParams,
  190. migrateIdentifier(sourceColumn.getName())));
  191. targetColumn.setOldName(sourceColumn.getName());
  192. targetColumn.setDefaultValue(sourceColumn.getDefaultValue());
  193. targetColumn.setIsNullable(sourceColumn.getIsNullable());
  194. targetColumn.setPrecision(sourceColumn.getPrecision());
  195. targetColumn.setScale(sourceColumn.getScale());
  196. targetColumn.setLength(sourceColumn.getLength());
  198. // migrate datatype
  199. com.mysql.grt.db.SimpleDatatypeList simpleDatatypes = migObj
  200. .getTargetCatalog().getSimpleDatatypes();
  202. String sourceDatatypeName = sourceColumn.getDatatypeName();
  204. if (!migrateColumnParamsToMySql(targetColumn, migrationParams)) {
  205. // character types
  206. if (sourceDatatypeName.equals("VARCHAR2")
  207. || sourceDatatypeName.equals("NVARCHAR2")) {
  208. GrtStringList columnFlags = new GrtStringList();
  209. columnFlags.add("BINARY");
  210. targetColumn.setFlags(columnFlags);
  212. if (sourceColumn.getLength() < 256) {
  213. // normal varchar up to 255 chars
  214. targetColumn.setDatatypeName("VARCHAR");
  215. } else if (sourceColumn.getLength() < 65536) {
  216. // MySQL 5 can deal with VARCHAR holding up to 65535
  217. // characters
  218. if (migObj.getTargetCatalog().getVersion().getMajor() >= 5)
  219. targetColumn.setDatatypeName("VARCHAR");
  220. // for older versions use medium text up to 65535
  221. else
  222. targetColumn.setDatatypeName("MEDIUMTEXT");
  223. } else {
  224. // long text
  225. targetColumn.setDatatypeName("LONGTEXT");
  226. }
  227. }
  228. // character types with fixed length
  229. else if (sourceDatatypeName.equals("CHAR")
  230. || sourceDatatypeName.equals("NCHAR")) {
  231. GrtStringList columnFlags = new GrtStringList();
  232. columnFlags.add("BINARY");
  233. targetColumn.setFlags(columnFlags);
  235. // fixed length character types
  236. if (sourceColumn.getLength() < 256) {
  237. // normal varchar up to 255 chars
  238. targetColumn.setDatatypeName("CHAR");
  239. } else if (sourceColumn.getLength() < 65536) {
  240. // MySQL 5 can deal with VARCHAR holding up to 65535
  241. // characters and in InnoDB CHAR == VARCHAR
  242. if (migObj.getTargetCatalog().getVersion().getMajor() >= 5)
  243. targetColumn.setDatatypeName("VARCHAR");
  244. // for older versions use medium text up to 65535
  245. else
  246. targetColumn.setDatatypeName("MEDIUMTEXT");
  247. } else {
  248. // long text
  249. targetColumn.setDatatypeName("LONGTEXT");
  250. }
  251. }
  252. // character types with unknown length
  253. else if (sourceDatatypeName.equals("CLOB")
  254. || sourceDatatypeName.equals("LONG")) {
  255. GrtStringList columnFlags = new GrtStringList();
  256. columnFlags.add("BINARY");
  257. targetColumn.setFlags(columnFlags);
  259. targetColumn.setDatatypeName("LONGTEXT");
  260. }
  261. // binary types
  262. else if (sourceDatatypeName.equals("RAW")) {
  263. targetColumn.setDatatypeName("MEDIUMBLOB");
  264. }
  265. // binary types
  266. else if (sourceDatatypeName.equals("LONG RAW")
  267. || sourceDatatypeName.equals("BLOB")) {
  268. targetColumn.setDatatypeName("LONGBLOB");
  269. }
  270. // numeric types
  271. else if (sourceDatatypeName.equals("NUMBER")
  272. || sourceDatatypeName.equals("DECIMAL")) {
  273. if (sourceColumn.getScale() == 0) {
  274. if (targetColumn.getPrecision() < 10) {
  275. targetColumn.setDatatypeName("INT");
  276. } else {
  277. if (targetColumn.getPrecision() < 19)
  278. targetColumn.setDatatypeName("BIGINT");
  279. else
  280. targetColumn.setDatatypeName("DECIMAL");
  281. }
  282. } else {
  283. targetColumn.setDatatypeName("DECIMAL");
  284. }
  286. // make sure Precision and Scale are set correctly
  287. if (targetColumn.getPrecision() > 65) {
  288. targetColumn.setPrecision(65);
  289. }
  290. if (targetColumn.getScale() > 30) {
  291. targetColumn.setScale(30);
  292. migUtils.addMigrationLogEntry(migObj, sourceColumn,
  293. targetColumn, "The precision of this column has been set to the maximum allowed value (30). "
  294. + "This might cause loss of data.",
  295. MigrationUtils.logWarning);
  296. }
  297. if (targetColumn.getScale() > targetColumn.getPrecision()) {
  298. targetColumn.setScale(targetColumn.getPrecision() - 1);
  299. }
  300. } else if (sourceDatatypeName.equals("REAL")
  301. || sourceDatatypeName.equals("DOUBLE PRECISION")) {
  302. targetColumn.setDatatypeName("DECIMAL");
  303. targetColumn.setScale(30);
  304. } else if (sourceDatatypeName.equals("FLOAT")) {
  305. targetColumn.setDatatypeName("DOUBLE");
  307. targetColumn.setPrecision(-1);
  308. targetColumn.setScale(-1);
  309. // datetime types
  310. } else if (sourceDatatypeName.equals("DATE")) {
  311. targetColumn.setDatatypeName("DATETIME");
  313. if ((sourceColumn.getDefaultValue() != null)
  314. && sourceColumn.getDefaultValue().equalsIgnoreCase(
  315. "sysdate"))
  316. targetColumn.setDefaultValue("");
  317. }
  318. // timestamp types
  319. else if (sourceDatatypeName.indexOf("TIMESTAMP") > -1) {
  320. // timestamp types
  321. targetColumn.setDatatypeName("DATETIME");
  322. }
  323. // not covered yet
  324. else {
  325. targetColumn.setDatatypeName("VARCHAR");
  326. targetColumn.setLength(255);
  328. migUtils.addMigrationLogEntry(migObj, sourceColumn,
  329. targetColumn, "The datatype "
  330. + sourceColumn.getDatatypeName()
  331. + " cannot be migrated.",
  332. MigrationUtils.logError);
  333. }
  334. }
  336. // lookup the simple datatype and set it in the column
  337. int simpleDatatypeIndex = simpleDatatypes.getIndexOfName(targetColumn
  338. .getDatatypeName());
  339. if (simpleDatatypeIndex > -1)
  340. targetColumn
  341. .setSimpleType(simpleDatatypes.get(simpleDatatypeIndex));
  343. // make sure N* are utf8
  344. if (sourceDatatypeName.equals("NVARCHAR2")
  345. || sourceDatatypeName.equals("NCHAR")
  346. || sourceDatatypeName.equals("NCLOB")) {
  347. targetColumn.setCharacterSetName("utf8");
  348. targetColumn.setCollationName("utf8_bin");
  349. }
  351. // return new created, migrated object
  352. return targetColumn;
  353. }
  355. /**
  356.  * Migrates an Oracle view to a MySQL view
  357.  * 
  358.  * @param sourceView
  359.  *            the object to migrate
  360.  * @param migrationParams
  361.  *            parameters used to define the target object
  362.  * 
  363.  * @return returns MySQL view object
  364.  */
  365. protected com.mysql.grt.db.mysql.View migrateViewToMysql(
  366. com.mysql.grt.db.migration.Migration migObj, View sourceView,
  367. GrtStringHashMap migrationParams, GrtObject parent) {
  369. // create target view
  370. com.mysql.grt.db.mysql.View targetView = super.migrateViewToMysql(
  371. migObj, sourceView, migrationParams, parent);
  373. // return new created, migrated object
  374. return targetView;
  375. }
  377. /**
  378.  * Migrates an Oracle Routine to a MySQL Routine
  379.  * 
  380.  * @param sourceView
  381.  *            the object to migrate
  382.  * @param migrationParams
  383.  *            parameters used to define the target object
  384.  * 
  385.  * @return returns MySQL view object
  386.  */
  387. protected com.mysql.grt.db.mysql.Routine migrateRoutineToMysql(
  388. com.mysql.grt.db.migration.Migration migObj, Routine sourceProc,
  389. GrtStringHashMap migrationParams, GrtObject parent) {
  391. // create target Routine
  392. com.mysql.grt.db.mysql.Routine targetProc = super
  393. .migrateRoutineToMysql(migObj, sourceProc, migrationParams,
  394. parent);
  396. // return new created, migrated object
  397. return targetProc;
  398. }
  400. /**
  401.  * Generates information about the schema to MySQL migration method
  402.  * 
  403.  * @return returns a Method with predefined migration parameters
  404.  */
  405. private Method getMigrateSchemaToMysqlInfo() {
  407. // create method description
  408. Method method = new Method(null);
  409. method.setName("migrateSchemaToMysql");
  410. method.setModuleName("MigrationOracle");
  411. method.setCaption("Oracle Default");
  412. method.setDesc("Default method to migrate an Oracle schema to MySQL.");
  413. method.setSourceStructName("db.oracle.Schema");
  414. method.setTargetPackageName("db.mysql");
  415. method.setRating(1);
  417. addMigrateSchemaToMysqlInfoParameters(method);
  419. return method;
  420. }
  422. /**
  423.  * Generates information about the Oracle Table to MySQL migration method
  424.  * 
  425.  * @return returns a Method with predefined migration parameters
  426.  */
  427. private Method getMigrateTableToMysqlInfo() {
  429. // create migrateOracleTable method
  430. Method method = new Method(null);
  431. method.setName("migrateTableToMysql");
  432. method.setModuleName("MigrationOracle");
  433. method.setCaption("Oracle Default");
  434. method.setDesc("Default method to migrate an Oracle table to MySQL.");
  435. method.setSourceStructName("db.oracle.Table");
  436. method.setTargetPackageName("db.mysql");
  437. method.setRating(1);
  439. addMigrateTableToMysqlInfoParameters(method);
  441. return method;
  442. }
  444. /**
  445.  * Generates information about the Column to MySQL migration method
  446.  * 
  447.  * @return returns a Method with predefined migration parameters
  448.  */
  449. private Method getMigrateColumnToMysqlInfo() {
  451. // create method description
  452. Method method = new Method(null);
  453. method.setName("migrateColumnToMysql");
  454. method.setModuleName("MigrationOracle");
  455. method.setCaption("Oracle Default");
  456. method.setDesc("Default method to migrate a Oracle column to MySQL.");
  457. method.setSourceStructName("db.oracle.Column");
  458. method.setTargetPackageName("db.mysql");
  459. method.setRating(1);
  461. addMigrateColumnToMysqlInfoParameters(method);
  463. return method;
  464. }
  466. /**
  467.  * Generates information about the View to MySQL migration method
  468.  * 
  469.  * @return returns a Method with predefined migration parameters
  470.  */
  471. private Method getMigrateViewToMysqlInfo() {
  473. // create migrateOracleTable method
  474. Method method = new Method(null);
  475. method.setName("migrateViewToMysql");
  476. method.setModuleName("MigrationOracle");
  477. method.setCaption("Oracle Default");
  478. method.setDesc("Default method to migrate an Oracle view to MySQL.");
  479. method.setSourceStructName("db.oracle.View");
  480. method.setTargetPackageName("db.mysql");
  481. method.setRating(1);
  483. addMigrateViewToMysqlInfoParameters(method);
  485. return method;
  486. }
  488. /**
  489.  * Generates information about the View to MySQL migration method
  490.  * 
  491.  * @return returns a Method with predefined migration parameters
  492.  */
  493. private Method getMigrateRoutineToMysqlInfo() {
  495. // create migrateOracleTable method
  496. Method method = new Method(null);
  497. method.setName("migrateRoutineToMysql");
  498. method.setModuleName("MigrationOracle");
  499. method.setCaption("Oracle Default");
  500. method.setDesc("Default method to migrate an "
  501. + "Oracle routine to MySQL.");
  502. method.setSourceStructName("db.oracle.Routine");
  503. method.setTargetPackageName("db.mysql");
  504. method.setRating(1);
  506. addMigrateRoutineToMysqlInfoParameters(method);
  508. return method;
  509. }
  510. }