MigrationMysql.java
上传用户:cccombo
上传日期:2021-01-31
资源大小:16445k
文件大小:13k
源码类别:

MySQL数据库

开发平台:

SQL

  1. package com.mysql.grt.modules;
  2. import com.mysql.grt.Grt;
  3. import com.mysql.grt.GrtObject;
  4. import com.mysql.grt.GrtStringHashMap;
  5. import com.mysql.grt.db.mysql.*;
  6. import com.mysql.grt.db.migration.Method;
  7. import com.mysql.grt.db.migration.MethodList;
  8. /**
  9.  * GRT Migration Class for MySQL
  10.  * 
  11.  * @author Mike
  12.  * @version 1.0, 06/17/05
  13.  * 
  14.  */
  15. public class MigrationMysql extends MigrationGeneric {
  16. /**
  17.  * Static function to return information about this class to the GRT
  18.  * environment
  19.  * 
  20.  * @return returns a GRT XML string containing the infos about this class
  21.  */
  22. public static String getModuleInfo() {
  23. return Grt.getModuleInfoXml(MigrationMysql.class, "MigrationGeneric");
  24. }
  25. /**
  26.  * Collects information about the migration methods to let the user choose
  27.  * which one to take
  28.  * 
  29.  * @return returns a Method with predefined migration parameters
  30.  */
  31. public static MethodList migrationMethods() {
  32. MethodList methods = MigrationGeneric.migrationMethods();
  33. // add methods to methodlist
  34. MigrationMysql mig = new MigrationMysql();
  35. methods.add(mig.getMigrateSchemaToMysqlInfo());
  36. methods.add(mig.getMigrateTableToMysqlInfo());
  37. methods.add(mig.getMigrateColumnToMysqlInfo());
  38. methods.add(mig.getMigrateViewToMysqlInfo());
  39. methods.add(mig.getMigrateRoutineToMysqlInfo());
  40. return methods;
  41. }
  42. /**
  43.  * Performs a migration based on a Migration object
  44.  * 
  45.  * @param migObj
  46.  *            migration object to migrate
  47.  * @param targetPackageName
  48.  *            name of the package that should be used to generate the target
  49.  *            objects, e.g. db.mysql
  50.  */
  51. public static void migrate(com.mysql.grt.db.migration.Migration migObj,
  52. com.mysql.grt.db.mgmt.Rdbms targetRdbms,
  53. com.mysql.grt.db.Version version) throws Exception {
  54. Grt.getInstance().addMsg("Starting MySQL migration...");
  55. new MigrationMysql().migrateCatalog(migObj, targetRdbms, version);
  56. }
  57. /**
  58.  * Performs a data transfer from the given source catalog to the target
  59.  * catalog
  60.  * 
  61.  * @param sourceJdbcDriver
  62.  *            class name of the source jdbc driver
  63.  * @param sourceJdbcConnectionString
  64.  *            jdbc connection string to the source database
  65.  * @param sourceCatalog
  66.  *            the source catalog
  67.  * @param targetJdbcDriver
  68.  *            class name of the target jdbc driver
  69.  * @param targetJdbcConnectionString
  70.  *            jdbc connection string to the target database
  71.  * @param targetCatalog
  72.  *            the target catalog
  73.  * @param params
  74.  *            parameters that define how the migration is performed
  75.  */
  76. public static void dataBulkTransfer(
  77. com.mysql.grt.db.mgmt.Connection sourceDbConn,
  78. Catalog sourceCatalog,
  79. com.mysql.grt.db.mgmt.Connection targetDbConn,
  80. com.mysql.grt.db.Catalog targetCatalog, GrtStringHashMap params,
  81. com.mysql.grt.base.ObjectLogList logList) throws Exception {
  82. new MigrationOracle().doDataBulkTransfer(sourceDbConn, sourceCatalog,
  83. targetDbConn, targetCatalog, params, logList);
  84. }
  85. /**
  86.  * migrates the name of an identifier
  87.  * 
  88.  * @param name
  89.  *            the source name of the identifier
  90.  * @return the migrated identifier name
  91.  */
  92. protected String migrateIdentifier(String name) {
  93. return name;
  94. }
  95. /**
  96.  * migrates the sourceSchema and stores the targetCatalog in the global
  97.  * migration object
  98.  * 
  99.  * @param migObj
  100.  *            migration object to migrate
  101.  * @param targetPackageName
  102.  *            name of the package that should be used to generate the target
  103.  *            objects, e.g. db.mysql
  104.  * @param sourceSchema
  105.  *            the source schema that should be migrated
  106.  */
  107. protected com.mysql.grt.db.mysql.Schema migrateSchemaToMysql(
  108. com.mysql.grt.db.migration.Migration migObj, Schema sourceSchema,
  109. GrtStringHashMap migrationParams, GrtObject parent) {
  110. Grt.getInstance().addMsg(
  111. "Migrating schema " + sourceSchema.getName() + " ...");
  112. Grt.getInstance().flushMessages();
  113. // call super migrate function to do basic migration
  114. com.mysql.grt.db.mysql.Schema targetSchema = super
  115. .migrateSchemaToMysql(migObj, sourceSchema, migrationParams,
  116. parent);
  117. return targetSchema;
  118. }
  119. /**
  120.  * Migrates an MySQL table to a MySQL table
  121.  * 
  122.  * @param sourceTable
  123.  *            the object to migrate
  124.  * @param migrationParams
  125.  *            parameters used to define the target object
  126.  * 
  127.  * @return returns MySQL table object
  128.  */
  129. protected com.mysql.grt.db.mysql.Table migrateTableToMysql(
  130. com.mysql.grt.db.migration.Migration migObj, Table sourceTable,
  131. GrtStringHashMap migrationParams, GrtObject parent) {
  132. // call migration method from the super class
  133. com.mysql.grt.db.mysql.Table targetTable;
  134. targetTable = super.migrateTableToMysql(migObj, sourceTable,
  135. migrationParams, parent);
  136. // do mysql specific things
  137. String engine = migrationParams.get("engine");
  138. if ((engine == null) || engine.equalsIgnoreCase(""))
  139. targetTable.setTableEngine(sourceTable.getTableEngine());
  140. // return new created, migrated object
  141. return targetTable;
  142. }
  143. /**
  144.  * Migrates a column to a MySQL column
  145.  * 
  146.  * @param sourceColumn
  147.  *            the object to migrate
  148.  * @param migrationParams
  149.  *            parameters used to define the target object
  150.  * @param parent
  151.  *            parent object of the migrated object
  152.  * 
  153.  * @return returns MySQL table object
  154.  */
  155. protected com.mysql.grt.db.mysql.Column migrateColumnToMysql(
  156. com.mysql.grt.db.migration.Migration migObj, Column sourceColumn,
  157. GrtStringHashMap migrationParams, GrtObject parent) {
  158. // create target table
  159. com.mysql.grt.db.mysql.Column targetColumn;
  160. targetColumn = new com.mysql.grt.db.mysql.Column(parent);
  161. // log creation of target object
  162. migUtils.addMigrationLogEntry(migObj, sourceColumn, targetColumn);
  163. // do migration
  164. targetColumn.setName(migUtils.getTargetName(migrationParams,
  165. migrateIdentifier(sourceColumn.getName())));
  166. targetColumn.setOldName(sourceColumn.getName());
  167. targetColumn.setDefaultValue(sourceColumn.getDefaultValue());
  168. targetColumn.setIsNullable(sourceColumn.getIsNullable());
  169. targetColumn.setPrecision(sourceColumn.getPrecision());
  170. targetColumn.setScale(sourceColumn.getScale());
  171. targetColumn.setLength(sourceColumn.getLength());
  172. targetColumn.setDatatypeExplicitParams(sourceColumn
  173. .getDatatypeExplicitParams());
  174. // migrate datatype
  175. com.mysql.grt.db.SimpleDatatypeList simpleDatatypes = migObj
  176. .getTargetCatalog().getSimpleDatatypes();
  177. String sourceDatatypeName = sourceColumn.getDatatypeName();
  178. if (!migrateColumnParamsToMySql(targetColumn, migrationParams)) {
  179. targetColumn.setDatatypeName(sourceDatatypeName);
  180. }
  181. targetColumn.setSimpleType(simpleDatatypes.get(simpleDatatypes
  182. .getIndexOfName(sourceDatatypeName)));
  183. targetColumn.setCharacterSetName(sourceColumn.getCharacterSetName());
  184. targetColumn.setCollationName(sourceColumn.getCollationName());
  185. targetColumn.setAutoIncrement(sourceColumn.getAutoIncrement());
  186. // migrate flags
  187. for (int i = 0; i < sourceColumn.getFlags().size(); i++) {
  188. targetColumn.getFlags().add(sourceColumn.getFlags().get(i));
  189. }
  190. // return new created, migrated object
  191. return targetColumn;
  192. }
  193. /**
  194.  * Migrates an MySQL view to a MySQL view
  195.  * 
  196.  * @param sourceView
  197.  *            the object to migrate
  198.  * @param migrationParams
  199.  *            parameters used to define the target object
  200.  * 
  201.  * @return returns MySQL view object
  202.  */
  203. protected com.mysql.grt.db.mysql.View migrateViewToMysql(
  204. com.mysql.grt.db.migration.Migration migObj, View sourceView,
  205. GrtStringHashMap migrationParams, GrtObject parent) {
  206. // create target view
  207. com.mysql.grt.db.mysql.View targetView;
  208. targetView = new com.mysql.grt.db.mysql.View(parent);
  209. // log creation of target object
  210. migUtils.addMigrationLogEntry(migObj, sourceView, targetView);
  211. // do migration
  212. targetView.setName(migUtils.getTargetName(migrationParams,
  213. migrateIdentifier(sourceView.getName())));
  214. targetView.setOldName(sourceView.getName());
  215. targetView.setWithCheckCondition(sourceView.getWithCheckCondition());
  216. // migrate SQL
  217. String query = sourceView.getQueryExpression().trim();
  218. // detect WITH CHECK OPTION in sql and remove it
  219. if (query.toUpperCase().endsWith("WITH CHECK OPTION"))
  220. query = query.substring(0, query.length() - 17).trim();
  221. targetView.setQueryExpression(query);
  222. targetView.setCommentedOut(0);
  223. // return new created, migrated object
  224. return targetView;
  225. }
  226. /**
  227.  * Migrates an MySQL Routine to a MySQL Routine
  228.  * 
  229.  * @param sourceView
  230.  *            the object to migrate
  231.  * @param migrationParams
  232.  *            parameters used to define the target object
  233.  * 
  234.  * @return returns MySQL view object
  235.  */
  236. protected com.mysql.grt.db.mysql.Routine migrateRoutineToMysql(
  237. com.mysql.grt.db.migration.Migration migObj, Routine sourceProc,
  238. GrtStringHashMap migrationParams, GrtObject parent) {
  239. com.mysql.grt.db.mysql.Routine targetProc;
  240. targetProc = new com.mysql.grt.db.mysql.Routine(parent);
  241. // log creation of target object
  242. migUtils.addMigrationLogEntry(migObj, sourceProc, sourceProc);
  243. // do migration
  244. targetProc.setName(migUtils.getTargetName(migrationParams,
  245. migrateIdentifier(sourceProc.getName())));
  246. targetProc.setOldName(sourceProc.getName());
  247. targetProc.setRoutineType(sourceProc.getRoutineType());
  248. // migrate SQL
  249. targetProc.setRoutineCode(sourceProc.getRoutineCode());
  250. // return new created, migrated object
  251. return targetProc;
  252. }
  253. /**
  254.  * Generates information about the schema to MySQL migration method
  255.  * 
  256.  * @return returns a Method with predefined migration parameters
  257.  */
  258. private Method getMigrateSchemaToMysqlInfo() {
  259. // create method description
  260. Method method = new Method(null);
  261. method.setName("migrateSchemaToMysql");
  262. method.setModuleName("MigrationMysql");
  263. method.setCaption("MySQL Default");
  264. method.setDesc("Default method to migrate an MySQL schema to MySQL.");
  265. method.setSourceStructName("db.mysql.Schema");
  266. method.setTargetPackageName("db.mysql");
  267. method.setRating(1);
  268. addMigrateSchemaToMysqlInfoParameters(method);
  269. return method;
  270. }
  271. /**
  272.  * Generates information about the Oracle Table to MySQL migration method
  273.  * 
  274.  * @return returns a Method with predefined migration parameters
  275.  */
  276. private Method getMigrateTableToMysqlInfo() {
  277. // create migrateOracleTable method
  278. Method method = new Method(null);
  279. method.setName("migrateTableToMysql");
  280. method.setModuleName("MigrationMysql");
  281. method.setCaption("MySQL Default");
  282. method.setDesc("Default method to migrate an MySQL table to MySQL.");
  283. method.setSourceStructName("db.mysql.Table");
  284. method.setTargetPackageName("db.mysql");
  285. method.setRating(1);
  286. addMigrateTableToMysqlInfoParameters(method);
  287. return method;
  288. }
  289. /**
  290.  * Generates information about the Column to MySQL migration method
  291.  * 
  292.  * @return returns a Method with predefined migration parameters
  293.  */
  294. private Method getMigrateColumnToMysqlInfo() {
  295. // create method description
  296. Method method = new Method(null);
  297. method.setName("migrateColumnToMysql");
  298. method.setModuleName("MigrationMysql");
  299. method.setCaption("MySQL Default");
  300. method.setDesc("Default method to migrate a MySQL column to MySQL.");
  301. method.setSourceStructName("db.mysql.Column");
  302. method.setTargetPackageName("db.mysql");
  303. method.setRating(1);
  304. addMigrateColumnToMysqlInfoParameters(method);
  305. return method;
  306. }
  307. /**
  308.  * Generates information about the View to MySQL migration method
  309.  * 
  310.  * @return returns a Method with predefined migration parameters
  311.  */
  312. private Method getMigrateViewToMysqlInfo() {
  313. // create migrateOracleTable method
  314. Method method = new Method(null);
  315. method.setName("migrateViewToMysql");
  316. method.setModuleName("MigrationMysql");
  317. method.setCaption("MySQL Default");
  318. method.setDesc("Default method to migrate a MySQL view to MySQL.");
  319. method.setSourceStructName("db.mysql.View");
  320. method.setTargetPackageName("db.mysql");
  321. method.setRating(1);
  322. addMigrateViewToMysqlInfoParameters(method);
  323. return method;
  324. }
  325. /**
  326.  * Generates information about the View to MySQL migration method
  327.  * 
  328.  * @return returns a Method with predefined migration parameters
  329.  */
  330. private Method getMigrateRoutineToMysqlInfo() {
  331. // create migrateOracleTable method
  332. Method method = new Method(null);
  333. method.setName("migrateRoutineToMysql");
  334. method.setModuleName("MigrationMysql");
  335. method.setCaption("MySQL Default");
  336. method.setDesc("Default method to migrate an "
  337. + "MySQL routine to MySQL.");
  338. method.setSourceStructName("db.mysql.Routine");
  339. method.setTargetPackageName("db.mysql");
  340. method.setRating(1);
  341. addMigrateRoutineToMysqlInfoParameters(method);
  342. return method;
  343. }
  344. }