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

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

MySQL数据库

开发平台：

SQL

MigrationGeneric.java：源码内容
  1. package com.mysql.grt.modules;
  3. import java.sql.*;
  4. import java.io.InputStream;
  5. import java.io.File;
  6. import java.io.FileOutputStream;
  7. import java.io.OutputStreamWriter;
  8. import java.io.Reader;
  9. import java.text.SimpleDateFormat;
  10. import java.math.BigDecimal;
  12. import com.mysql.grt.*;
  13. import com.mysql.grt.base.*;
  14. import com.mysql.grt.db.migration.*;
  15. import com.mysql.grt.db.*;
  17. /**
  18.  * GRT Migration Class
  19.  * 
  20.  * @author MikeZ
  21.  * @version 1.0, 01/16/05
  22.  * 
  23.  */
  24. public class MigrationGeneric {
  26. protected MigrationUtils migUtils = new MigrationUtils();
  28. /**
  29.  * Static function to return information about this class to the GRT
  30.  * environment
  31.  * 
  32.  * @return returns a GRT XML string containing the infos about this class
  33.  */
  34. public static String getModuleInfo() {
  35. return Grt.getModuleInfoXml(MigrationGeneric.class, "");
  36. }
  38. /**
  39.  * Collects information about migration the methods to let the user choose
  40.  * which one to take
  41.  * 
  42.  * @return returns a Method with predefined migration parameters
  43.  */
  44. public static MethodList migrationMethods() {
  46. MigrationGeneric mig = new MigrationGeneric();
  48. MethodList methods = new MethodList();
  50. // add information about available methods to methodlist
  51. methods.add(mig.getMigrateSchemaToMysqlInfo());
  52. methods.add(mig.getMigrateTableToMysqlInfo());
  53. methods.add(mig.getMigrateColumnToMysqlInfo());
  54. methods.add(mig.getMigrateIndexToMysqlInfo());
  55. methods.add(mig.getMigrateForeignKeyToMysqlInfo());
  56. methods.add(mig.getMigrateViewToMysqlInfo());
  57. methods.add(mig.getMigrateRoutineToMysqlInfo());
  59. return methods;
  60. }
  62. /**
  63.  * Performs a migration based on a Migration object
  64.  * 
  65.  * @param migObj
  66.  *            migration object to migrate
  67.  * @param targetPackageName
  68.  *            name of the package that should be used to generate the target
  69.  *            objects, e.g. db.mysql
  70.  */
  71. public static void migrate(com.mysql.grt.db.migration.Migration migObj,
  72. com.mysql.grt.db.mgmt.Rdbms targetRdbms,
  73. com.mysql.grt.db.Version version) throws Exception {
  75. Grt.getInstance().addMsg("Starting generic migration...");
  77. new MigrationGeneric().migrateCatalog(migObj, targetRdbms, version);
  78. }
  80. public static void dataBulkTransfer(
  81. com.mysql.grt.db.mgmt.Connection sourceDbConn,
  82. Catalog sourceCatalog,
  83. com.mysql.grt.db.mgmt.Connection targetDbConn,
  84. Catalog targetCatalog, GrtStringHashMap params,
  85. com.mysql.grt.base.ObjectLogList logList) throws Exception {
  87. new MigrationGeneric().doDataBulkTransfer(sourceDbConn, sourceCatalog,
  88. targetDbConn, targetCatalog, params, logList);
  89. }
  91. /**
  92.  * migrates the name of an identifier
  93.  * 
  94.  * @param name
  95.  *            the source name of the identifier
  96.  * @return the migrated identifier name
  97.  */
  98. protected String migrateIdentifier(String name) {
  99. if (name != null)
  100. return name;
  101. else
  102. return "";
  103. }
  105. /**
  106.  * migrates the sourceCatalog and stores the targetCatalog in the global
  107.  * migration object
  108.  * 
  109.  * @param migObj
  110.  *            migration object to migrate
  111.  * @param targetPackageName
  112.  *            name of the package that should be used to generate the target
  113.  *            objects, e.g. db.mysql
  114.  */
  115. protected void migrateCatalog(com.mysql.grt.db.migration.Migration migObj,
  116. com.mysql.grt.db.mgmt.Rdbms targetRdbms,
  117. com.mysql.grt.db.Version version) {
  119. // create target catalog based on the targetPackageName
  120. Catalog targetCatalog = migObj.setTargetCatalog((Catalog) Grt
  121. .getGrtClassInstance(targetRdbms.getDatabaseObjectPackage()
  122. + ".Catalog", migObj));
  124. targetCatalog.setName("Standard");
  125. targetCatalog.setOldName(targetCatalog.getName());
  127. // set the version of the target database
  128. if (version != null) {
  129. version.setOwner(targetCatalog);
  131. targetCatalog.setVersion(version);
  132. } else if (targetRdbms.getName().equalsIgnoreCase("Mysql")) {
  133. version = new Version(targetCatalog);
  134. version.setMajor(5);
  135. version.setMinor(0);
  136. version.setRelease(21);
  137. version.setName("5.0.21");
  139. targetCatalog.setVersion(version);
  140. } else {
  141. version = new Version(targetCatalog);
  142. version.setMajor(1);
  143. version.setName("1.0.0");
  145. targetCatalog.setVersion(version);
  146. }
  148. buildSimpleDatatypes(targetCatalog, targetRdbms);
  150. // migrate all source schemata to target schemata
  151. for (int i = 0; i < migObj.getSourceCatalog().getSchemata().size(); i++) {
  152. Schema sourceSchema = migObj.getSourceCatalog().getSchemata()
  153. .get(i);
  155. // migrate schema
  156. Schema targetSchema = (Schema) migUtils.migrateObject(this, migObj,
  157. sourceSchema, targetCatalog);
  159. // add generated schema to targetCatalog
  160. targetCatalog.getSchemata().add(targetSchema);
  161. }
  163. Grt.getInstance().addMsg("Migration completed.");
  164. }
  166. /**
  167.  * migrates the sourceSchema and stores the targetCatalog in the global
  168.  * migration object
  169.  * 
  170.  * @param migObj
  171.  *            migration object to migrate
  172.  * @param targetPackageName
  173.  *            name of the package that should be used to generate the target
  174.  *            objects, e.g. db.mysql
  175.  * @param sourceSchema
  176.  *            the source schema that should be migrated
  177.  */
  178. protected com.mysql.grt.db.mysql.Schema migrateSchemaToMysql(
  179. com.mysql.grt.db.migration.Migration migObj, Schema sourceSchema,
  180. GrtStringHashMap migrationParams, GrtObject parent) {
  182. Grt.getInstance().addMsg(
  183. "Migrating schema " + sourceSchema.getName() + " ...");
  184. Grt.getInstance().flushMessages();
  186. // create target schemata based on the targetPackageName
  187. com.mysql.grt.db.mysql.Schema targetSchema = new com.mysql.grt.db.mysql.Schema(
  188. parent);
  190. // log creation of target object
  191. migUtils.addMigrationLogEntry(migObj, sourceSchema, targetSchema);
  193. // migrate schema
  194. targetSchema.setName(migUtils.getTargetName(migrationParams,
  195. migrateIdentifier(sourceSchema.getName())));
  196. targetSchema.setOldName(sourceSchema.getName());
  198. // consider migration parameters
  199. if (migrationParams != null) {
  200. String charset = migrationParams.get("charset");
  201. if (charset != null)
  202. targetSchema.setDefaultCharacterSetName(charset);
  204. String collation = migrationParams.get("collation");
  205. if (charset != null)
  206. targetSchema.setDefaultCollationName(collation);
  207. }
  209. // migrate tables
  210. Grt.getInstance().addMsg("Migrating tables ...");
  212. for (int i = 0; i < sourceSchema.getTables().size(); i++) {
  213. Table sourceTable = sourceSchema.getTables().get(i);
  215. Grt.getInstance().addProgress(
  216. "Migrating table " + sourceTable.getName(),
  217. (i * 100) / sourceSchema.getTables().size());
  218. if (Grt.getInstance().flushMessages() != 0) {
  219. Grt.getInstance().addMsg("Migration canceled by user.");
  220. return targetSchema;
  221. }
  223. Table targetTable = (Table) migUtils.migrateObject(this, migObj,
  224. sourceTable, targetSchema);
  226. if (targetTable != null)
  227. targetSchema.getTables().add(targetTable);
  228. }
  230. // migrate tables - foreign keys (they need to be migrated after all
  231. // tables are migrated so the references can be found
  232. for (int i = 0; i < sourceSchema.getTables().size(); i++) {
  233. Table sourceTable = sourceSchema.getTables().get(i);
  235. migrateTableForeignKeysToMysql(migObj, sourceTable);
  236. }
  238. // migrate views
  239. Grt.getInstance().addMsg("Migrating views ...");
  241. for (int i = 0; i < sourceSchema.getViews().size(); i++) {
  242. View sourceView = sourceSchema.getViews().get(i);
  244. Grt.getInstance().addProgress(
  245. "Migrating view " + sourceView.getName(),
  246. (i * 100) / sourceSchema.getViews().size());
  247. if (Grt.getInstance().flushMessages() != 0) {
  248. Grt.getInstance().addMsg("Migration canceled by user.");
  249. return targetSchema;
  250. }
  252. targetSchema.getViews().add(
  253. (View) migUtils.migrateObject(this, migObj, sourceView,
  254. targetSchema));
  255. }
  257. // migrate Routines
  258. Grt.getInstance().addMsg("Migrating routines ...");
  260. for (int i = 0; i < sourceSchema.getRoutines().size(); i++) {
  261. Routine sourceRoutine = sourceSchema.getRoutines().get(i);
  263. Grt.getInstance().addProgress(
  264. "Migrating routine " + sourceRoutine.getName(),
  265. (i * 100) / sourceSchema.getRoutines().size());
  266. if (Grt.getInstance().flushMessages() != 0) {
  267. Grt.getInstance().addMsg("Migration canceled by user.");
  268. return targetSchema;
  269. }
  271. targetSchema.getRoutines().add(
  272. (Routine) migUtils.migrateObject(this, migObj,
  273. sourceRoutine, targetSchema));
  274. }
  276. // Hide progress bar
  277. Grt.getInstance().addProgress("", -1);
  278. Grt.getInstance().flushMessages();
  280. return targetSchema;
  281. }
  283. /**
  284.  * Migrates a table to a MySQL table
  285.  * 
  286.  * @param sourceTable
  287.  *            the object to migrate
  288.  * @param migrationParams
  289.  *            parameters used to define the target object
  290.  * 
  291.  * @return returns MySQL table object
  292.  */
  293. protected com.mysql.grt.db.mysql.Table migrateTableToMysql(
  294. com.mysql.grt.db.migration.Migration migObj, Table sourceTable,
  295. GrtStringHashMap migrationParams, GrtObject parent) {
  297. // create target table
  298. com.mysql.grt.db.mysql.Table targetTable;
  299. targetTable = new com.mysql.grt.db.mysql.Table(parent);
  301. // log creation of target object
  302. migUtils.addMigrationLogEntry(migObj, sourceTable, targetTable);
  304. // do migration
  305. targetTable.setName(migUtils.getTargetName(migrationParams,
  306. migrateIdentifier(sourceTable.getName())));
  307. targetTable.setOldName(sourceTable.getName());
  309. // consider migration parameters
  310. boolean addAutoincParam = false;
  311. if (migrationParams != null) {
  312. String charset = migrationParams.get("charset");
  313. if (charset != null)
  314. targetTable.setDefaultCharacterSetName(charset);
  316. String collation = migrationParams.get("collation");
  317. if (charset != null)
  318. targetTable.setDefaultCollationName(collation);
  320. String engine = migrationParams.get("engine");
  321. if (engine != null)
  322. targetTable.setTableEngine(engine);
  324. String addAutoincrement = migrationParams.get("addAutoincrement");
  325. if ((addAutoincrement != null)
  326. && (addAutoincrement.equalsIgnoreCase("yes")))
  327. addAutoincParam = true;
  329. }
  331. // charset
  332. targetTable.setDefaultCharacterSetName(migrationParams.get("charset"));
  333. targetTable.setDefaultCollationName(migrationParams.get("collation"));
  335. // migrate columns
  336. for (int i = 0; i < sourceTable.getColumns().size(); i++) {
  337. Column sourceColumn = sourceTable.getColumns().get(i);
  338. Column targetColumn = (Column) migUtils.migrateObject(this, migObj,
  339. sourceColumn, targetTable);
  341. targetTable.getColumns().add(targetColumn);
  342. }
  344. // migrate indices
  345. for (int i = 0; i < sourceTable.getIndices().size(); i++) {
  346. Index sourceIndex = sourceTable.getIndices().get(i);
  348. Index targetIndex = (Index) migUtils.migrateObject(this, migObj,
  349. sourceIndex, targetTable);
  351. if (targetIndex != null)
  352. targetTable.getIndices().add(targetIndex);
  353. }
  355. // primary key
  356. Index sourcePk = sourceTable.getPrimaryKey();
  357. if (sourcePk != null) {
  358. Index targetPk = (Index) (migUtils.findTargetObject(sourcePk));
  360. if (targetPk != null)
  361. targetPk.setIsPrimary(1);
  363. targetTable.setPrimaryKey(targetPk);
  365. // make sure all columns are not null
  366. for (int i = 0; i < targetPk.getColumns().size(); i++) {
  367. Column refCol = targetPk.getColumns().get(i).getReferedColumn();
  368. if (refCol.getIsNullable() == 1)
  369. refCol.setIsNullable(0);
  370. }
  371. }
  373. if ((addAutoincParam)
  374. && (targetTable.getPrimaryKey() != null)
  375. && (targetTable.getPrimaryKey().getColumns().size() == 1)
  376. && (targetTable.getPrimaryKey().getColumns().get(0)
  377. .getReferedColumn().getDatatypeName()
  378. .equalsIgnoreCase("INTEGER"))) {
  379. com.mysql.grt.db.mysql.Column pkColumn;
  380. pkColumn = (com.mysql.grt.db.mysql.Column) targetTable
  381. .getPrimaryKey().getColumns().get(0).getReferedColumn();
  383. if (pkColumn != null)
  384. pkColumn.setAutoIncrement(1);
  385. }
  387. // make sure there is only one autoInc value
  388. int autoIncCount = 0;
  389. for (int i = 0; i < targetTable.getColumns().size(); i++) {
  390. com.mysql.grt.db.mysql.Column col = (com.mysql.grt.db.mysql.Column) targetTable
  391. .getColumns().get(i);
  393. if (col.getAutoIncrement() == 1) {
  394. if (autoIncCount == 0) {
  395. // if this table has a PK
  396. if (targetTable.getPrimaryKey() != null) {
  397. // and the current column is not part of the PK
  398. IndexColumnList indexColumns = targetTable
  399. .getPrimaryKey().getColumns();
  400. boolean indexFoundInPk = false;
  402. for (int j = 0; j < indexColumns.size(); j++) {
  403. if (indexColumns.get(j).getReferedColumn() == col) {
  404. indexFoundInPk = true;
  405. break;
  406. }
  407. }
  408. if (indexFoundInPk) {
  409. autoIncCount = 1;
  410. } else {
  411. // reset AutoInc
  412. col.setAutoIncrement(0);
  413. }
  414. } else {
  415. // if there is no PK but an AI column, create a new PK
  416. // with that column
  417. com.mysql.grt.db.mysql.Index targetPk = new com.mysql.grt.db.mysql.Index(
  418. targetTable);
  419. com.mysql.grt.db.mysql.IndexColumn pkCol = new com.mysql.grt.db.mysql.IndexColumn(
  420. targetPk);
  422. targetPk.setName("PRIMARY");
  423. targetPk.setIndexType("PRIMARY");
  424. targetPk.setIsPrimary(1);
  426. pkCol.setName(col.getName());
  427. pkCol.setReferedColumn(col);
  429. targetPk.getColumns().add(pkCol);
  430. targetTable.setPrimaryKey(targetPk);
  432. targetTable.getIndices().add(targetPk);
  434. autoIncCount = 1;
  435. }
  436. } else {
  437. col.setAutoIncrement(0);
  438. }
  439. }
  440. }
  442. // return new created, migrated object
  443. return targetTable;
  444. }
  446. protected void migrateTableForeignKeysToMysql(
  447. com.mysql.grt.db.migration.Migration migObj, Table sourceTable) {
  448. Table targetTable = (Table) (migUtils.findTargetObject(sourceTable));
  450. // migrate foreign keys
  451. if (targetTable != null) {
  452. for (int i = 0; i < sourceTable.getForeignKeys().size(); i++) {
  453. ForeignKey sourceForeignKey = sourceTable.getForeignKeys().get(
  454. i);
  456. targetTable.getForeignKeys().add(
  457. (ForeignKey) migUtils.migrateObject(this, migObj,
  458. sourceForeignKey, targetTable));
  459. }
  460. }
  461. }
  463. /**
  464.  * Applys the migration parameter to the column
  465.  * 
  466.  * @param targetColumn
  467.  *            the column who's settings should be changed
  468.  * @param migrationParams
  469.  *            parameters used to define the target object
  470.  * 
  471.  * @return returns true if the datatype got set
  472.  */
  473. protected boolean migrateColumnParamsToMySql(
  474. com.mysql.grt.db.mysql.Column targetColumn,
  475. GrtStringHashMap migrationParams) {
  476. boolean result = false;
  478. if (migrationParams != null) {
  479. boolean forceDecimalDigits = ((migrationParams
  480. .get("forceDecimalDigits") != null) && migrationParams.get(
  481. "forceDecimalDigits").equalsIgnoreCase("yes"));
  483. if (forceDecimalDigits
  484. && (migrationParams.get("forcePrecisionValue") != null)
  485. && !migrationParams.get("forcePrecisionValue").equals("")) {
  486. targetColumn.setPrecision(Integer.parseInt(migrationParams
  487. .get("forcePrecisionValue")));
  489. if ((migrationParams.get("forceScaleValue") != null)
  490. && (!migrationParams.get("forceScaleValue").equals(""))) {
  491. targetColumn.setScale(Integer.parseInt(migrationParams
  492. .get("forceScaleValue")));
  493. }
  494. }
  496. boolean forceLength = ((migrationParams.get("forceLength") != null) && migrationParams
  497. .get("forceLength").equalsIgnoreCase("yes"));
  499. if (forceLength
  500. && (migrationParams.get("forceLengthValue") != null)
  501. && !migrationParams.get("forceLengthValue").equals("")) {
  502. targetColumn.setLength(Integer.parseInt(migrationParams
  503. .get("forceLengthValue")));
  504. }
  506. if ((migrationParams.get("forceDatatypeName") != null)
  507. && !migrationParams.get("forceDatatypeName").equals("")) {
  508. targetColumn.setDatatypeName(migrationParams
  509. .get("forceDatatypeName"));
  510. result = true;
  511. }
  512. }
  514. return result;
  515. }
  517. /**
  518.  * Migrates a column to a MySQL column
  519.  * 
  520.  * @param sourceColumn
  521.  *            the object to migrate
  522.  * @param migrationParams
  523.  *            parameters used to define the target object
  524.  * @param parent
  525.  *            parent object of the migrated object
  526.  * 
  527.  * @return returns MySQL table object
  528.  */
  529. protected com.mysql.grt.db.mysql.Column migrateColumnToMysql(
  530. com.mysql.grt.db.migration.Migration migObj, Column sourceColumn,
  531. GrtStringHashMap migrationParams, GrtObject parent) {
  533. // create target table
  534. com.mysql.grt.db.mysql.Column targetColumn;
  535. targetColumn = new com.mysql.grt.db.mysql.Column(parent);
  537. // log creation of target object
  538. migUtils.addMigrationLogEntry(migObj, sourceColumn, targetColumn);
  540. // do migration
  541. targetColumn.setName(migUtils.getTargetName(migrationParams,
  542. migrateIdentifier(sourceColumn.getName())));
  543. targetColumn.setOldName(sourceColumn.getName());
  544. targetColumn.setDefaultValue(sourceColumn.getDefaultValue());
  545. targetColumn.setIsNullable(sourceColumn.getIsNullable());
  546. targetColumn.setPrecision(sourceColumn.getPrecision());
  547. targetColumn.setScale(sourceColumn.getScale());
  548. targetColumn.setLength(sourceColumn.getLength());
  550. // migrate datatype
  551. SimpleDatatypeList simpleDatatypes = migObj.getTargetCatalog()
  552. .getSimpleDatatypes();
  554. String sourceDatatypeName = sourceColumn.getDatatypeName();
  556. if (!migrateColumnParamsToMySql(targetColumn, migrationParams)) {
  557. // try to find datatype in target list
  558. com.mysql.grt.db.SimpleDatatypeList targetSimpleDatatypes = migObj
  559. .getTargetCatalog().getSimpleDatatypes();
  560. for (int i = 0; i < targetSimpleDatatypes.size(); i++) {
  561. com.mysql.grt.db.SimpleDatatype datatype = targetSimpleDatatypes
  562. .get(i);
  563. if (datatype.getName().equalsIgnoreCase(sourceDatatypeName)) {
  564. targetColumn.setDatatypeName(datatype.getName());
  565. targetColumn.setSimpleType(datatype);
  566. break;
  567. }
  568. }
  570. if (!targetColumn.getName().equals("")) {
  571. DatatypeMappingList mappings = migObj
  572. .getGenericDatatypeMappings();
  574. for (int i = 0; i < mappings.size(); i++) {
  575. DatatypeMapping mapping = mappings.get(i);
  577. if (mapping.getSourceDatatypeName().equalsIgnoreCase(
  578. sourceDatatypeName.trim())) {
  579. // check length condition
  580. if (((mapping.getLengthConditionFrom() > 0) && (sourceColumn
  581. .getLength() < mapping.getLengthConditionFrom()))
  582. || ((mapping.getLengthConditionTo() > 0) && (sourceColumn
  583. .getLength() > mapping
  584. .getLengthConditionTo()))) {
  585. continue;
  586. }
  588. // check precision condition
  589. if (((mapping.getPrecisionConditionFrom() > 0) && (sourceColumn
  590. .getPrecision() < mapping
  591. .getPrecisionConditionFrom()))
  592. || ((mapping.getPrecisionConditionTo() > 0) && (sourceColumn
  593. .getPrecision() > mapping
  594. .getPrecisionConditionTo()))) {
  595. continue;
  596. }
  598. // check scale condition
  599. if (((mapping.getScaleConditionFrom() > 0) && (sourceColumn
  600. .getScale() < mapping.getScaleConditionFrom()))
  601. || ((mapping.getScaleConditionTo() > 0) && (sourceColumn
  602. .getScale() > mapping
  603. .getScaleConditionTo()))) {
  604. continue;
  605. }
  607. targetColumn.setDatatypeName(mapping
  608. .getTargetDatatypeName());
  610. if (mapping.getAutoIncrement() == 1) {
  611. targetColumn.setAutoIncrement(1);
  612. targetColumn.setDefaultValue("");
  613. targetColumn.setDefaultValueIsNull(1);
  614. }
  616. if (mapping.getUnsigned() == 1)
  617. targetColumn.getFlags().add("UNSIGNED");
  619. if (!mapping.getCharacterSet().equalsIgnoreCase(""))
  620. targetColumn.setCharacterSetName(mapping
  621. .getCharacterSet());
  623. if (!mapping.getCollation().equalsIgnoreCase(""))
  624. targetColumn.setCollationName(mapping
  625. .getCollation());
  627. if (mapping.getLength() > -1)
  628. targetColumn.setLength(mapping.getLength());
  630. if (mapping.getPrecision() != -1)
  631. targetColumn.setPrecision(mapping.getPrecision());
  633. if (mapping.getScale() != -1)
  634. targetColumn.setScale(mapping.getScale());
  635. break;
  636. }
  637. }
  638. }
  639. }
  641. // lookup the simple datatype and set it in the column
  642. int simpleDatatypeIndex = simpleDatatypes.getIndexOfName(targetColumn
  643. .getDatatypeName());
  644. if (simpleDatatypeIndex > -1)
  645. targetColumn
  646. .setSimpleType(simpleDatatypes.get(simpleDatatypeIndex));
  648. if ((targetColumn.getDatatypeName() == null)
  649. || targetColumn.getDatatypeName().equals("")) {
  650. String msg = "The datatype " + sourceColumn.getDatatypeName()
  651. + " cannot be migrated.";
  652. migUtils.addMigrationLogEntry(migObj, sourceColumn, targetColumn,
  653. msg, MigrationUtils.logError);
  655. Grt.getInstance().addMsg(msg);
  656. Grt.getInstance().flushMessages();
  658. /*
  659.  * migUtils.addMigrationLogEntry(migObj, sourceColumn.getOwner(),
  660.  * targetColumn.getOwner(), "A datatype cannot be migrated.",
  661.  * MigrationUtils.logWarning);
  662.  */
  664. targetColumn.setSimpleType(simpleDatatypes.get(0));
  665. targetColumn
  666. .setDatatypeName(targetColumn.getSimpleType().getName());
  667. }
  669. // convert TIMESTAMP DEFAULT NOW to TIMESTAMP CURRENT_TIMESTAMP
  670. if (targetColumn.getDatatypeName().equalsIgnoreCase("TIMESTAMP")
  671. && targetColumn.getDefaultValue() != null
  672. && (targetColumn.getDefaultValue().equalsIgnoreCase("NOW") || targetColumn
  673. .getDefaultValue().equalsIgnoreCase("'NOW'")))
  674. targetColumn.setDefaultValue("CURRENT_TIMESTAMP");
  676. // return new created, migrated object
  677. return targetColumn;
  678. }
  680. /**
  681.  * Migrates a table index to MySQL
  682.  * 
  683.  * @param sourceIndex
  684.  *            the object to migrate
  685.  * @param migrationParams
  686.  *            parameters used to define the target object
  687.  * 
  688.  * @return returns MySQL table object
  689.  */
  690. protected com.mysql.grt.db.mysql.Index migrateIndexToMysql(
  691. com.mysql.grt.db.migration.Migration migObj, Index sourceIndex,
  692. GrtStringHashMap migrationParams, GrtObject parent) {
  694. // create index
  695. com.mysql.grt.db.mysql.Index targetIndex;
  696. targetIndex = new com.mysql.grt.db.mysql.Index(parent);
  698. // log creation of target object
  699. migUtils.addMigrationLogEntry(migObj, sourceIndex, targetIndex);
  701. // do migration
  702. targetIndex.setName(migUtils.getTargetName(migrationParams,
  703. migrateIdentifier(sourceIndex.getName())));
  704. if (targetIndex.getName().length() > 32)
  705. targetIndex.setName(targetIndex.getName().substring(0, 31));
  707. targetIndex.setOldName(sourceIndex.getName());
  708. targetIndex.setUnique(sourceIndex.getUnique());
  710. // deal with migrationParams, forcedIndexLength
  711. int forcedIndexLength;
  713. try {
  714. forcedIndexLength = Integer.parseInt(migrationParams
  715. .get("forcedIndexLength"));
  716. } catch (NumberFormatException e) {
  717. forcedIndexLength = 0;
  718. }
  720. // migrate index columns
  721. Table sourceTable = (Table) sourceIndex.getOwner();
  723. for (int i = 0; i < sourceIndex.getColumns().size(); i++) {
  724. IndexColumn sourceIndexColumn = sourceIndex.getColumns().get(i);
  726. // get original source column
  727. int columnIndex = sourceTable.getColumns().getIndexOfName(
  728. sourceIndexColumn.getName());
  730. if (columnIndex == -1)
  731. continue;
  733. Column sourceColumn = sourceTable.getColumns().get(columnIndex);
  735. // create new IndexColumn
  736. IndexColumn targetColumn = new IndexColumn(targetIndex);
  738. Column referedColumn = (Column) (migUtils
  739. .findTargetObject(sourceColumn));
  741. targetColumn.setReferedColumn(referedColumn);
  743. targetIndex.getColumns().add(targetColumn);
  745. // check index length
  746. if (forcedIndexLength > 0)
  747. targetColumn.setColumnLength(forcedIndexLength);
  748. else {
  749. int indexLength = sourceIndexColumn.getColumnLength();
  751. SimpleDatatype datatype = referedColumn.getSimpleType();
  752. if (datatype != null) {
  753. DatatypeGroup group = datatype.getGroup();
  755. if (group != null) {
  756. String groupName = group.getName();
  758. // only strings, text or blob have a index column length
  759. if ((indexLength > 0)
  760. && (!(groupName.equals("string")
  761. || groupName.equals("text") || groupName
  762. .equals("blob"))))
  763. indexLength = 0;
  765. // text and blob have to have a index column length
  766. if ((indexLength == 0)
  767. && (groupName.equals("text") || groupName
  768. .equals("blob")))
  769. indexLength = 45;
  770. }
  771. }
  773. // limit max index length to 500 per index column,
  774. // so there can be at least 2 index columns without issues
  775. if (indexLength > 500)
  776. indexLength = 500;
  778. // finally check, if the indexLength is longer than the column's
  779. // length itself
  780. if ((referedColumn.getLength() > 0)
  781. && (indexLength > referedColumn.getLength()))
  782. indexLength = referedColumn.getLength();
  784. targetColumn.setColumnLength(indexLength);
  785. }
  786. }
  788. // return new created, migrated object
  789. return targetIndex;
  790. }
  792. /**
  793.  * Migrates a foreign key to MySQL
  794.  * 
  795.  * @param sourceRoutine
  796.  *            the object to migrate
  797.  * @param migrationParams
  798.  *            parameters used to define the target object
  799.  * 
  800.  * @return returns MySQL table object
  801.  */
  802. protected com.mysql.grt.db.mysql.ForeignKey migrateForeignKeyToMysql(
  803. com.mysql.grt.db.migration.Migration migObj,
  804. ForeignKey sourceForeignKey, GrtStringHashMap migrationParams,
  805. GrtObject parent) {
  807. // create foreign key
  808. com.mysql.grt.db.mysql.ForeignKey targetForeignKey;
  809. targetForeignKey = new com.mysql.grt.db.mysql.ForeignKey(parent);
  811. // log creation of target object
  812. migUtils.addMigrationLogEntry(migObj, sourceForeignKey,
  813. targetForeignKey);
  815. // do migration
  816. targetForeignKey.setName(migUtils.getTargetName(migrationParams,
  817. migrateIdentifier(sourceForeignKey.getName())));
  818. targetForeignKey.setOldName(sourceForeignKey.getName());
  820. String overrideRules = migrationParams.get("overrideRules");
  821. if ((overrideRules != null)
  822. && (overrideRules.compareToIgnoreCase("yes") == 0)) {
  823. targetForeignKey.setDeleteRule(migrationParams
  824. .get("defaultDeleteRule"));
  825. targetForeignKey.setUpdateRule(migrationParams
  826. .get("defaultUpdateRule"));
  827. } else {
  828. targetForeignKey.setDeleteRule(sourceForeignKey.getDeleteRule());
  829. targetForeignKey.setUpdateRule(sourceForeignKey.getUpdateRule());
  830. }
  832. targetForeignKey.setDeferability(sourceForeignKey.getDeferability());
  833. targetForeignKey
  834. .setReferedTableSchemaName(migrateIdentifier(sourceForeignKey
  835. .getReferedTableSchemaName()));
  836. targetForeignKey.setReferedTableName(migrateIdentifier(sourceForeignKey
  837. .getReferedTableName()));
  839. Table sourceTable = (Table) sourceForeignKey.getOwner();
  841. // migrate FK columns names
  842. for (int i = 0; i < sourceForeignKey.getColumns().size(); i++) {
  843. Column sourceColumnRef = sourceForeignKey.getColumns().get(i);
  845. // get original source column
  846. Column sourceColumn = sourceTable.getColumns().get(
  847. sourceTable.getColumns().getIndexOfName(
  848. sourceColumnRef.getName()));
  850. Column targetColumn = (Column) (migUtils
  851. .findTargetObject(sourceColumn));
  853. targetForeignKey.getColumns().add(targetColumn);
  855. }
  857. // find target refered table
  858. Table refTable = (Table) sourceForeignKey.getReferedTable();
  859. if (refTable != null) {
  860. Table targetRefTable = (Table) (migUtils.findTargetObject(refTable));
  862. if (targetRefTable != null)
  863. targetForeignKey.setReferedTable(targetRefTable);
  864. }
  866. // migrate FK columns refs
  867. for (int i = 0; i < sourceForeignKey.getColumns().size(); i++) {
  868. Column sourceColumnRef = sourceForeignKey.getReferedColumns()
  869. .get(i);
  871. Column targetColumn = (Column) (migUtils
  872. .findTargetObject(sourceColumnRef));
  874. if (targetColumn != null)
  875. targetForeignKey.getReferedColumns().add(targetColumn);
  876. }
  878. for (int i = 0; i < sourceForeignKey.getReferedColumnNames().size(); i++) {
  879. targetForeignKey.getReferedColumnNames().add(
  880. migrateIdentifier(sourceForeignKey.getReferedColumnNames()
  881. .get(i)));
  882. }
  884. // return new created, migrated object
  885. return targetForeignKey;
  886. }
  888. /**
  889.  * Migrates a view to a MySQL view
  890.  * 
  891.  * @param sourceTable
  892.  *            the object to migrate
  893.  * @param migrationParams
  894.  *            parameters used to define the target object
  895.  * 
  896.  * @return returns MySQL table object
  897.  */
  898. protected com.mysql.grt.db.mysql.View migrateViewToMysql(
  899. com.mysql.grt.db.migration.Migration migObj, View sourceView,
  900. GrtStringHashMap migrationParams, GrtObject parent) {
  902. // create target view
  903. com.mysql.grt.db.mysql.View targetView;
  904. targetView = new com.mysql.grt.db.mysql.View(parent);
  906. // log creation of target object
  907. migUtils.addMigrationLogEntry(migObj, sourceView, targetView);
  909. // do migration
  910. targetView.setName(migUtils.getTargetName(migrationParams,
  911. migrateIdentifier(sourceView.getName())));
  912. targetView.setOldName(sourceView.getName());
  914. targetView.setWithCheckCondition(sourceView.getWithCheckCondition());
  916. // copy SQL
  917. String query = sourceView.getQueryExpression().trim();
  919. // detect WITH CHECK OPTION in sql and remove it
  920. if (query.toUpperCase().endsWith("WITH CHECK OPTION"))
  921. query = query.substring(0, query.length() - 17).trim();
  923. targetView.setQueryExpression(query);
  925. // copy column names
  926. for (int i = 0; i < sourceView.getColumns().size(); i++) {
  927. targetView.getColumns().add(sourceView.getColumns().get(i));
  928. }
  930. // comment SQL out for the moment
  931. targetView.setCommentedOut(1);
  933. migUtils.addMigrationLogEntry(migObj, sourceView, targetView,
  934. "The generated SQL has to be checked manually.",
  935. MigrationUtils.logWarning);
  937. // return new created, migrated object
  938. return targetView;
  939. }
  941. /**
  942.  * Migrates a Routine to a MySQL procedure
  943.  * 
  944.  * @param sourceProc
  945.  *            the object to migrate
  946.  * @param migrationParams
  947.  *            parameters used to define the target object
  948.  * 
  949.  * @return returns MySQL Routine object
  950.  */
  951. protected com.mysql.grt.db.mysql.Routine migrateRoutineToMysql(
  952. com.mysql.grt.db.migration.Migration migObj, Routine sourceProc,
  953. GrtStringHashMap migrationParams, GrtObject parent) {
  955. com.mysql.grt.db.mysql.Routine targetProc;
  956. targetProc = new com.mysql.grt.db.mysql.Routine(parent);
  958. // do migration
  959. targetProc.setName(migUtils.getTargetName(migrationParams,
  960. migrateIdentifier(sourceProc.getName())));
  961. targetProc.setOldName(sourceProc.getName());
  962. targetProc.setRoutineType(sourceProc.getRoutineType());
  964. // copy SQL
  965. if (sourceProc.getRoutineCode() != null)
  966. targetProc.setRoutineCode(sourceProc.getRoutineCode().trim());
  968. // comment SQL out for the moment
  969. targetProc.setCommentedOut(1);
  971. migUtils.addMigrationLogEntry(migObj, sourceProc, targetProc,
  972. "The generated SQL has to be checked manually.",
  973. MigrationUtils.logWarning);
  975. // return new created, migrated object
  976. return targetProc;
  977. }
  979. /**
  980.  * Generates information about the schema to MySQL migration method
  981.  * 
  982.  * @return returns a Method with predefined migration parameters
  983.  */
  984. private Method getMigrateSchemaToMysqlInfo() {
  986. // create method description
  987. Method method = new Method(null);
  988. method.setName("migrateSchemaToMysql");
  989. method.setModuleName("MigrationGeneric");
  990. method.setCaption("Generic");
  991. method.setDesc("Generic method to migrate a schema to MySQL.");
  992. method.setSourceStructName("db.Schema");
  993. method.setTargetPackageName("db.mysql");
  994. method.setRating(0);
  996. addMigrateSchemaToMysqlInfoParameters(method);
  998. return method;
  999. }
  1001. /**
  1002.  * Generates the predefined migration parameters for
  1003.  * getMigrateSchemaToMysqlInfo
  1004.  * 
  1005.  * @param method
  1006.  *            the method to which the parameters should be added
  1007.  * 
  1008.  */
  1009. protected void addMigrateSchemaToMysqlInfoParameters(Method method) {
  1011. // specify the parameters the method understands
  1012. GrtStringHashMap paramNames = new GrtStringHashMap();
  1013. method.setParams(paramNames);
  1014. paramNames.add("charset", "latin1");
  1015. paramNames.add("collation", "latin1_swedish_ci");
  1017. // create a list of parameter groups the user can choose from
  1018. ParameterGroupList paramGroupList = new ParameterGroupList();
  1019. method.setParamGroups(paramGroupList);
  1021. // add parameter group
  1022. ParameterGroup paramGroup = new ParameterGroup(method);
  1023. paramGroupList.add(paramGroup);
  1024. paramGroup.setName("Latin1");
  1025. paramGroup
  1026. .setDesc("Use this parameter group to use Latin1 as default character set for the schema.");
  1027. GrtStringHashMap params = new GrtStringHashMap();
  1028. paramGroup.setParams(params);
  1029. params.add("charset", "latin1");
  1030. params.add("collation", "latin1_swedish_ci");
  1032. // add parameter group
  1033. paramGroup = new ParameterGroup(method);
  1034. paramGroupList.add(paramGroup);
  1035. paramGroup.setName("Multilanguage");
  1036. paramGroup
  1037. .setDesc("Use this parameter group to use UTF8 as default character set for the schema.");
  1038. params = new GrtStringHashMap();
  1039. paramGroup.setParams(params);
  1040. params.add("charset", "utf8");
  1041. params.add("collation", "utf8_general_ci");
  1042. }
  1044. /**
  1045.  * Generates information about the Table to MySQL migration method
  1046.  * 
  1047.  * @return returns a Method with predefined migration parameters
  1048.  */
  1049. private Method getMigrateTableToMysqlInfo() {
  1051. // create method description
  1052. Method method = new Method(null);
  1053. method.setName("migrateTableToMysql");
  1054. method.setModuleName("MigrationGeneric");
  1055. method.setCaption("Generic");
  1056. method.setDesc("Generic method to migrate a table to MySQL.");
  1057. method.setSourceStructName("db.Table");
  1058. method.setTargetPackageName("db.mysql");
  1059. method.setRating(0);
  1061. addMigrateTableToMysqlInfoParameters(method);
  1063. return method;
  1064. }
  1066. /**
  1067.  * Generates the predefined migration parameters for
  1068.  * getMigrateTableToMysqlInfo
  1069.  * 
  1070.  * @param method
  1071.  *            the method to which the parameters should be added
  1072.  * 
  1073.  */
  1074. protected void addMigrateTableToMysqlInfoParameters(Method method) {
  1076. // specify the parameters the method understands
  1077. GrtStringHashMap paramNames = new GrtStringHashMap();
  1078. method.setParams(paramNames);
  1079. paramNames.add("engine", "INNODB");
  1080. paramNames.add("charset", "");
  1081. paramNames.add("collation", "");
  1082. paramNames.add("addAutoincrement", "yes");
  1084. // create a list of parameter groups the user can choose from
  1085. ParameterGroupList paramGroupList = new ParameterGroupList();
  1086. method.setParamGroups(paramGroupList);
  1088. // add parameter group
  1089. ParameterGroup paramGroup = new ParameterGroup(method);
  1090. paramGroupList.add(paramGroup);
  1091. paramGroup.setName("Data consistency");
  1092. paramGroup
  1093. .setDesc("Standard parameter group. "
  1094. + "The migrated tables will use the "
  1095. + "InnoDB storage "
  1096. + "engine to offer transactional and "
  1097. + "foreign key support.");
  1098. GrtStringHashMap params = new GrtStringHashMap();
  1099. paramGroup.setParams(params);
  1100. params.add("engine", "INNODB");
  1101. params.add("addAutoincrement", "yes");
  1103. // add parameter group
  1104. paramGroup = new ParameterGroup(method);
  1105. paramGroupList.add(paramGroup);
  1106. paramGroup.setName("Statistical data");
  1107. paramGroup.setDesc("Choose this parameter group for tables that "
  1108. + "contain lots of data which does not need "
  1109. + "transaction safety. This method is ideal "
  1110. + "for logging information or statistical data.");
  1111. params = new GrtStringHashMap();
  1112. paramGroup.setParams(params);
  1113. params.add("engine", "MyISAM");
  1114. params.add("addAutoincrement", "yes");
  1116. // add parameter group
  1117. paramGroup = new ParameterGroup(method);
  1118. paramGroupList.add(paramGroup);
  1119. paramGroup.setName("Data consistency / multilanguage");
  1120. paramGroup.setDesc("The migrated tables will use the "
  1121. + "InnoDB storage " + "engine to offer transactional and "
  1122. + "foreign key support and use " + "UTF8 as default charset.");
  1123. params = new GrtStringHashMap();
  1124. paramGroup.setParams(params);
  1125. params.add("engine", "INNODB");
  1126. params.add("charset", "utf8");
  1127. params.add("collation", "utf8_general_ci");
  1128. params.add("addAutoincrement", "yes");
  1129. }
  1131. /**
  1132.  * Generates information about the Routine to MySQL migration method
  1133.  * 
  1134.  * @return returns a Method with predefined migration parameters
  1135.  */
  1136. private Method getMigrateColumnToMysqlInfo() {
  1138. // create method description
  1139. Method method = new Method(null);
  1140. method.setName("migrateColumnToMysql");
  1141. method.setModuleName("MigrationGeneric");
  1142. method.setCaption("Generic");
  1143. method.setDesc("Generic method to migrate a column to MySQL.");
  1144. method.setSourceStructName("db.Column");
  1145. method.setTargetPackageName("db.mysql");
  1146. method.setRating(0);
  1148. addMigrateColumnToMysqlInfoParameters(method);
  1150. return method;
  1151. }
  1153. /**
  1154.  * Generates the predefined migration parameters for
  1155.  * getMigrateColumnToMysqlInfo
  1156.  * 
  1157.  * @param method
  1158.  *            the method to which the parameters should be added
  1159.  * 
  1160.  */
  1161. protected void addMigrateColumnToMysqlInfoParameters(Method method) {
  1163. // specify the parameters the method understands
  1164. GrtStringHashMap paramNames = new GrtStringHashMap();
  1165. method.setParams(paramNames);
  1166. paramNames.add("forceDatatypeName", "");
  1167. paramNames.add("forceLength", "no");
  1168. paramNames.add("forceLengthValue", "");
  1169. paramNames.add("forceDecimalDigits", "no");
  1170. paramNames.add("forceScaleValue", "");
  1171. paramNames.add("forcePrecisionValue", "");
  1172. paramNames.add("autoDecimalDigits", "no");
  1174. // create a list of parameter groups the user can choose from
  1175. ParameterGroupList paramGroupList = new ParameterGroupList();
  1176. method.setParamGroups(paramGroupList);
  1178. // add parameter group
  1179. ParameterGroup paramGroup = new ParameterGroup(method);
  1180. paramGroupList.add(paramGroup);
  1181. paramGroup.setName("Standard parameters");
  1182. paramGroup.setDesc("This is the standard parameter group "
  1183. + "to migrate colums.");
  1184. GrtStringHashMap params = new GrtStringHashMap();
  1185. paramGroup.setParams(params);
  1186. params.add("forceDatatypeName", "");
  1187. params.add("forceLength", "no");
  1188. params.add("forceLengthValue", "");
  1189. params.add("forceDecimalDigits", "no");
  1190. params.add("forceScaleValue", "");
  1191. params.add("forcePrecisionValue", "");
  1192. params.add("autoDecimalDigits", "no");
  1193. }
  1195. /**
  1196.  * Generates information about the Routine to MySQL migration method
  1197.  * 
  1198.  * @return returns a Method with predefined migration parameters
  1199.  */
  1200. private Method getMigrateIndexToMysqlInfo() {
  1202. // create method description
  1203. Method method = new Method(null);
  1204. method.setName("migrateIndexToMysql");
  1205. method.setModuleName("MigrationGeneric");
  1206. method.setCaption("Generic");
  1207. method.setDesc("Generic method to migrate an index to MySQL.");
  1208. method.setSourceStructName("db.Index");
  1209. method.setTargetPackageName("db.mysql");
  1210. method.setRating(0);
  1212. addMigrateIndexToMysqlInfoParameters(method);
  1214. return method;
  1215. }
  1217. /**
  1218.  * Generates the predefined migration parameters for
  1219.  * getMigrateForeignKeyToMysqlInfo
  1220.  * 
  1221.  * @param method
  1222.  *            the method to which the parameters should be added
  1223.  * 
  1224.  */
  1225. protected void addMigrateIndexToMysqlInfoParameters(Method method) {
  1227. // specify the parameters the method understands
  1228. GrtStringHashMap paramNames = new GrtStringHashMap();
  1229. method.setParams(paramNames);
  1230. paramNames.add("forcedIndexLength", "0");
  1232. // create a list of parameter groups the user can choose from
  1233. ParameterGroupList paramGroupList = new ParameterGroupList();
  1234. method.setParamGroups(paramGroupList);
  1236. // add parameter group
  1237. ParameterGroup paramGroup = new ParameterGroup(method);
  1238. paramGroupList.add(paramGroup);
  1239. paramGroup.setName("Standard parameters");
  1240. paramGroup.setDesc("This is the standard parameter group "
  1241. + "to migrate indices.");
  1242. GrtStringHashMap params = new GrtStringHashMap();
  1243. paramGroup.setParams(params);
  1244. params.add("forcedIndexLength", "0");
  1246. paramGroup = new ParameterGroup(method);
  1247. paramGroupList.add(paramGroup);
  1248. paramGroup.setName("Fast inserts");
  1249. paramGroup.setDesc("Use this paremeter group to "
  1250. + "limit the length of an index on a VARCHAR or "
  1251. + "TEXT column to the first 10 characters. Note that "
  1252. + "this might slow down SELECT commands.");
  1253. params = new GrtStringHashMap();
  1254. paramGroup.setParams(params);
  1255. params.add("forcedIndexLength", "10");
  1256. }
  1258. /**
  1259.  * Generates information about the Routine to MySQL migration method
  1260.  * 
  1261.  * @return returns a Method with predefined migration parameters
  1262.  */
  1263. private Method getMigrateForeignKeyToMysqlInfo() {
  1265. // create method description
  1266. Method method = new Method(null);
  1267. method.setName("migrateForeignKeyToMysql");
  1268. method.setModuleName("MigrationGeneric");
  1269. method.setCaption("Generic");
  1270. method.setDesc("Generic method to migrate a foreign key to MySQL.");
  1271. method.setSourceStructName("db.ForeignKey");
  1272. method.setTargetPackageName("db.mysql");
  1273. method.setRating(0);
  1275. addMigrateForeignKeyToMysqlInfoParameters(method);
  1277. return method;
  1278. }
  1280. /**
  1281.  * Generates the predefined migration parameters for
  1282.  * getMigrateForeignKeyToMysqlInfo
  1283.  * 
  1284.  * @param method
  1285.  *            the method to which the parameters should be added
  1286.  * 
  1287.  */
  1288. protected void addMigrateForeignKeyToMysqlInfoParameters(Method method) {
  1290. // specify the parameters the method understands
  1291. GrtStringHashMap paramNames = new GrtStringHashMap();
  1292. method.setParams(paramNames);
  1293. paramNames.add("overrideRules", "no");
  1294. paramNames.add("defaultDeleteRule", "NO ACTION");
  1295. paramNames.add("defaultUpdateRule", "NO ACTION");
  1297. // create a list of parameter groups the user can choose from
  1298. ParameterGroupList paramGroupList = new ParameterGroupList();
  1299. method.setParamGroups(paramGroupList);
  1301. // add parameter group
  1302. ParameterGroup paramGroup = new ParameterGroup(method);
  1303. paramGroupList.add(paramGroup);
  1304. paramGroup.setName("Standard parameters");
  1305. paramGroup.setDesc("This is the standard parameter group "
  1306. + "to migrate foreign keys.");
  1307. GrtStringHashMap params = new GrtStringHashMap();
  1308. paramGroup.setParams(params);
  1309. params.add("overrideRules", "no");
  1310. params.add("defaultDeleteRule", "NO ACTION");
  1311. params.add("defaultUpdateRule", "NO ACTION");
  1312. }
  1314. /**
  1315.  * Generates information about the Table to MySQL migration method
  1316.  * 
  1317.  * @return returns a Method with predefined migration parameters
  1318.  */
  1319. private Method getMigrateViewToMysqlInfo() {
  1321. // create method description
  1322. Method method = new Method(null);
  1323. method.setName("migrateViewToMysql");
  1324. method.setModuleName("MigrationGeneric");
  1325. method.setCaption("Generic");
  1326. method.setDesc("Generic method to migrate a view to MySQL.");
  1327. method.setSourceStructName("db.View");
  1328. method.setTargetPackageName("db.mysql");
  1329. method.setRating(0);
  1331. addMigrateViewToMysqlInfoParameters(method);
  1333. return method;
  1334. }
  1336. /**
  1337.  * Generates the predefined migration parameters for
  1338.  * getMigrateViewToMysqlInfo
  1339.  * 
  1340.  * @param method
  1341.  *            the method to which the parameters should be added
  1342.  * 
  1343.  */
  1344. protected void addMigrateViewToMysqlInfoParameters(Method method) {
  1346. // specify the parameters the method understands
  1347. GrtStringHashMap paramNames = new GrtStringHashMap();
  1348. method.setParams(paramNames);
  1349. paramNames.add("forceCheckOption", "no");
  1351. // create a list of parameter groups the user can choose from
  1352. ParameterGroupList paramGroupList = new ParameterGroupList();
  1353. method.setParamGroups(paramGroupList);
  1355. // add parameter group
  1356. ParameterGroup paramGroup = new ParameterGroup(method);
  1357. paramGroupList.add(paramGroup);
  1358. paramGroup.setName("Standard parameters");
  1359. paramGroup.setDesc("This is the standard parameter group "
  1360. + "to migrate views.");
  1361. GrtStringHashMap params = new GrtStringHashMap();
  1362. paramGroup.setParams(params);
  1363. params.add("forceCheckOption", "no");
  1364. }
  1366. /**
  1367.  * Generates information about the View to MySQL migration method
  1368.  * 
  1369.  * @return returns a Method with predefined migration parameters
  1370.  */
  1371. private Method getMigrateRoutineToMysqlInfo() {
  1373. // create migrateTable method
  1374. Method method = new Method(null);
  1375. method.setName("migrateRoutineToMysql");
  1376. method.setModuleName("MigrationGeneric");
  1377. method.setCaption("Generic");
  1378. method.setDesc("Generic method to migrate a " + " routine to MySQL.");
  1379. method.setSourceStructName("db.Routine");
  1380. method.setTargetPackageName("db.mysql");
  1381. method.setRating(0);
  1383. addMigrateRoutineToMysqlInfoParameters(method);
  1385. return method;
  1386. }
  1388. protected void addMigrateRoutineToMysqlInfoParameters(Method method) {
  1390. // specify the parameters the method understands
  1391. GrtStringHashMap paramNames = new GrtStringHashMap();
  1392. method.setParams(paramNames);
  1393. paramNames.add("Skip", "no");
  1395. // create a list of parameter groups the user can choose from
  1396. ParameterGroupList paramGroupList = new ParameterGroupList();
  1397. method.setParamGroups(paramGroupList);
  1399. // add parameter group
  1400. ParameterGroup paramGroup = new ParameterGroup(method);
  1401. paramGroupList.add(paramGroup);
  1402. paramGroup.setName("Standard parameters");
  1403. paramGroup.setDesc("This is the standard parameter group "
  1404. + "to migrate routines.");
  1405. GrtStringHashMap params = new GrtStringHashMap();
  1406. paramGroup.setParams(params);
  1407. params.add("Skip", "no");
  1408. }
  1410. protected void buildSimpleDatatypes(Catalog catalog,
  1411. com.mysql.grt.db.mgmt.Rdbms targetRdbms) {
  1413. com.mysql.grt.db.SimpleDatatypeList rdbmsDatatypeList = targetRdbms
  1414. .getSimpleDatatypes();
  1416. for (int i = 0; i < rdbmsDatatypeList.size(); i++) {
  1417. catalog.getSimpleDatatypes().add(rdbmsDatatypeList.get(i));
  1418. }
  1419. }
  1421. private static String foreignKeysDisable = "SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, "
  1422. + "FOREIGN_KEY_CHECKS=0;";
  1424. private static String foreignKeysReEnable = "SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;";
  1426. protected void doDataBulkTransfer(
  1427. com.mysql.grt.db.mgmt.Connection sourceDbConn,
  1428. Catalog sourceCatalog,
  1429. com.mysql.grt.db.mgmt.Connection targetDbConn,
  1430. Catalog targetCatalog, GrtStringHashMap params,
  1431. com.mysql.grt.base.ObjectLogList logList) throws Exception {
  1433. OutputStreamWriter outputStreamWriter = null;
  1435. // Check options
  1436. boolean doOnlineTransferData = true;
  1437. boolean doCreateScript = false;
  1439. String optionString = params.get("TransferData");
  1440. if ((optionString != null) && (optionString.equalsIgnoreCase("no")))
  1441. doOnlineTransferData = false;
  1443. optionString = params.get("CreateScript");
  1444. if ((optionString != null) && (optionString.equalsIgnoreCase("yes")))
  1445. doCreateScript = true;
  1447. if (!doOnlineTransferData && !doCreateScript) {
  1448. Grt.getInstance().addMsg(
  1449. "Neither online data transfer "
  1450. + "nor the creation of a script "
  1451. + "file was selected. Skipping "
  1452. + "bulk data transfer.");
  1453. return;
  1454. }
  1456. if (doOnlineTransferData) {
  1457. Grt.getInstance().addMsg("Starting online data bulk transfer ...");
  1458. }
  1460. if (doCreateScript) {
  1461. String scriptFileName = params.get("ScriptFileName");
  1463. if ((scriptFileName != null) && (!scriptFileName.equals(""))) {
  1464. Grt.getInstance().addMsg("Opening output script file ...");
  1466. File scriptFile = new File(scriptFileName);
  1468. FileOutputStream outputStream = new FileOutputStream(scriptFile);
  1470. outputStreamWriter = new OutputStreamWriter(outputStream,
  1471. "UTF-8");
  1473. outputStreamWriter
  1474. .write("-- ----------------------------------------------------------------------rn"
  1475. + "-- SQL data bulk transfer script generated by the MySQL Migration Toolkitrn"
  1476. + "-- ----------------------------------------------------------------------rnrn");
  1478. outputStreamWriter.write("-- Disable foreign key checksrn"
  1479. + foreignKeysDisable + "rnrn");
  1480. }
  1481. }
  1483. Grt.getInstance().addMsg("Initializing source JDBC driver ...");
  1484. Connection sourceConn = ReverseEngineeringGeneric
  1485. .establishConnection(sourceDbConn);
  1487. Connection targetConn = null;
  1489. if (doOnlineTransferData) {
  1490. Grt.getInstance().addMsg("Initializing target JDBC driver ...");
  1491. targetConn = ReverseEngineeringGeneric
  1492. .establishConnection(targetDbConn);
  1494. // deactivate autocommit for target connection
  1495. targetConn.setAutoCommit(false);
  1497. // disable FK checks
  1498. Statement targetStmt = targetConn.createStatement();
  1499. targetStmt.execute(foreignKeysDisable);
  1500. targetStmt.close();
  1501. }
  1503. // handle all schemata
  1504. for (int i = 0; i < sourceCatalog.getSchemata().size(); i++) {
  1505. Schema sourceSchema = sourceCatalog.getSchemata().get(i);
  1506. Schema targetSchema = null;
  1508. Grt.getInstance().addMsg(
  1509. "Processing schema " + sourceSchema.getName() + " ...");
  1510. Grt.getInstance().flushMessages();
  1512. // search target column based on old name
  1513. for (int j = 0; j < targetCatalog.getSchemata().size(); j++) {
  1514. if (targetCatalog.getSchemata().get(j).getOldName().equals(
  1515. sourceSchema.getName())) {
  1516. targetSchema = targetCatalog.getSchemata().get(j);
  1517. break;
  1518. }
  1519. }
  1521. if (targetSchema == null) {
  1522. Grt.getInstance().addErr(
  1523. "The source schema " + sourceSchema.getName()
  1524. + " is skipped because the target "
  1525. + "schema is not found.");
  1526. continue;
  1527. }
  1529. // loop over all tables
  1530. for (int j = 0; j < sourceSchema.getTables().size(); j++) {
  1531. Table sourceTable = sourceSchema.getTables().get(j);
  1532. Table targetTable = null;
  1534. // search target column based on old name
  1535. for (int k = 0; k < targetSchema.getTables().size(); k++) {
  1536. if (targetSchema.getTables().get(k).getOldName().equals(
  1537. sourceTable.getName())) {
  1538. targetTable = targetSchema.getTables().get(k);
  1539. break;
  1540. }
  1541. }
  1543. if (targetTable == null) {
  1544. Grt.getInstance().addMsg(
  1545. "The source table " + sourceTable.getName()
  1546. + " is skipped because the target "
  1547. + "table is not found.");
  1548. continue;
  1549. }
  1551. if (targetTable.getClass() == com.mysql.grt.db.mysql.Table.class)
  1552. if (doDataBulkTransferTableToMysql(sourceDbConn,
  1553. sourceConn, sourceTable, targetDbConn, targetConn,
  1554. targetTable, params, outputStreamWriter, logList) != 0)
  1555. break;
  1556. }
  1558. // Hide Progress Bar
  1559. Grt.getInstance().addProgress("", -1);
  1560. Grt.getInstance().flushMessages();
  1561. }
  1563. if (doOnlineTransferData) {
  1564. // commit inserted data
  1565. targetConn.commit();
  1567. // go back to autocommit
  1568. targetConn.setAutoCommit(true);
  1570. // re-enable FK checks
  1571. Statement targetStmt = targetConn.createStatement();
  1572. targetStmt.execute(foreignKeysReEnable);
  1573. targetStmt.close();
  1574. }
  1576. if (outputStreamWriter != null) {
  1577. outputStreamWriter
  1578. .write("-- Re-enable foreign key checksrn"
  1579. + foreignKeysReEnable + "rnrn"
  1580. + "-- End of scriptrn");
  1581. outputStreamWriter.close();
  1582. }
  1584. Grt.getInstance().addMsg("Data bulk transfer finished.");
  1585. }
  1587. protected int doDataBulkTransferTableToMysql(
  1588. com.mysql.grt.db.mgmt.Connection sourceDbConn,
  1589. Connection sourceConn, Table sourceTable,
  1590. com.mysql.grt.db.mgmt.Connection targetDbConn,
  1591. Connection targetConn, Table targetTable, GrtStringHashMap params,
  1592. OutputStreamWriter outputStreamWriter,
  1593. com.mysql.grt.base.ObjectLogList logList) {
  1595. // Check options
  1596. boolean doOnlineTransferData = true;
  1597. boolean doExcludeBlob = false;
  1598. boolean doExcludeSourceSchemaName = false;
  1599. boolean doOverrideBlobLimit = false;
  1600. boolean doBlobStreaming = false;
  1601. boolean doRightTrimForText = false;
  1602. boolean doSplittedSelects = false;
  1603. boolean doNotQuoteSourceIds = false;
  1604. int doLimitRows = -1;
  1606. String optionString = params.get("TransferData");
  1607. if ((optionString != null) && (optionString.equalsIgnoreCase("no")))
  1608. doOnlineTransferData = false;
  1610. optionString = params.get("ExcludeBlob");
  1611. if ((optionString != null) && (optionString.equalsIgnoreCase("yes")))
  1612. doExcludeBlob = true;
  1614. optionString = params.get("excludeSourceSchemaName");
  1615. if ((optionString != null) && (optionString.equalsIgnoreCase("yes")))
  1616. doExcludeSourceSchemaName = true;
  1618. optionString = params.get("OverrideBlobLimit");
  1619. if ((optionString != null) && (optionString.equalsIgnoreCase("yes")))
  1620. doOverrideBlobLimit = true;
  1622. optionString = params.get("BlobStreaming");
  1623. if ((optionString != null) && (optionString.equalsIgnoreCase("yes")))
  1624. doBlobStreaming = true;
  1626. optionString = params.get("RightTrimForText");
  1627. if ((optionString != null) && (optionString.equalsIgnoreCase("yes")))
  1628. doRightTrimForText = true;
  1630. optionString = params.get("MaxRowsNum");
  1631. if ((optionString != null) && !optionString.equalsIgnoreCase("")
  1632. && !optionString.equalsIgnoreCase("-1"))
  1633. doLimitRows = Integer.parseInt(optionString);
  1635. optionString = params.get("DoNotQuoteSourceIds");
  1636. if ((optionString != null) && (optionString.equalsIgnoreCase("yes")))
  1637. doNotQuoteSourceIds = true;
  1639. String sourceQuoteChar;
  1640. String targetQuoteChar;
  1641. String countSelect = "SELECT count(*) AS total_num FROM ";
  1642. StringBuffer select = new StringBuffer("SELECT ");
  1643. StringBuffer insert;
  1644. StringBuffer insertHeader = new StringBuffer("INSERT INTO ");
  1645. int columnCount = 0;
  1647. ObjectLog logObj = new ObjectLog(null);
  1648. logObj.setLogObject(sourceTable);
  1649. logObj.setRefObject(targetTable);
  1651. try {
  1652. // Allow to skip source quotations
  1653. if (!doNotQuoteSourceIds)
  1654. sourceQuoteChar = sourceConn.getMetaData()
  1655. .getIdentifierQuoteString();
  1656. else
  1657. sourceQuoteChar = "";
  1659. if (doOnlineTransferData) {
  1660. targetQuoteChar = targetConn.getMetaData()
  1661. .getIdentifierQuoteString();
  1662. } else {
  1663. targetQuoteChar = params.get("targetQuoteChar");
  1664. if ((targetQuoteChar == null) || (targetQuoteChar.equals("")))
  1665. targetQuoteChar = "`";
  1666. }
  1668. // build column list
  1669. StringBuffer selectCols = new StringBuffer();
  1670. StringBuffer insertCols = new StringBuffer();
  1671. for (int i = 0; i < sourceTable.getColumns().size(); i++) {
  1672. Column sourceColumn = sourceTable.getColumns().get(i);
  1673. Column targetColumn = null;
  1675. // search target column based on old name
  1676. for (int j = 0; j < targetTable.getColumns().size(); j++) {
  1677. if (targetTable.getColumns().get(j).getOldName().equals(
  1678. sourceColumn.getName())) {
  1679. targetColumn = targetTable.getColumns().get(j);
  1680. break;
  1681. }
  1682. }
  1684. // exclude BLOBs if the option was selected
  1685. if ((doExcludeBlob)
  1686. && (sourceColumn.getDatatypeName()
  1687. .equalsIgnoreCase("BLOB")))
  1688. continue;
  1690. // only transfer this column if there is a target column
  1691. if (targetColumn != null) {
  1692. if (selectCols.length() != 0) {
  1693. selectCols.append(", ");
  1694. insertCols.append(", ");
  1695. }
  1697. selectCols.append(sourceQuoteChar + sourceColumn.getName()
  1698. + sourceQuoteChar);
  1700. insertCols.append(targetQuoteChar + targetColumn.getName()
  1701. + targetQuoteChar);
  1703. columnCount++;
  1704. }
  1705. }
  1707. select.append(selectCols);
  1708. select.append(" FROM ");
  1710. if (!doExcludeSourceSchemaName) {
  1711. select.append(sourceQuoteChar
  1712. + sourceTable.getOwner().getName() + sourceQuoteChar
  1713. + ".");
  1714. countSelect += sourceQuoteChar
  1715. + sourceTable.getOwner().getName() + sourceQuoteChar
  1716. + ".";
  1717. }
  1719. select.append(sourceQuoteChar + sourceTable.getName()
  1720. + sourceQuoteChar);
  1721. countSelect += sourceQuoteChar + sourceTable.getName()
  1722. + sourceQuoteChar;
  1724. insertHeader.append(targetQuoteChar
  1725. + targetTable.getOwner().getName() + targetQuoteChar + "."
  1726. + targetQuoteChar + targetTable.getName() + targetQuoteChar
  1727. + "(");
  1728. insertHeader.append(insertCols);
  1729. insertHeader.append(")rnVALUES ");
  1731. // Get number of rows to transfer
  1732. int rowCount = 0;
  1733. int rowTotalCount = 0;
  1734. int currentRowNumber = 0;
  1735. int rowBlockOffset = 0;
  1736. int rowBlockSize = 20000;
  1737. Statement sourceStmt = sourceConn.createStatement();
  1739. GrtMessage msg = Grt.getInstance().addMsg(
  1740. "Getting the number of rows of table "
  1741. + sourceTable.getName());
  1742. Grt.getInstance().addMsgDetail(msg, countSelect);
  1743. Grt.getInstance().flushMessages();
  1745. ResultSet rset = sourceStmt.executeQuery(countSelect);
  1747. if (rset.next()) {
  1748. rowTotalCount = rset.getInt(1);
  1749. rowCount = rowTotalCount;
  1750. }
  1752. if (doLimitRows == -1 || doLimitRows > rowCount)
  1753. doLimitRows = rowCount;
  1755. // Starting the transfer
  1756. msg = Grt.getInstance().addMsg(
  1757. "Transfering data from table " + sourceTable.getName()
  1758. + " (" + String.valueOf(doLimitRows) + "/"
  1759. + String.valueOf(rowCount) + " rows)");
  1760. Grt.getInstance().addMsgDetail(msg, select.toString());
  1761. Grt.getInstance().flushMessages();
  1763. rowCount = doLimitRows;
  1765. Grt.getInstance().addProgress("Open source resultset.", 0);
  1766. Grt.getInstance().flushMessages();
  1768. if (sourceDbConn.getDriver().getOwner().getName().equalsIgnoreCase(
  1769. "Mysql")
  1770. && (rowCount > rowBlockSize)) {
  1771. doSplittedSelects = true;
  1772. rset = sourceStmt.executeQuery(select.toString() + "nLIMIT "
  1773. + rowBlockOffset + ", " + rowBlockSize);
  1774. } else {
  1775. rset = sourceStmt.executeQuery(select.toString());
  1776. }
  1777. ResultSetMetaData rsetMetaData = rset.getMetaData();
  1779. // Remember column types
  1780. int[] colTypes = new int[columnCount];
  1781. for (int i = 0; i < columnCount; i++) {
  1782. colTypes[i] = rsetMetaData.getColumnType(i + 1);
  1783. }
  1785. SimpleDateFormat dateFormat = new SimpleDateFormat(
  1786. "yyyy-MM-dd HH:mm:ss");
  1787. SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");
  1789. Grt.getInstance().addProgress("Started row transfer", 0);
  1790. Grt.getInstance().flushMessages();
  1792. // loop for splitted selects
  1793. do {
  1794. insert = new StringBuffer();
  1795. insert.append(insertHeader);
  1796. boolean isFirstDataTuppel = true;
  1797. int bufferedRows = 0;
  1799. // if splitted selects are used, get next block after
  1800. if (doSplittedSelects && (rset == null)) {
  1801. rowBlockOffset += rowBlockSize;
  1802. rset = sourceStmt
  1803. .executeQuery(select.toString() + "nLIMIT "
  1804. + rowBlockOffset + ", " + rowBlockSize);
  1805. }
  1807. // loop over all rows
  1808. while (rset.next()) {
  1809. currentRowNumber++;
  1811. if (currentRowNumber > rowCount) {
  1812. currentRowNumber = rowCount;
  1813. break;
  1814. }
  1816. if ((currentRowNumber % 100 == 0) && (rowCount > 0)) {
  1817. Grt.getInstance().addProgress(
  1818. currentRowNumber + " rows transfered.",
  1819. (currentRowNumber * 100) / rowTotalCount);
  1821. if (Grt.getInstance().flushMessages() != 0) {
  1822. Grt.getInstance().addMsg(
  1823. "Bulk transfer canceled by user.");
  1824. return 1;
  1825. }
  1826. }
  1828. // check if we need to add a ,
  1829. if (isFirstDataTuppel) {
  1830. insert = insert.append('(');
  1831. isFirstDataTuppel = false;
  1832. } else
  1833. insert = insert.append(",rn  (");
  1835. // add the column data to the insert
  1836. for (int i = 0; i < columnCount; i++) {
  1837. if (i > 0)
  1838. insert.append(", ");
  1840. String columnTypeName = rsetMetaData
  1841. .getColumnTypeName(i + 1);
  1843. if ((colTypes[i] == java.sql.Types.BIGINT)
  1844. || (colTypes[i] == java.sql.Types.INTEGER)
  1845. || (colTypes[i] == java.sql.Types.SMALLINT)
  1846. || (colTypes[i] == java.sql.Types.TINYINT)) {
  1847. String value = rset.getString(i + 1);
  1849. if (value != null)
  1850. insert.append(value);
  1851. else
  1852. insert.append("NULL");
  1853. } else if ((colTypes[i] == java.sql.Types.DECIMAL)
  1854. || (colTypes[i] == java.sql.Types.DOUBLE)
  1855. || (colTypes[i] == java.sql.Types.FLOAT)
  1856. || (colTypes[i] == java.sql.Types.NUMERIC)
  1857. || (colTypes[i] == java.sql.Types.REAL)) {
  1858. BigDecimal value = rset.getBigDecimal(i + 1);
  1860. if (value != null)
  1861. insert.append(value.toString());
  1862. else
  1863. insert.append("NULL");
  1864. } else if ((colTypes[i] == java.sql.Types.LONGVARCHAR)
  1865. || (colTypes[i] == java.sql.Types.VARCHAR)
  1866. || (colTypes[i] == java.sql.Types.CHAR)) {
  1867. String value = rset.getString(i + 1);
  1869. if (doRightTrimForText)
  1870. value = value.replaceAll("\s+$", "");
  1872. if (value != null) {
  1873. insert.append("'");
  1874. insert.append(getEscapedString(value));
  1875. insert.append("'");
  1876. } else
  1877. insert.append("NULL");
  1878. } else if (colTypes[i] == java.sql.Types.DATE) {
  1879. Timestamp value = rset.getTimestamp(i + 1);
  1881. if (value != null) {
  1882. insert.append("'");
  1883. insert.append(dateFormat.format(value));
  1884. insert.append("'");
  1885. } else
  1886. insert.append("NULL");
  1887. } else if (colTypes[i] == java.sql.Types.TIME) {
  1888. Time value = rset.getTime(i + 1);
  1890. if (value != null) {
  1891. insert.append("'");
  1892. insert.append(timeFormat.format(value));
  1893. insert.append("'");
  1894. } else
  1895. insert.append("NULL");
  1896. } else if (colTypes[i] == java.sql.Types.BLOB
  1897. || columnTypeName.equalsIgnoreCase("LONG RAW")
  1898. || columnTypeName.equalsIgnoreCase("LONG")
  1899. || columnTypeName.equalsIgnoreCase("RAW")
  1900. || columnTypeName.equalsIgnoreCase("BINARY")
  1901. || columnTypeName.equalsIgnoreCase("VARBINARY")
  1902. || columnTypeName.equalsIgnoreCase("IMAGE")) {
  1903. try {
  1904. if (!doBlobStreaming) {
  1905. InputStream blobStream = rset
  1906. .getBinaryStream(i + 1);
  1908. if (blobStream != null) {
  1909. insert
  1910. .append(getEscapedHexString(
  1911. blobStream,
  1912. doOverrideBlobLimit));
  1913. blobStream.close();
  1914. } else
  1915. insert.append("NULL");
  1916. } else {
  1917. insert.append("NULL");
  1918. }
  1919. } catch (Exception e) {
  1920. Grt
  1921. .getInstance()
  1922. .addErr(
  1923. "The following error occured while "
  1924. + "transfering binary data from "
  1925. + sourceTable.getName()
  1926. + ", column "
  1927. + rsetMetaData
  1928. .getColumnName(i + 1)
  1929. + "n" + e.getMessage());
  1931. insert.append("NULL");
  1932. }
  1933. } else if (columnTypeName.equals("BIT")) {
  1934. if (sourceDbConn.getDriver().getName().equals(
  1935. "Access")) {
  1936. String value = rset.getString(i + 1);
  1937. insert.append(String.valueOf(Integer
  1938. .parseInt(value)
  1939. * -1));
  1940. } else
  1941. insert.append(rset.getString(i + 1));
  1942. } else if (colTypes[i] == java.sql.Types.DATE) {
  1943. Date value = rset.getDate(i + 1);
  1945. if (value != null) {
  1946. insert.append("'");
  1947. insert.append(dateFormat.format(value));
  1948. insert.append("'");
  1949. } else
  1950. insert.append("NULL");
  1951. } else if ((colTypes[i] == java.sql.Types.BOOLEAN)
  1952. || ((colTypes[i] == java.sql.Types.BIT) && columnTypeName
  1953. .equals("TINYINT"))) {
  1954. boolean value = rset.getBoolean(i + 1);
  1956. if (value)
  1957. insert.append("1");
  1958. else
  1959. insert.append("0");
  1960. } else {
  1961. // if the type is not of java.sql.Types, take a look
  1962. // at
  1963. // the type's name
  1965. if (columnTypeName.equalsIgnoreCase("BIT")) {
  1966. insert.append(rset.getString(i + 1));
  1967. } else if (columnTypeName.equalsIgnoreCase("DATE")
  1968. || columnTypeName
  1969. .equalsIgnoreCase("DATETIME")
  1970. || columnTypeName
  1971. .equalsIgnoreCase("SMALLDATETIME")
  1972. || (columnTypeName.indexOf("TIMESTAMP") > -1)) {
  1973. Timestamp value;
  1975. try {
  1976. value = rset.getTimestamp(i + 1);
  1977. } catch (SQLException e) {
  1978. try {
  1979. value = Timestamp.valueOf(rset
  1980. .getString(i + 1));
  1981. } catch (Exception e1) {
  1982. value = new Timestamp(0);
  1983. }
  1984. }
  1986. if (value != null) {
  1987. insert.append("'");
  1988. insert.append(dateFormat.format(value));
  1989. insert.append("'");
  1990. } else
  1991. insert.append("NULL");
  1992. } else if (columnTypeName.equalsIgnoreCase("TEXT")
  1993. || columnTypeName.equalsIgnoreCase("NTEXT")) {
  1994. String value = rset.getString(i + 1);
  1996. if (value != null) {
  1997. insert.append("'");
  1998. insert.append(getEscapedString(value));
  1999. insert.append("'");
  2000. } else
  2001. insert.append("NULL");
  2002. } else if (columnTypeName.equalsIgnoreCase("CLOB")) {
  2003. Reader reader = null;
  2004. try {
  2005. reader = rset.getCharacterStream(i + 1);
  2006. } catch (SQLException e) {
  2007. insert.append("''");
  2008. }
  2009. if (reader == null) {
  2010. insert.append("NULL");
  2011. } else {
  2012. insert.append("'");
  2014. char[] charbuf = new char[4096];
  2015. for (int j = reader.read(charbuf); j > 0; j = reader
  2016. .read(charbuf)) {
  2017. insert.append(getEscapedString(charbuf,
  2018. j));
  2019. }
  2021. insert.append("'");
  2022. }
  2023. } else if (columnTypeName.equalsIgnoreCase("TINYINT UNSIGNED")) {
  2024. String value = rset.getString(i + 1);
  2026. if (value != null)
  2027. insert.append(value);
  2028. else
  2029. insert.append("NULL");
  2030. } else
  2031. insert.append("''");
  2032. }
  2033. }
  2034. insert.append(')');
  2036. bufferedRows++;
  2038. if (insert.length() > 1024 * 800) {
  2039. insert.append(";rn");
  2041. String sql = insert.toString();
  2042. insert = new StringBuffer();
  2043. insert.append(insertHeader);
  2044. isFirstDataTuppel = true;
  2046. if (doOnlineTransferData) {
  2047. // execute insert statments
  2048. Statement targetStmt = targetConn.createStatement();
  2049. try {
  2050. targetStmt.setEscapeProcessing(false);
  2051. targetStmt.execute(sql);
  2052. } catch (Exception e) {
  2053. // add error log entry
  2054. ObjectLogEntry logEntry = new ObjectLogEntry(
  2055. null);
  2056. logEntry.setName(e.getMessage());
  2057. logEntry.setEntryType(2);
  2059. logObj.getEntries().add(logEntry);
  2061. // remove the number of rows that could not be
  2062. // transfered
  2063. currentRowNumber -= bufferedRows;
  2064. rowCount -= bufferedRows;
  2065. }
  2066. if (targetStmt != null)
  2067. targetStmt.close();
  2069. bufferedRows = 0;
  2070. }
  2072. if (outputStreamWriter != null)
  2073. outputStreamWriter.write(sql);
  2074. }
  2075. }
  2077. if (bufferedRows > 0) {
  2078. insert.append(";rn");
  2080. String sql = insert.toString();
  2082. if (doOnlineTransferData) {
  2083. // execute insert statments
  2084. Statement targetStmt = targetConn.createStatement();
  2085. try {
  2086. targetStmt.setEscapeProcessing(false);
  2087. targetStmt.execute(sql);
  2088. } catch (Exception e) {
  2089. // add error log entry
  2090. ObjectLogEntry logEntry = new ObjectLogEntry(null);
  2091. logEntry.setName(e.getMessage());
  2092. logEntry.setEntryType(2);
  2094. logObj.getEntries().add(logEntry);
  2096. currentRowNumber -= bufferedRows;
  2097. }
  2098. if (targetStmt != null)
  2099. targetStmt.close();
  2100. }
  2102. if (outputStreamWriter != null)
  2103. outputStreamWriter.write(sql);
  2104. }
  2106. if ((rowCount > 0) && (outputStreamWriter != null))
  2107. outputStreamWriter.write("rn");
  2109. // if doSplittedSelects is turned on and there are still rows
  2110. // to be transfered, go back to the beginning of the loop
  2111. rset = null;
  2112. } while (doSplittedSelects && currentRowNumber < rowCount);
  2114. sourceStmt.close();
  2116. Grt.getInstance().addMsgDetail(msg,
  2117. Integer.toString(currentRowNumber) + " row(s) transfered.");
  2119. // add log message entry with the number of transfered rows
  2120. ObjectLogEntry logEntry = new ObjectLogEntry(null);
  2121. logEntry.setName(Integer.toString(currentRowNumber)
  2122. + " row(s) transfered.");
  2123. logEntry.setEntryType(0);
  2124. logObj.getEntries().add(logEntry);
  2126. // special handling for BLOB streaming
  2127. if (doBlobStreaming) {
  2128. // commit inserted data
  2129. targetConn.commit();
  2131. doDataBulkTransferTableBlobsToMysql(sourceDbConn, sourceConn,
  2132. sourceTable, targetDbConn, targetConn, targetTable,
  2133. params, outputStreamWriter, logList, currentRowNumber);
  2134. }
  2136. } catch (Exception e) {
  2137. String msgString = "The following error occured while "
  2138. + "transfering data from " + sourceTable.getName() + "n"
  2139. + e.getMessage();
  2140. Grt.getInstance().addErr(msgString);
  2142. // add log message entry with the error
  2143. ObjectLogEntry logEntry = new ObjectLogEntry(null);
  2144. logEntry.setName(msgString);
  2145. logEntry.setEntryType(1);
  2146. logObj.getEntries().add(logEntry);
  2147. }
  2149. logList.add(logObj);
  2151. return 0;
  2152. }
  2154. static StringBuffer getEscapedString(String s) {
  2155. StringBuffer b = new StringBuffer();
  2157. if (s != null) {
  2158. for (int i = 0; i < s.length(); i++) {
  2159. char c = s.charAt(i);
  2161. if (c == '"')
  2162. b.append("\"");
  2163. /*else if (c == '{')
  2164. b.append("\{");*/
  2165. else if (c == ''')
  2166. b.append("\'");
  2167. else if (c == 0)
  2168. b.append("\0");
  2169. else if (c == 'n')
  2170. b.append("\n");
  2171. else if (c == 'r')
  2172. b.append("\r");
  2173. else if (c == '\')
  2174. b.append("\\");
  2175. else
  2176. b.append(c);
  2177. }
  2178. }
  2180. return b;
  2181. }
  2183. static StringBuffer getEscapedString(char[] charbuf, int len) {
  2184. StringBuffer b = new StringBuffer();
  2186. if (charbuf != null) {
  2187. for (int i = 0; i < len; i++) {
  2188. char c = charbuf[i];
  2190. if (c == '"')
  2191. b.append("\"");
  2192. /*else if (c == '{')
  2193. b.append("\{");*/
  2194. else if (c == ''')
  2195. b.append("\'");
  2196. else if (c == 0)
  2197. b.append("\0");
  2198. else if (c == 'n')
  2199. b.append("\n");
  2200. else if (c == 'r')
  2201. b.append("\r");
  2202. else if (c == '\')
  2203. b.append("\\");
  2204. else
  2205. b.append(c);
  2206. }
  2207. }
  2209. return b;
  2210. }
  2212. static StringBuffer getEscapedHexString(InputStream is,
  2213. boolean doOverrideBlobLimit) throws Exception {
  2214. StringBuffer b = new StringBuffer();
  2215. byte buffer[] = new byte[1024];
  2216. int length;
  2217. int currentSize = 0;
  2219. b.append("0x");
  2221. while ((length = is.read(buffer, 0, 1024)) != -1) {
  2222. currentSize += 1024;
  2223. if ((currentSize > 1048576 * 4) && (!doOverrideBlobLimit)) {
  2224. throw new RuntimeException("BLOB is larger than 4MB.");
  2225. }
  2227. for (int i = 0; i < length; i++) {
  2228. if ((buffer[i] & 0xff) < 16)
  2229. b.append('0');
  2231. b.append(Integer.toHexString(buffer[i] & 0xff));
  2232. }
  2233. }
  2235. return b;
  2236. }
  2238. protected int doDataBulkTransferTableBlobsToMysql(
  2239. com.mysql.grt.db.mgmt.Connection sourceDbConn,
  2240. Connection sourceConn, Table sourceTable,
  2241. com.mysql.grt.db.mgmt.Connection targetDbConn,
  2242. Connection targetConn, Table targetTable, GrtStringHashMap params,
  2243. OutputStreamWriter outputStreamWriter,
  2244. com.mysql.grt.base.ObjectLogList logList, int rowCount)
  2245. throws SQLException {
  2247. // there has to be a PK
  2248. if (sourceTable.getPrimaryKey() == null)
  2249. return 0;
  2251. boolean doExcludeSourceSchemaName = false;
  2252. String optionString;
  2254. optionString = params.get("excludeSourceSchemaName");
  2255. if ((optionString != null) && (optionString.equalsIgnoreCase("yes")))
  2256. doExcludeSourceSchemaName = true;
  2258. String sourceQuoteChar = sourceConn.getMetaData()
  2259. .getIdentifierQuoteString();
  2260. String targetQuoteChar = targetConn.getMetaData()
  2261. .getIdentifierQuoteString();
  2263. // build primary key column list
  2264. String selectCols = "";
  2265. String updateCols = "";
  2266. String updatePkCols = "";
  2267. int pkColCount = 0;
  2268. for (int i = 0; i < sourceTable.getPrimaryKey().getColumns().size(); i++) {
  2269. Column sourceColumn = sourceTable.getPrimaryKey().getColumns().get(
  2270. i).getReferedColumn();
  2271. Column targetColumn = null;
  2273. // search target column based on old name
  2274. for (int j = 0; j < targetTable.getColumns().size(); j++) {
  2275. if (targetTable.getColumns().get(j).getOldName().equals(
  2276. sourceColumn.getName())) {
  2277. targetColumn = targetTable.getColumns().get(j);
  2278. break;
  2279. }
  2280. }
  2282. if (targetColumn != null) {
  2283. if (!updatePkCols.equals("")) {
  2284. selectCols += ", ";
  2285. updatePkCols += " AND ";
  2286. }
  2288. selectCols += sourceQuoteChar + sourceColumn.getName()
  2289. + sourceQuoteChar;
  2290. updatePkCols += targetQuoteChar + targetColumn.getName()
  2291. + targetQuoteChar + " = ? ";
  2293. pkColCount++;
  2294. }
  2295. }
  2297. if (pkColCount == 0)
  2298. return 0;
  2300. // build BLOB column list
  2301. int columnCount = 0;
  2302. for (int i = 0; i < sourceTable.getColumns().size(); i++) {
  2303. Column sourceColumn = sourceTable.getColumns().get(i);
  2304. Column targetColumn = null;
  2306. // search target column based on old name
  2307. for (int j = 0; j < targetTable.getColumns().size(); j++) {
  2308. if (targetTable.getColumns().get(j).getOldName().equals(
  2309. sourceColumn.getName())) {
  2310. targetColumn = targetTable.getColumns().get(j);
  2311. break;
  2312. }
  2313. }
  2315. // only look at BLOBs
  2316. String sourceDatatype = sourceColumn.getDatatypeName();
  2317. if (!(sourceDatatype.equalsIgnoreCase("BLOB")
  2318. || sourceDatatype.equalsIgnoreCase("MEDIUMBLOB")
  2319. || sourceDatatype.equalsIgnoreCase("LONGBLOB")
  2320. || sourceDatatype.equalsIgnoreCase("TINYBLOB")
  2321. || sourceDatatype.equalsIgnoreCase("LONG RAW")
  2322. || sourceDatatype.equalsIgnoreCase("RAW")
  2323. || sourceDatatype.equalsIgnoreCase("LONG")
  2324. || sourceDatatype.equalsIgnoreCase("BINARY")
  2325. || sourceDatatype.equalsIgnoreCase("VARBINARY") || sourceDatatype
  2326. .equalsIgnoreCase("IMAGE")))
  2327. continue;
  2329. // only transfer this column if there is a target column
  2330. if (targetColumn != null) {
  2331. if (!selectCols.equals(""))
  2332. selectCols += ", ";
  2334. selectCols += sourceQuoteChar + sourceColumn.getName()
  2335. + sourceQuoteChar;
  2337. if (!updateCols.equals(""))
  2338. updateCols += " AND ";
  2340. updateCols += targetQuoteChar + targetColumn.getName()
  2341. + targetQuoteChar + " = ? ";
  2343. columnCount++;
  2344. }
  2345. }
  2347. if (columnCount == 0)
  2348. return 0;
  2350. String select = "SELECT " + selectCols + " FROM ";
  2352. if (!doExcludeSourceSchemaName) {
  2353. select += sourceQuoteChar + sourceTable.getOwner().getName()
  2354. + sourceQuoteChar + ".";
  2355. }
  2357. select += sourceQuoteChar + sourceTable.getName() + sourceQuoteChar;
  2359. String update = "UPDATE " + targetQuoteChar
  2360. + targetTable.getOwner().getName() + targetQuoteChar + "."
  2361. + targetQuoteChar + targetTable.getName() + targetQuoteChar
  2362. + " SET " + updateCols + "rnWHERE " + updatePkCols;
  2364. Grt.getInstance().addMsg("Starting online BLOB data bulk transfer ...");
  2365. Grt.getInstance().addMsg(select);
  2366. Grt.getInstance().addMsg(update);
  2368. Grt.getInstance().addProgress("Started BLOB transfer", 0);
  2369. Grt.getInstance().flushMessages();
  2371. // use a special connection to enable BLOB streaming
  2372. String jdbcConnectionString = "jdbc:mysql://"
  2373. + targetDbConn.getParameterValues().get("host") + ":"
  2374. + targetDbConn.getParameterValues().get("port") + "/?user="
  2375. + targetDbConn.getParameterValues().get("username")
  2376. + "&password="
  2377. + targetDbConn.getParameterValues().get("password")
  2378. + "&useStreamLengthsInPrepStmts=false";
  2380. Connection blobTargetConn = DriverManager
  2381. .getConnection(jdbcConnectionString);
  2382. blobTargetConn.setAutoCommit(false);
  2384. Statement sourceStmt = sourceConn.createStatement();
  2385. ResultSet rset = sourceStmt.executeQuery(select);
  2386. // ResultSetMetaData rsetMetaData = rset.getMetaData();
  2388. int currentRowNumber = 0;
  2389. int blobNumber = 0;
  2390. while (rset.next()) {
  2391. currentRowNumber++;
  2393. PreparedStatement targetStmt = blobTargetConn
  2394. .prepareStatement(update);
  2396. // update progress every 10 rows
  2397. if ((currentRowNumber % 10 == 0) && (rowCount > 0)) {
  2398. Grt.getInstance()
  2399. .addProgress(
  2400. (currentRowNumber * columnCount)
  2401. + " blobs transfered.",
  2402. (currentRowNumber * 100) / rowCount);
  2404. if (Grt.getInstance().flushMessages() != 0) {
  2405. Grt.getInstance().addMsg(
  2406. "Bulk BLOB transfer canceled by user.");
  2407. return 1;
  2408. }
  2409. }
  2411. // set the BLOB columns
  2412. for (int i = 0; i < columnCount; i++) {
  2413. InputStream blobStream = rset.getBinaryStream(pkColCount + i
  2414. + 1);
  2416. if (blobStream == null)
  2417. targetStmt.setNull(i + 1, java.sql.Types.BLOB);
  2418. else {
  2419. targetStmt.setBinaryStream(i + 1, blobStream, 1);
  2420. blobNumber++;
  2421. }
  2422. }
  2424. // set the PK parameter
  2425. for (int i = 0; i < pkColCount; i++) {
  2426. targetStmt
  2427. .setString(columnCount + i + 1, rset.getString(i + 1));
  2428. }
  2430. try {
  2431. targetStmt.execute();
  2432. } catch (Exception e) {
  2433. Grt.getInstance()
  2434. .addErr(
  2435. "The following error occured while "
  2436. + "transfering BLOB data from "
  2437. + sourceTable.getName() + "n"
  2438. + e.getMessage());
  2439. }
  2441. targetStmt.close();
  2443. // commit after each row.
  2444. blobTargetConn.commit();
  2445. }
  2446. sourceStmt.close();
  2448. blobTargetConn.commit();
  2449. blobTargetConn.close();
  2451. Grt.getInstance().addMsg(
  2452. "Online BLOB data bulk transfer finished, " + blobNumber
  2453. + " BLOB(s) transfered...");
  2454. Grt.getInstance().flushMessages();
  2456. return 0;
  2457. }
  2458. }