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

MySQL数据库

开发平台:

SQL

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