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

MySQL数据库

开发平台:

SQL

  1. package com.mysql.grt.modules;
  2. import java.sql.*;
  3. import com.mysql.grt.*;
  4. import com.mysql.grt.base.*;
  5. import com.mysql.grt.db.mysql.*;
  6. /**
  7.  * GRT Migration Class
  8.  * 
  9.  * @author MikeZ
  10.  * @version 1.0, 01/25/05
  11.  * 
  12.  */
  13. public class TransformationMysqlJdbc {
  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(TransformationMysqlJdbc.class, "");
  22. }
  23. /**
  24.  * Generates all SQL create statements for the given catalog. The SQL
  25.  * statement will be set in each database object, e.g. schemata, tables,
  26.  * views, ...
  27.  * 
  28.  * @param catalog
  29.  *            the catalog object to create the SQL for
  30.  */
  31. public static void generateSqlCreateStatements(Catalog catalog,
  32. GrtHashMap options) {
  33. GrtList args = new GrtList();
  34. args.addObject(catalog);
  35. args.addObject(options);
  36. try {
  37. Grt.getInstance().callGrtFunction("TransformationMysql",
  38. "generateSqlCreateStatements", args);
  39. } catch (RuntimeException e) {
  40. // generate sql for tables
  41. Grt.getInstance().addMsg(
  42. "The following error occured while "
  43. + "creating the SQL code: " + e.getMessage());
  44. Grt.getInstance().flushMessages();
  45. }
  46. }
  47. /**
  48.  * Generates the SQL create code for the given object
  49.  * 
  50.  * @param obj
  51.  *            the database object to create the SQL for
  52.  * @return the SQL create code as String
  53.  */
  54. public static String getSqlScript(Catalog catalog, GrtHashMap options) {
  55. String sql = "";
  56. GrtList args = new GrtList();
  57. args.addObject(catalog);
  58. args.addObject(options);
  59. try {
  60. sql = (String) Grt.getInstance().callGrtFunction(
  61. "TransformationMysql", "getSqlScript", args);
  62. } catch (RuntimeException e) {
  63. Grt.getInstance().addMsg(
  64. "The following error occured while "
  65. + "creating the SQL code: " + e.getMessage());
  66. Grt.getInstance().flushMessages();
  67. }
  68. return sql;
  69. }
  70. /**
  71.  * Generates the SQL create code for the given object
  72.  * 
  73.  * @param obj
  74.  *            the database object to create the SQL for
  75.  * @return the SQL create code as String
  76.  */
  77. public static String getSqlCreate(com.mysql.grt.db.DatabaseObject obj) {
  78. String sql;
  79. try {
  80. sql = (String) Grt.getInstance().callGrtFunction(
  81. "TransformationMysql", "getSqlCreate", obj);
  82. } catch (RuntimeException e) {
  83. sql = "/*" + e.getMessage() + "*/";
  84. }
  85. return sql;
  86. }
  87. /**
  88.  * Generates the SQL create code for the given object
  89.  * 
  90.  * @param obj
  91.  *            the database object to create the SQL for
  92.  * @return the SQL create code as String
  93.  */
  94. public static String getSqlDrop(com.mysql.grt.db.DatabaseObject obj) {
  95. String sql;
  96. try {
  97. sql = (String) Grt.getInstance().callGrtFunction(
  98. "TransformationMysql", "getSqlDrop", obj);
  99. } catch (RuntimeException e) {
  100. sql = "/*" + e.getMessage() + "*/";
  101. }
  102. return sql;
  103. }
  104. /**
  105.  * Generates the SQL create code for the given object
  106.  * 
  107.  * @param obj
  108.  *            the database object to create the SQL for
  109.  * @return the SQL create code as String
  110.  */
  111. public static String getSqlMerge(com.mysql.grt.db.DatabaseObject obj) {
  112. String sql;
  113. try {
  114. sql = (String) Grt.getInstance().callGrtFunction(
  115. "TransformationMysql", "getSqlMerge", obj);
  116. } catch (RuntimeException e) {
  117. sql = "/*" + e.getMessage() + "*/";
  118. }
  119. return sql;
  120. }
  121. /**
  122.  * Execute all SQL statements for all objects in the given catalog. The SQL
  123.  * statement is taken from the object's sql member
  124.  * 
  125.  * @param jdbcDriver
  126.  *            class name of the jdbc driver
  127.  * @param jdbcConnectionString
  128.  *            jdbc connection string to the target database
  129.  * @param catalog
  130.  *            the catalog to process
  131.  */
  132. public static void executeSqlStatements(
  133. com.mysql.grt.db.mgmt.Connection dbConn, Catalog catalog,
  134. ObjectLogList logList) throws Exception {
  135. new TransformationMysqlJdbc().doExecuteSqlStatements(dbConn, catalog,
  136. logList);
  137. }
  138. protected void doExecuteSqlStatements(
  139. com.mysql.grt.db.mgmt.Connection dbConn, Catalog catalog,
  140. ObjectLogList logList) throws Exception {
  141. Connection conn = ReverseEngineeringGeneric.establishConnection(dbConn);
  142. String sql;
  143. // Statement stmt = conn.createStatement();
  144. try {
  145. sql = (String) Grt.getInstance().callGrtFunction(
  146. "TransformationMysql", "getScriptHeader", null);
  147. executeSqlStatements(conn, sql, "Execute script header commands.");
  148. } catch (SQLException e) {
  149. // tollerate exception
  150. }
  151. // Create schemata
  152. for (int i = 0; i < catalog.getSchemata().size(); i++) {
  153. Schema schema = (Schema) catalog.getSchemata().get(i);
  154. // Create schema
  155. executeSqlStatement(conn, schema, "Creating schema "
  156. + schema.getName() + " ...", logList);
  157. // Create tables
  158. Grt.getInstance().addMsg("Creating tables ...");
  159. for (int j = 0; j < schema.getTables().size(); j++) {
  160. Table table = (Table) schema.getTables().get(j);
  161. Grt.getInstance().addProgress(
  162. "Creating table " + table.getName(),
  163. (j * 100) / schema.getTables().size());
  164. Grt.getInstance().flushMessages();
  165. executeSqlStatement(conn, table, "Creating table "
  166. + table.getName() + " ...", logList);
  167. }
  168. // Create views
  169. Grt.getInstance().addMsg("Creating views ...");
  170. for (int j = 0; j < schema.getViews().size(); j++) {
  171. View view = (View) schema.getViews().get(j);
  172. Grt.getInstance().addProgress(
  173. "Creating view " + view.getName(),
  174. (j * 100) / schema.getViews().size());
  175. Grt.getInstance().flushMessages();
  176. executeSqlStatement(conn, view, "Creating view "
  177. + view.getName() + " ...", logList);
  178. }
  179. // Create procedures
  180. Grt.getInstance().addMsg("Creating procedures ...");
  181. for (int j = 0; j < schema.getRoutines().size(); j++) {
  182. Routine proc = (Routine) schema.getRoutines().get(j);
  183. Grt.getInstance().addProgress(
  184. "Creating view " + proc.getName(),
  185. (j * 100) / schema.getRoutines().size());
  186. Grt.getInstance().flushMessages();
  187. executeSqlStatement(conn, proc, "Creating procedure "
  188. + proc.getName() + " ...", logList);
  189. }
  190. // Hide progress bar
  191. Grt.getInstance().addProgress("", -1);
  192. Grt.getInstance().flushMessages();
  193. }
  194. try {
  195. sql = (String) Grt.getInstance().callGrtFunction(
  196. "TransformationMysql", "getScriptFooter", null);
  197. executeSqlStatements(conn, sql, "Execute script footer commands.");
  198. } catch (SQLException e) {
  199. // tollerate exception
  200. }
  201. conn.close();
  202. }
  203. private void executeSqlStatement(Connection conn,
  204. com.mysql.grt.db.DatabaseObject obj, String action,
  205. ObjectLogList logList) {
  206. // generate a new object log
  207. ObjectLog objectLog = new ObjectLog(logList.getOwner());
  208. objectLog.setLogObject(obj);
  209. try {
  210. executeSqlStatements(conn, obj.getSql(), action);
  211. } catch (SQLException e) {
  212. ObjectLogEntry entry = new ObjectLogEntry(objectLog);
  213. entry.setName(e.getMessage());
  214. entry.setEntryType(2);
  215. objectLog.getEntries().add(entry);
  216. } finally {
  217. logList.add(objectLog);
  218. }
  219. }
  220. protected void executeSqlStatements(Connection conn, String sql,
  221. String action) throws SQLException {
  222. GrtStringList cmds;
  223. cmds = (GrtStringList) Grt.getInstance().callGrtFunction(
  224. "TransformationMysql", "splitSqlCommands", sql);
  225. for (int i = 0; i < cmds.size(); i++)
  226. executeSqlStatement(conn, cmds.get(i), action);
  227. }
  228. private void executeSqlStatement(Connection conn, String sql, String action)
  229. throws SQLException {
  230. // check if there is a SQL statement to execute
  231. if ((sql != null) && (!sql.equals(""))) {
  232. Grt.getInstance().addMsg(action);
  233. Grt.getInstance().addMsgDetail(sql);
  234. PreparedStatement stmt = conn.prepareStatement(sql);
  235. try {
  236. stmt.execute();
  237. } catch (SQLException e) {
  238. Grt.getInstance().addMsg(
  239. "An error occured while executing the SQL statement.");
  240. Grt.getInstance().addMsgDetail(e.getMessage());
  241. throw (e);
  242. } finally {
  243. if (stmt != null)
  244. stmt.close();
  245. }
  246. }
  247. }
  248. public static com.mysql.grt.db.DatabaseObject getScriptHeader(
  249. GrtHashMap options) {
  250. com.mysql.grt.db.DatabaseObject header;
  251. try {
  252. header = (com.mysql.grt.db.DatabaseObject) Grt.getInstance()
  253. .callGrtFunction("TransformationMysql", "getScriptHeader",
  254. options);
  255. } catch (RuntimeException e) {
  256. header = null;
  257. }
  258. return header;
  259. }
  260. public static com.mysql.grt.db.DatabaseObject getScriptFooter(
  261. GrtHashMap options) {
  262. com.mysql.grt.db.DatabaseObject footer;
  263. try {
  264. footer = (com.mysql.grt.db.DatabaseObject) Grt.getInstance()
  265. .callGrtFunction("TransformationMysql", "getScriptFooter",
  266. null);
  267. } catch (RuntimeException e) {
  268. footer = null;
  269. }
  270. return footer;
  271. }
  272. }