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

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

MySQL数据库

开发平台：

SQL

MigrationMssql.java：源码内容
  1. package com.mysql.grt.modules;
  3. import com.mysql.grt.*;
  4. import com.mysql.grt.db.migration.*;
  5. import com.mysql.grt.db.mssql.*;
  7. /**
  8.  * GRT Migration Class for MSSQL 2k
  9.  * 
  10.  * @author Mike
  11.  * @version 1.0, 05/21/05
  12.  * 
  13.  */
  14. public class MigrationMssql 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(MigrationMssql.class, "MigrationGeneric");
  24. }
  26. /**
  27.  * Collects information about the migration methods to let the user choose
  28.  * which one to take
  29.  * 
  30.  * @return returns a Method with predefined migration parameters
  31.  */
  32. public static MethodList migrationMethods() {
  33. MethodList methods = MigrationGeneric.migrationMethods();
  35. // add methods to methodlist
  36. MigrationMssql mig = new MigrationMssql();
  37. methods.add(mig.getMigrateSchemaToMysqlInfo());
  38. methods.add(mig.getMigrateTableToMysqlInfo());
  39. methods.add(mig.getMigrateColumnToMysqlInfo());
  40. methods.add(mig.getMigrateViewToMysqlInfo());
  41. methods.add(mig.getMigrateRoutineToMysqlInfo());
  43. return methods;
  44. }
  46. /**
  47.  * Performs a migration based on a Migration object
  48.  * 
  49.  * @param migObj
  50.  *            migration object to migrate
  51.  * @param targetPackageName
  52.  *            name of the package that should be used to generate the target
  53.  *            objects, e.g. db.mysql
  54.  */
  55. public static void migrate(com.mysql.grt.db.migration.Migration migObj,
  56. com.mysql.grt.db.mgmt.Rdbms targetRdbms,
  57. com.mysql.grt.db.Version version) throws Exception {
  59. Grt.getInstance().addMsg("Starting MS SQL migration...");
  61. new MigrationMssql().migrateCatalog(migObj, targetRdbms, version);
  62. }
  64. /**
  65.  * Performs a data transfer from the given source catalog to the target
  66.  * catalog
  67.  * 
  68.  * @param sourceJdbcDriver
  69.  *            class name of the source jdbc driver
  70.  * @param sourceJdbcConnectionString
  71.  *            jdbc connection string to the source database
  72.  * @param sourceCatalog
  73.  *            the source catalog
  74.  * @param targetJdbcDriver
  75.  *            class name of the target jdbc driver
  76.  * @param targetJdbcConnectionString
  77.  *            jdbc connection string to the target database
  78.  * @param targetCatalog
  79.  *            the target catalog
  80.  * @param params
  81.  *            parameters that define how the migration is performed
  82.  */
  83. public static void dataBulkTransfer(
  84. com.mysql.grt.db.mgmt.Connection sourceDbConn,
  85. Catalog sourceCatalog,
  86. com.mysql.grt.db.mgmt.Connection targetDbConn,
  87. com.mysql.grt.db.Catalog targetCatalog, GrtStringHashMap params,
  88. com.mysql.grt.base.ObjectLogList logList) throws Exception {
  90. new MigrationMssql().doDataBulkTransfer(sourceDbConn, sourceCatalog,
  91. targetDbConn, targetCatalog, params, logList);
  92. }
  94. /**
  95.  * migrates the name of an identifier
  96.  * 
  97.  * @param name
  98.  *            the source name of the identifier
  99.  * @return the migrated identifier name
  100.  */
  101. protected String migrateIdentifier(String name) {
  102. return name;
  103. }
  105. /**
  106.  * migrates the sourceSchema 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.  * @param sourceSchema
  115.  *            the source schema that should be migrated
  116.  */
  117. protected com.mysql.grt.db.mysql.Schema migrateSchemaToMysql(
  118. com.mysql.grt.db.migration.Migration migObj, Schema sourceSchema,
  119. GrtStringHashMap migrationParams, GrtObject parent) {
  121. Grt.getInstance().addMsg(
  122. "Migrating schema " + sourceSchema.getName() + " ...");
  123. Grt.getInstance().flushMessages();
  125. // call super migrate function to do basic migration
  126. com.mysql.grt.db.mysql.Schema targetSchema = super
  127. .migrateSchemaToMysql(migObj, sourceSchema, migrationParams,
  128. parent);
  130. // change schema name to catalog_schema
  131. targetSchema.setName(sourceSchema.getOwner().getName() + "_"
  132. + sourceSchema.getName());
  134. return targetSchema;
  135. }
  137. /**
  138.  * Migrates an MSSQL table to a MySQL table
  139.  * 
  140.  * @param sourceTable
  141.  *            the object to migrate
  142.  * @param migrationParams
  143.  *            parameters used to define the target object
  144.  * 
  145.  * @return returns MySQL table object
  146.  */
  147. protected com.mysql.grt.db.mysql.Table migrateTableToMysql(
  148. com.mysql.grt.db.migration.Migration migObj, Table sourceTable,
  149. GrtStringHashMap migrationParams, GrtObject parent) {
  151. // call migration method from the super class
  152. com.mysql.grt.db.mysql.Table targetTable;
  153. targetTable = super.migrateTableToMysql(migObj, sourceTable,
  154. migrationParams, parent);
  156. // do mssql specific things
  158. // return new created, migrated object
  159. return targetTable;
  160. }
  162. /**
  163.  * Migrates a column to a MySQL column
  164.  * 
  165.  * @param sourceColumn
  166.  *            the object to migrate
  167.  * @param migrationParams
  168.  *            parameters used to define the target object
  169.  * @param parent
  170.  *            parent object of the migrated object
  171.  * 
  172.  * @return returns MySQL table object
  173.  */
  174. protected com.mysql.grt.db.mysql.Column migrateColumnToMysql(
  175. com.mysql.grt.db.migration.Migration migObj, Column sourceColumn,
  176. GrtStringHashMap migrationParams, GrtObject parent) {
  178. // create target table
  179. com.mysql.grt.db.mysql.Column targetColumn;
  180. targetColumn = new com.mysql.grt.db.mysql.Column(parent);
  182. // log creation of target object
  183. migUtils.addMigrationLogEntry(migObj, sourceColumn, targetColumn);
  185. // do migration
  186. targetColumn.setName(migUtils.getTargetName(migrationParams,
  187. migrateIdentifier(sourceColumn.getName())));
  188. targetColumn.setOldName(sourceColumn.getName());
  189. targetColumn.setDefaultValue(sourceColumn.getDefaultValue());
  190. targetColumn.setIsNullable(sourceColumn.getIsNullable());
  191. targetColumn.setPrecision(sourceColumn.getPrecision());
  192. targetColumn.setScale(sourceColumn.getScale());
  193. targetColumn.setLength(sourceColumn.getLength());
  195. // migrate datatype
  196. com.mysql.grt.db.SimpleDatatypeList simpleDatatypes = migObj
  197. .getTargetCatalog().getSimpleDatatypes();
  199. String sourceDatatypeName = sourceColumn.getDatatypeName();
  201. if (!migrateColumnParamsToMySql(targetColumn, migrationParams)) {
  202. // character types
  203. if (sourceDatatypeName.equalsIgnoreCase("VARCHAR")
  204. || sourceDatatypeName.equalsIgnoreCase("NVARCHAR")
  205. || sourceDatatypeName.equalsIgnoreCase("TEXT")
  206. || sourceDatatypeName.equalsIgnoreCase("NTEXT")) {
  207. // text types
  208. if (sourceColumn.getLength() < 256) {
  209. // normal varchar up to 255 chars
  210. targetColumn.setDatatypeName("VARCHAR");
  211. } else if (sourceColumn.getLength() < 65536) {
  212. // MySQL 5 can deal with VARCHAR holding up to 65535
  213. // characters
  214. if (migObj.getTargetCatalog().getVersion().getMajor() >= 5)
  215. targetColumn.setDatatypeName("VARCHAR");
  216. // for older versions use medium text up to 65535
  217. else
  218. targetColumn.setDatatypeName("MEDIUMTEXT");
  219. } else {
  220. // long text
  221. targetColumn.setDatatypeName("LONGTEXT");
  222. }
  223. } else if (sourceDatatypeName.equalsIgnoreCase("CHAR")
  224. || sourceDatatypeName.equalsIgnoreCase("NCHAR")) {
  225. // fixed length character types
  226. if (sourceColumn.getLength() < 256) {
  227. // normal varchar up to 255 chars
  228. targetColumn.setDatatypeName("CHAR");
  229. } else {
  230. // long text
  231. targetColumn.setDatatypeName("LONGTEXT");
  232. }
  233. }
  234. // binary types
  235. else if (sourceDatatypeName.equalsIgnoreCase("IMAGE")
  236. || sourceDatatypeName.equalsIgnoreCase("BINARY")
  237. || sourceDatatypeName.equalsIgnoreCase("VARBINARY")) {
  238. if (sourceColumn.getLength() < 256) {
  239. if (sourceDatatypeName.equalsIgnoreCase("IMAGE")) {
  240. // tiny blob up to 255 byte
  241. targetColumn.setDatatypeName("TINYBLOB");
  242. } else if (sourceDatatypeName.equalsIgnoreCase("BINARY")) {
  243. // tiny blob up to 255 byte
  244. targetColumn.setDatatypeName("BINARY");
  245. } else if (sourceDatatypeName.equalsIgnoreCase("VARBINARY")) {
  246. // tiny blob up to 255 byte
  247. targetColumn.setDatatypeName("VARBINARY");
  248. }
  249. } else if (sourceColumn.getLength() < 65536) {
  250. // medium blob up to 65535 byte
  251. targetColumn.setDatatypeName("MEDIUMBLOB");
  252. } else {
  253. // long blob
  254. targetColumn.setDatatypeName("LONGBLOB");
  255. }
  256. }
  257. // numeric types
  258. else if (sourceDatatypeName.equalsIgnoreCase("DECIMAL")
  259. || sourceDatatypeName.equalsIgnoreCase("NUMERIC")
  260. || sourceDatatypeName.equalsIgnoreCase("MONEY")
  261. || sourceDatatypeName.equalsIgnoreCase("SMALLMONEY")) {
  262. targetColumn.setDatatypeName("DECIMAL");
  263. } else if (sourceDatatypeName.equalsIgnoreCase("FLOAT")) {
  264. targetColumn.setDatatypeName("FLOAT");
  265. targetColumn.setScale(-1);
  266. } else if (sourceDatatypeName.equalsIgnoreCase("REAL")) {
  267. targetColumn.setDatatypeName("FLOAT");
  268. targetColumn.setScale(-1);
  269. }
  270. // datetime types
  271. else if (sourceDatatypeName.equalsIgnoreCase("DATETIME")
  272. || sourceDatatypeName.equalsIgnoreCase("SMALLDATETIME")) {
  273. if (sourceColumn.getDefaultValue() != null
  274. && sourceColumn.getDefaultValue().equalsIgnoreCase(
  275. "getdate()")) {
  276. targetColumn.setDatatypeName("TIMESTAMP");
  277. targetColumn.setDefaultValue("CURRENT_TIMESTAMP");
  278. } else
  279. targetColumn.setDatatypeName("DATETIME");
  280. }
  281. // timestamp types
  282. else if (sourceDatatypeName.equalsIgnoreCase("TIMESTAMP")) {
  283. targetColumn.setDatatypeName("TIMESTAMP");
  285. if (sourceColumn.getDefaultValue() != null
  286. && sourceColumn.getDefaultValue().equalsIgnoreCase(
  287. "getdate()"))
  288. targetColumn.setDefaultValue("CURRENT_TIMESTAMP");
  289. }
  290. // integer types
  291. else if (sourceDatatypeName.equalsIgnoreCase("BIGINT")) {
  292. targetColumn.setDatatypeName("BIGINT");
  293. } else if (sourceDatatypeName.equalsIgnoreCase("INT")) {
  294. targetColumn.setDatatypeName("INT");
  295. } else if (sourceDatatypeName.equalsIgnoreCase("SMALLINT")) {
  296. targetColumn.setDatatypeName("SMALLINT");
  297. } else if (sourceDatatypeName.equalsIgnoreCase("TINYINT")
  298. || sourceDatatypeName.equalsIgnoreCase("BIT")) {
  299. targetColumn.setDatatypeName("TINYINT");
  300. } else if (sourceDatatypeName.equalsIgnoreCase("UNIQUEIDENTIFIER")) {
  301. targetColumn.setDatatypeName("VARCHAR");
  302. targetColumn.setLength(64);
  303. }
  304. // not covered yet
  305. else {
  306. migUtils.addMigrationLogEntry(migObj, sourceColumn,
  307. targetColumn, "The datatype "
  308. + sourceColumn.getDatatypeName()
  309. + " cannot be migrated.",
  310. MigrationUtils.logError);
  311. }
  312. }
  314. // lookup the simple value and set it in the column
  315. int simpleDatatypeIndex = simpleDatatypes.getIndexOfName(targetColumn
  316. .getDatatypeName());
  317. if (simpleDatatypeIndex > -1)
  318. targetColumn
  319. .setSimpleType(simpleDatatypes.get(simpleDatatypeIndex));
  321. // make sure N* are utf8
  322. if (sourceDatatypeName.equalsIgnoreCase("NVARCHAR")
  323. || sourceDatatypeName.equalsIgnoreCase("NCHAR")
  324. || sourceDatatypeName.equalsIgnoreCase("NTEXT")) {
  325. targetColumn.setCharacterSetName("utf8");
  326. targetColumn.setCollationName("utf8_general_ci");
  327. }
  329. // AutoIncrement, only for INT datatypes
  330. String datatypeName = targetColumn.getDatatypeName();
  331. if (datatypeName.equalsIgnoreCase("INT")
  332. || datatypeName.equalsIgnoreCase("INTEGER")
  333. || datatypeName.equalsIgnoreCase("TINYINT")
  334. || datatypeName.equalsIgnoreCase("SMALLINT")
  335. || datatypeName.equalsIgnoreCase("BIGINT"))
  336. targetColumn.setAutoIncrement(sourceColumn.getIdentity());
  338. // return new created, migrated object
  339. return targetColumn;
  340. }
  342. /**
  343.  * Migrates an MS SQL view to a MySQL view
  344.  * 
  345.  * @param sourceView
  346.  *            the object to migrate
  347.  * @param migrationParams
  348.  *            parameters used to define the target object
  349.  * 
  350.  * @return returns MySQL view object
  351.  */
  352. protected com.mysql.grt.db.mysql.View migrateViewToMysql(
  353. com.mysql.grt.db.migration.Migration migObj, View sourceView,
  354. GrtStringHashMap migrationParams, GrtObject parent) {
  356. // create target view
  357. com.mysql.grt.db.mysql.View targetView = super.migrateViewToMysql(
  358. migObj, sourceView, migrationParams, parent);
  360. // return new created, migrated object
  361. return targetView;
  362. }
  364. /**
  365.  * Migrates an MS SQL Routine to a MySQL Routine
  366.  * 
  367.  * @param sourceView
  368.  *            the object to migrate
  369.  * @param migrationParams
  370.  *            parameters used to define the target object
  371.  * 
  372.  * @return returns MySQL view object
  373.  */
  374. protected com.mysql.grt.db.mysql.Routine migrateRoutineToMysql(
  375. com.mysql.grt.db.migration.Migration migObj, Routine sourceProc,
  376. GrtStringHashMap migrationParams, GrtObject parent) {
  378. // create target Routine
  379. com.mysql.grt.db.mysql.Routine targetProc = super
  380. .migrateRoutineToMysql(migObj, sourceProc, migrationParams,
  381. parent);
  383. // copy Routine code 1:1
  384. targetProc.setRoutineCode(sourceProc.getRoutineCode());
  386. // return new created, migrated object
  387. return targetProc;
  388. }
  390. /**
  391.  * Generates information about the schema to MySQL migration method
  392.  * 
  393.  * @return returns a Method with predefined migration parameters
  394.  */
  395. private Method getMigrateSchemaToMysqlInfo() {
  397. // create method description
  398. Method method = new Method(null);
  399. method.setName("migrateSchemaToMysql");
  400. method.setModuleName("MigrationMssql");
  401. method.setCaption("MS SQL Default");
  402. method.setDesc("Default method to migrate an MS SQL schema to MySQL.");
  403. method.setSourceStructName("db.mssql.Schema");
  404. method.setTargetPackageName("db.mysql");
  405. method.setRating(1);
  407. addMigrateSchemaToMysqlInfoParameters(method);
  409. return method;
  410. }
  412. /**
  413.  * Generates information about the Table to MySQL migration method
  414.  * 
  415.  * @return returns a Method with predefined migration parameters
  416.  */
  417. private Method getMigrateTableToMysqlInfo() {
  419. // create method description
  420. Method method = new Method(null);
  421. method.setName("migrateTableToMysql");
  422. method.setModuleName("MigrationMssql");
  423. method.setCaption("MS SQL Default");
  424. method.setDesc("Default method to migrate a MS SQL table to MySQL.");
  425. method.setSourceStructName("db.mssql.Table");
  426. method.setTargetPackageName("db.mysql");
  427. method.setRating(1);
  429. addMigrateTableToMysqlInfoParameters(method);
  431. return method;
  432. }
  434. /**
  435.  * Generates information about the Column to MySQL migration method
  436.  * 
  437.  * @return returns a Method with predefined migration parameters
  438.  */
  439. private Method getMigrateColumnToMysqlInfo() {
  441. // create method description
  442. Method method = new Method(null);
  443. method.setName("migrateColumnToMysql");
  444. method.setModuleName("MigrationMssql");
  445. method.setCaption("MS SQL Default");
  446. method.setDesc("Default method to migrate a MS SQL column to MySQL.");
  447. method.setSourceStructName("db.mssql.Column");
  448. method.setTargetPackageName("db.mysql");
  449. method.setRating(1);
  451. addMigrateColumnToMysqlInfoParameters(method);
  453. return method;
  454. }
  456. /**
  457.  * Generates information about the View to MySQL migration method
  458.  * 
  459.  * @return returns a Method with predefined migration parameters
  460.  */
  461. private Method getMigrateViewToMysqlInfo() {
  463. // create migrateOracleTable method
  464. Method method = new Method(null);
  465. method.setName("migrateViewToMysql");
  466. method.setModuleName("MigrationMssql");
  467. method.setCaption("MS SQL Default");
  468. method.setDesc("Default method to migrate an MS SQL view to MySQL.");
  469. method.setSourceStructName("db.mssql.View");
  470. method.setTargetPackageName("db.mysql");
  471. method.setRating(1);
  473. addMigrateViewToMysqlInfoParameters(method);
  475. return method;
  476. }
  478. /**
  479.  * Generates information about the View to MySQL migration method
  480.  * 
  481.  * @return returns a Method with predefined migration parameters
  482.  */
  483. private Method getMigrateRoutineToMysqlInfo() {
  485. // create migrateOracleTable method
  486. Method method = new Method(null);
  487. method.setName("migrateRoutineToMysql");
  488. method.setModuleName("MigrationMssql");
  489. method.setCaption("MS SQL Default");
  490. method.setDesc("Default method to migrate an "
  491. + "MS SQL routine to MySQL.");
  492. method.setSourceStructName("db.mssql.Routine");
  493. method.setTargetPackageName("db.mysql");
  494. method.setRating(1);
  496. addMigrateRoutineToMysqlInfoParameters(method);
  498. return method;
  499. }
  500. }