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

MySQL数据库

开发平台:

SQL

  1. package com.mysql.grt.modules;
  2. import java.sql.*;
  3. import com.mysql.grt.*;
  4. import com.mysql.grt.db.oracle.*;
  5. /**
  6.  * GRT Reverse Engineering Class for Oracle 8i/9i
  7.  * 
  8.  * @author Mike
  9.  * @version 1.0, 11/26/04
  10.  * 
  11.  */
  12. public class ReverseEngineeringOracle extends ReverseEngineeringGeneric {
  13. /**
  14.  * Static function to return information about this class to the GRT
  15.  * environment
  16.  * 
  17.  * @return returns a GRT XML string containing the infos about this class
  18.  */
  19. public static String getModuleInfo() {
  20. return Grt.getModuleInfoXml(ReverseEngineeringOracle.class,
  21. "ReverseEngineering");
  22. }
  23. private static String schemataSelect = "SELECT USERNAME FROM ALL_USERS ORDER BY USERNAME";
  24. /**
  25.  * Returns a list of all schemata from the given JDBC connection
  26.  * 
  27.  * @param jdbcDriver
  28.  *            the class name of the JDBC driver
  29.  * @param jdbcConnectionString
  30.  *            a JDBC connection string
  31.  * @return returns a GRT XML string containing a list of schemata names
  32.  */
  33. public static GrtStringList getSchemata(
  34. com.mysql.grt.db.mgmt.Connection dbConn) throws Exception {
  35. // connect to the database
  36. Connection conn = establishConnection(dbConn);
  37. Grt.getInstance().addMsg("Fetching schemata list.");
  38. Grt.getInstance().addMsgDetail(schemataSelect);
  39. Grt.getInstance().flushMessages();
  40. GrtStringList schemataList = new GrtStringList();
  41. Statement stmt = conn.createStatement();
  42. ResultSet rset = stmt.executeQuery(schemataSelect);
  43. while (rset.next()) {
  44. schemataList.add(rset.getString(1));
  45. }
  46. stmt.close();
  47. conn.close();
  48. Grt.getInstance().addMsg("Return schemata list.");
  49. Grt.getInstance().flushMessages();
  50. return schemataList;
  51. }
  52. private static String statisticProcedureCall = "CALL DBMS_UTILITY.ANALYZE_SCHEMA"
  53. + "(?,  'ESTIMATE', 50, 0, 'FOR TABLE')";
  54. /**
  55.  * Does the reverse engineering of the given schematas over the JDBC
  56.  * connection and returns the GRT objects
  57.  * 
  58.  * @param jdbcDriver
  59.  *            the class name of the JDBC driver
  60.  * @param jdbcConnectionString
  61.  *            a JDBC connection string
  62.  * @param schemataList
  63.  *            list of schemata to be reverse engineered
  64.  * @return returns a GRT XML string containing a the reverse engineered
  65.  *         objects
  66.  */
  67. public static com.mysql.grt.db.Catalog reverseEngineer(
  68. com.mysql.grt.db.mgmt.Connection dbConn, GrtStringList schemataList)
  69. throws Exception {
  70. boolean reverseEngineerOnlyTableObjects = (Grt.getInstance()
  71. .getGrtGlobalAsInt(
  72. "/migration/applicationData/"
  73. + "reverseEngineerOnlyTableObjects") == 1);
  74. // connect to the database
  75. Connection conn = establishConnection(dbConn);
  76. // create reveng instance
  77. ReverseEngineeringOracle revEng = new ReverseEngineeringOracle();
  78. Catalog catalog = new Catalog(null);
  79. catalog.setName("OracleCatalog");
  80. catalog.setVersion(getVersion(dbConn));
  81. Grt.getInstance().addMsg("Build simple Oracle datatypes.");
  82. Grt.getInstance().flushMessages();
  83. revEng.buildSimpleDatatypes(dbConn, catalog);
  84. for (int i = 0; i < schemataList.size(); i++) {
  85. Schema schema = new Schema(catalog);
  86. schema.setName((String) (schemataList.get(i)));
  87. catalog.getSchemata().add(schema);
  88. // Get Tables
  89. if (revEng.reverseEngineerTables(conn, catalog, schema) == 0
  90. && !reverseEngineerOnlyTableObjects) {
  91. // Get Views
  92. revEng.reverseEngineerViews(conn, catalog, schema);
  93. // Get SPs
  94. if (revEng.reverseEngineerProcedures(conn, catalog, schema) == 0) {
  95. // Get Sequences
  96. revEng.reverseEngineerSequences(conn, catalog, schema);
  97. }
  98. }
  99. }
  100. // make sure the Fks use real references instead of
  101. // text names where possible
  102. revEng.reverseEngineerUpdateFkReferences(catalog);
  103. return catalog;
  104. }
  105. protected void buildSimpleDatatypes(
  106. com.mysql.grt.db.mgmt.Connection dbConn, Catalog catalog) {
  107. com.mysql.grt.db.mgmt.Driver driver = dbConn.getDriver();
  108. com.mysql.grt.db.mgmt.Rdbms rdbms = (com.mysql.grt.db.mgmt.Rdbms) driver
  109. .getOwner();
  110. com.mysql.grt.db.SimpleDatatypeList rdbmsDatatypeList = rdbms
  111. .getSimpleDatatypes();
  112. com.mysql.grt.db.SimpleDatatypeList catalogDatatypeList = new com.mysql.grt.db.SimpleDatatypeList();
  113. for (int i = 0; i < rdbmsDatatypeList.size(); i++) {
  114. catalogDatatypeList.add(rdbmsDatatypeList.get(i));
  115. }
  116. catalog.setSimpleDatatypes(catalogDatatypeList);
  117. }
  118. private static String tableCountSelect = "SELECT COUNT(*) AS TABLECOUNT FROM ALL_TABLES t, ALL_OBJECTS a "
  119. + "WHERE t.OWNER=? AND a.OWNER=t.OWNER AND a.OBJECT_NAME=t.TABLE_NAME AND "
  120. + " a.OBJECT_TYPE='TABLE' AND a.STATUS='VALID' ";
  121. private static String tableSelect = "SELECT t.* FROM ALL_TABLES t, ALL_OBJECTS a "
  122. + "WHERE t.OWNER=? AND a.OWNER=t.OWNER AND a.OBJECT_NAME=t.TABLE_NAME AND "
  123. + " a.OBJECT_TYPE='TABLE' AND a.STATUS='VALID' "
  124. + "ORDER BY t.OWNER, t.TABLE_NAME";
  125. protected int reverseEngineerTables(Connection conn, Catalog catalog,
  126. Schema schema) throws Exception {
  127. int tableCount = 0;
  128. int currentTableNumber = 0;
  129. Grt.getInstance().addMsg(
  130. "Fetch the number of tables in the schema " + schema.getName()
  131. + ".");
  132. Grt.getInstance().addMsgDetail(tableCountSelect);
  133. PreparedStatement stmt = conn.prepareStatement(tableCountSelect);
  134. stmt.setString(1, schema.getName());
  135. ResultSet tblRset = stmt.executeQuery();
  136. if (tblRset.next()) {
  137. tableCount = tblRset.getInt("TABLECOUNT");
  138. }
  139. stmt.close();
  140. Grt.getInstance().addMsg(
  141. "Fetching " + tableCount + " table(s) of the schema "
  142. + schema.getName() + ".");
  143. Grt.getInstance().addMsgDetail(tableSelect);
  144. Grt.getInstance().flushMessages();
  145. stmt = conn.prepareStatement(tableSelect);
  146. stmt.setString(1, schema.getName());
  147. tblRset = stmt.executeQuery();
  148. while (tblRset.next()) {
  149. // Create new table
  150. Table table = new Table(schema);
  151. schema.getTables().add(table);
  152. currentTableNumber++;
  153. table.setName(tblRset.getString("TABLE_NAME"));
  154. Grt.getInstance().addProgress(
  155. "Processing table " + table.getName() + ".",
  156. (currentTableNumber * 100) / tableCount);
  157. if (Grt.getInstance().flushMessages() != 0) {
  158. Grt.getInstance().addMsg("Migration canceled by user.");
  159. return 1;
  160. }
  161. try {
  162. table.setTablespaceName(tblRset.getString("TABLESPACE_NAME"));
  163. table.setClusterName(tblRset.getString("CLUSTER_NAME"));
  164. table.setPctFreeBlockSpace(tblRset.getInt("PCT_FREE"));
  165. table.setPctUsedBlockSpace(tblRset.getInt("PCT_USED"));
  166. table.setInitialTrans(tblRset.getInt("INI_TRANS"));
  167. table.setMaxTrans(tblRset.getInt("MAX_TRANS"));
  168. table.setInitialExtent(tblRset.getInt("INITIAL_EXTENT"));
  169. table.setNextExtent(tblRset.getInt("NEXT_EXTENT"));
  170. table.setMinExtents(tblRset.getInt("MIN_EXTENTS"));
  171. table.setMaxExtents(tblRset.getInt("MAX_EXTENTS"));
  172. table.setPctIncrease(tblRset.getInt("PCT_INCREASE"));
  173. } catch (Throwable t) {
  174. // ignore exceptions because this is non-essential data
  175. }
  176. try {
  177. table.setNumRows(tblRset.getInt("NUM_ROWS"));
  178. table.setBlocks(tblRset.getInt("BLOCKS"));
  179. table.setEmptyBlocks(tblRset.getInt("EMPTY_BLOCKS"));
  180. table.setAvgSpace(tblRset.getInt("AVG_SPACE"));
  181. table.setAvgRowLen(tblRset.getInt("AVG_ROW_LEN"));
  182. } catch (Throwable t) {
  183. // ignore exceptions because this is non-essential data
  184. }
  185. if (tblRset.getString("NESTED").compareToIgnoreCase("yes") == 0) {
  186. table.setIsNestedTable(1);
  187. } else {
  188. table.setIsNestedTable(0);
  189. }
  190. }
  191. Grt.getInstance().addProgress("", -1);
  192. Grt.getInstance().flushMessages();
  193. Grt.getInstance().addMsg("Fetch column information.");
  194. Grt.getInstance().flushMessages();
  195. reverseEngineerTableColumns(conn, catalog, schema);
  196. Grt.getInstance().addMsg("Fetch PK information.");
  197. Grt.getInstance().flushMessages();
  198. reverseEngineerTablePK(conn, catalog, schema);
  199. Grt.getInstance().addMsg("Fetch index information.");
  200. Grt.getInstance().flushMessages();
  201. reverseEngineerTableIndices(conn, catalog, schema);
  202. Grt.getInstance().addMsg("Fetch FK information.");
  203. Grt.getInstance().flushMessages();
  204. reverseEngineerTableFKs(conn, catalog, schema);
  205. Grt.getInstance().addMsg("Fetch trigger information.");
  206. Grt.getInstance().flushMessages();
  207. reverseEngineerTableTriggers(conn, catalog, schema);
  208. Grt.getInstance().addProgress("", -1);
  209. Grt.getInstance().flushMessages();
  210. stmt.close();
  211. return 0;
  212. }
  213. private static String tableColumnsSelect8 = "SELECT tc.TABLE_NAME, tc.COLUMN_NAME, "
  214. + " tc.DATA_TYPE, tc.DATA_TYPE_MOD, tc.DATA_LENGTH, tc.DATA_PRECISION, "
  215. + " tc.DATA_SCALE, tc.NULLABLE, tc.DEFAULT_LENGTH, tc.DENSITY, "
  216. + " tc.NUM_NULLS, tc.NUM_BUCKETS, tc.CHARACTER_SET_NAME, tc.DATA_DEFAULT "
  217. + "FROM ALL_TAB_COLUMNS tc, ALL_TABLES t "
  218. + "WHERE tc.OWNER=? AND t.OWNER=tc.OWNER AND tc.TABLE_NAME=t.TABLE_NAME "
  219. + "ORDER BY tc.TABLE_NAME, tc.COLUMN_ID";
  220. private static String tableColumnsSelect9 = "SELECT tc.TABLE_NAME, tc.COLUMN_NAME, "
  221. + " tc.DATA_TYPE, tc.DATA_TYPE_MOD, tc.CHAR_LENGTH, tc.DATA_LENGTH, "
  222. + " tc.DATA_PRECISION, tc.DATA_SCALE, tc.NULLABLE, tc.DEFAULT_LENGTH, "
  223. + " tc.DENSITY, tc.NUM_NULLS, tc.NUM_BUCKETS, tc.CHARACTER_SET_NAME, "
  224. + " tc.DATA_DEFAULT "
  225. + "FROM ALL_TAB_COLUMNS tc, ALL_TABLES t "
  226. + "WHERE tc.OWNER=? AND t.OWNER=tc.OWNER AND tc.TABLE_NAME=t.TABLE_NAME "
  227. + "ORDER BY tc.TABLE_NAME, tc.COLUMN_ID";
  228. protected void reverseEngineerTableColumns(Connection conn,
  229. Catalog catalog, Schema schema) {
  230. try {
  231. if (schema.getTables().size() < 1)
  232. return;
  233. // get first table
  234. int tableIndex = 0;
  235. Table table = (Table) schema.getTables().get(tableIndex);
  236. String sql;
  237. if (catalog.getVersion().getMajor() <= 8)
  238. sql = tableColumnsSelect8;
  239. else
  240. sql = tableColumnsSelect9;
  241. Grt.getInstance().addMsg("Fetching column information.");
  242. Grt.getInstance().addMsgDetail(sql);
  243. PreparedStatement stmt = conn.prepareStatement(sql);
  244. stmt.setString(1, schema.getName());
  245. ResultSet colRset = stmt.executeQuery();
  246. while (colRset.next()) {
  247. String tableName = colRset.getString("TABLE_NAME");
  248. // if the table name has changed, go to next matching table
  249. while (!tableName.equals(table.getName())) {
  250. table = (Table) schema.getTables().get(++tableIndex);
  251. }
  252. // create new column
  253. Column column = new Column(table);
  254. table.getColumns().add(column);
  255. column.setName(colRset.getString("COLUMN_NAME"));
  256. column.setDatatypeName(colRset.getString("DATA_TYPE"));
  257. column.setDatatypeModifier(colRset.getString("DATA_TYPE_MOD"));
  258. // Get Simple Type
  259. int datatypeIndex = catalog.getSimpleDatatypes()
  260. .getIndexOfName(column.getDatatypeName());
  261. if (datatypeIndex > -1) {
  262. column.setSimpleType(catalog.getSimpleDatatypes().get(
  263. datatypeIndex));
  264. } else {
  265. column.setSimpleType(catalog.getSimpleDatatypes().get(
  266. catalog.getSimpleDatatypes().getIndexOfName(
  267. "VARCHAR2")));
  268. column.setLength(255);
  269. Grt.getInstance().addMsg(
  270. "WARNING: The datatype " + column.getDatatypeName()
  271. + " was not been defined yet.");
  272. }
  273. if (column.getDatatypeName().equalsIgnoreCase("VARCHAR2")
  274. || column.getDatatypeName().equalsIgnoreCase(
  275. "NVARCHAR2")
  276. || column.getDatatypeName().equalsIgnoreCase("CHAR")
  277. || column.getDatatypeName().equalsIgnoreCase("NCHAR")
  278. || column.getDatatypeName().equalsIgnoreCase("LONG")) {
  279. try {
  280. // in Oracle 9i there is CHAR_LENGTH
  281. if (catalog.getVersion().getMajor() >= 9)
  282. column.setLength(colRset.getInt("CHAR_LENGTH"));
  283. else
  284. column.setLength(colRset.getInt("DATA_LENGTH"));
  285. } catch (Exception e) {
  286. column.setLength(colRset.getInt("DATA_LENGTH"));
  287. }
  288. } else
  289. column.setLength(colRset.getInt("DATA_LENGTH"));
  290. column.setPrecision(colRset.getInt("DATA_PRECISION"));
  291. if (colRset.wasNull())
  292. column.setPrecision(22);
  293. column.setScale(colRset.getInt("DATA_SCALE"));
  294. // Nullable
  295. if (colRset.getString("NULLABLE").compareToIgnoreCase("Y") == 0) {
  296. column.setIsNullable(1);
  297. } else {
  298. column.setIsNullable(0);
  299. }
  300. // Default Value Length
  301. column.setDefaultLength(colRset.getInt("DEFAULT_LENGTH"));
  302. // Density
  303. column.setDensity(colRset.getDouble("DENSITY"));
  304. // Number of Nulls in column
  305. column.setNumberOfNulls(colRset.getInt("NUM_NULLS"));
  306. // Number of Buckets in histogram for the column
  307. column.setNumberOfBuckets(colRset.getInt("NUM_BUCKETS"));
  308. // Character set: CHAR_CS or NCHAR_CS
  309. column.setCharacterSetName(colRset
  310. .getString("CHARACTER_SET_NAME"));
  311. // Default Value
  312. String defaultValue = colRset.getString("DATA_DEFAULT");
  313. if (defaultValue != null && !defaultValue.equals("")) {
  314. // remove () from numeric types
  315. if (column.getSimpleType().getGroup().getName().equals(
  316. "numeric")
  317. && defaultValue.startsWith("(")
  318. && defaultValue.endsWith(")")) {
  319. defaultValue = defaultValue.substring(1, defaultValue
  320. .length() - 1);
  321. }
  322. // ignore Oracle specific functions
  323. if ((!defaultValue.equalsIgnoreCase("USER"))
  324. && (!defaultValue.equalsIgnoreCase("SYSDATE"))
  325. && (!defaultValue.equalsIgnoreCase("sys_guid()")))
  326. column.setDefaultValue(defaultValue.trim());
  327. }
  328. }
  329. stmt.close();
  330. } catch (Exception e) {
  331. Grt.getInstance().addErr(e.getMessage());
  332. }
  333. }
  334. private static String tablePKSelect8 = "SELECT c.TABLE_NAME, i.COLUMN_NAME "
  335. + "FROM ALL_CONSTRAINTS c, ALL_TABLES t, ALL_IND_COLUMNS i "
  336. + "WHERE c.OWNER=? AND t.OWNER=c.OWNER AND c.TABLE_NAME=t.TABLE_NAME AND "
  337. + " c.CONSTRAINT_TYPE='P' AND c.CONSTRAINT_NAME=i.INDEX_NAME AND "
  338. + " i.TABLE_OWNER=c.OWNER AND i.TABLE_NAME=c.TABLE_NAME "
  339. + "ORDER BY c.TABLE_NAME, i.COLUMN_POSITION";
  340. private static String tablePKSelect9 = "SELECT c.TABLE_NAME, i.COLUMN_NAME "
  341. + "FROM ALL_CONSTRAINTS c, ALL_TABLES t, ALL_IND_COLUMNS i "
  342. + "WHERE c.OWNER=? AND t.OWNER=c.OWNER AND c.TABLE_NAME=t.TABLE_NAME AND "
  343. + " c.CONSTRAINT_TYPE='P' AND c.INDEX_NAME=i.INDEX_NAME AND "
  344. + " i.TABLE_OWNER=c.OWNER AND i.TABLE_NAME=c.TABLE_NAME "
  345. + "ORDER BY c.TABLE_NAME, i.COLUMN_POSITION";
  346. protected void reverseEngineerTablePK(Connection conn, Catalog catalog,
  347. Schema schema) {
  348. try {
  349. if (schema.getTables().size() < 1)
  350. return;
  351. // get first table
  352. int tableIndex = 0;
  353. Table table = (Table) schema.getTables().get(tableIndex);
  354. String sql;
  355. if (catalog.getVersion().getMajor() <= 8)
  356. sql = tablePKSelect8;
  357. else
  358. sql = tablePKSelect9;
  359. Grt.getInstance().addMsg("Fetching primary key information.");
  360. Grt.getInstance().addMsgDetail(sql);
  361. PreparedStatement stmt = conn.prepareStatement(sql);
  362. stmt.setString(1, schema.getName());
  363. ResultSet colRset = stmt.executeQuery();
  364. Index primaryKey = null;
  365. while (colRset.next()) {
  366. String tableName = colRset.getString("TABLE_NAME");
  367. // if the table name has changed, go to next matching table
  368. while (!tableName.equals(table.getName())) {
  369. table = (Table) schema.getTables().get(++tableIndex);
  370. primaryKey = null;
  371. }
  372. if (primaryKey == null) {
  373. primaryKey = new Index(table);
  374. primaryKey.setName("PRIMARY");
  375. primaryKey.setIsPrimary(1);
  376. table.getIndices().add(primaryKey);
  377. table.setPrimaryKey(primaryKey);
  378. }
  379. String indexColumnName = colRset.getString("COLUMN_NAME");
  380. int index = table.getColumns().getIndexOfName(indexColumnName);
  381. if (index > -1) {
  382. // create new index column
  383. IndexColumn indexColumn = new IndexColumn(primaryKey);
  384. indexColumn.setName(indexColumnName);
  385. // find reference table column
  386. for (int j = 0; j < table.getColumns().size(); j++) {
  387. Column column = (Column) (table.getColumns().get(j));
  388. if (column.getName().compareToIgnoreCase(
  389. indexColumn.getName()) == 0) {
  390. indexColumn.setReferedColumn(column);
  391. break;
  392. }
  393. }
  394. primaryKey.getColumns().add(indexColumn);
  395. }
  396. }
  397. stmt.close();
  398. } catch (Exception e) {
  399. Grt.getInstance().addErr(e.getMessage());
  400. }
  401. }
  402. private static String tableIndexSelect = "SELECT i.*, "
  403. + " ic.COLUMN_NAME, ic.COLUMN_LENGTH, ic.DESCEND "
  404. + "FROM ALL_INDEXES i, ALL_IND_COLUMNS ic, ALL_CONSTRAINTS c, ALL_TABLES t "
  405. + "WHERE i.TABLE_OWNER=? AND t.OWNER=i.OWNER AND i.TABLE_NAME=t.TABLE_NAME AND "
  406. + " ic.TABLE_OWNER=i.TABLE_OWNER AND "
  407. + " ic.TABLE_NAME=i.TABLE_NAME AND "
  408. + " ic.INDEX_NAME=i.INDEX_NAME AND c.OWNER(+)=i.OWNER AND "
  409. + " c.CONSTRAINT_NAME(+)=i.INDEX_NAME AND "
  410. + " (c.CONSTRAINT_TYPE is null OR c.CONSTRAINT_TYPE<>'P') "
  411. + "ORDER BY i.TABLE_NAME, ic.INDEX_NAME, ic.COLUMN_POSITION";
  412. private static String tableIndexColNameLookup = "SELECT DEFAULT$ AS COLUMN_NAME "
  413. + "FROM SYS.COL$ "
  414. + "WHERE NAME=? AND OBJ# in "
  415. + "  (SELECT OBJECT_ID FROM ALL_OBJECTS "
  416. + "  WHERE OWNER=? AND OBJECT_NAME=?)";
  417. protected void reverseEngineerTableIndices(Connection conn,
  418. Catalog catalog, Schema schema) {
  419. try {
  420. if (schema.getTables().size() < 1)
  421. return;
  422. // get first table
  423. int tableIndex = 0;
  424. Table table = (Table) schema.getTables().get(tableIndex);
  425. Grt.getInstance().addMsg("Fetching indices information.");
  426. Grt.getInstance().addMsgDetail(tableIndexSelect);
  427. PreparedStatement stmt = conn.prepareStatement(tableIndexSelect);
  428. stmt.setString(1, schema.getName());
  429. ResultSet rset = stmt.executeQuery();
  430. String indexName = "";
  431. // String indexOwner = "";
  432. Index index = null;
  433. while (rset.next()) {
  434. String tableName = rset.getString("TABLE_NAME");
  435. // if the table name has changed, go to next matching table
  436. while (!tableName.equals(table.getName())) {
  437. if (index != null)
  438. table.getIndices().add(index);
  439. table = (Table) schema.getTables().get(++tableIndex);
  440. indexName = "";
  441. index = null;
  442. }
  443. // String newIndexOwner = rset.getString("OWNER");
  444. String newIndexName = rset.getString("INDEX_NAME");
  445. /* && (indexOwner.compareToIgnoreCase(newIndexOwner) != 0) */
  446. if (indexName.compareToIgnoreCase(newIndexName) != 0) {
  447. if (index != null)
  448. table.getIndices().add(index);
  449. index = new Index(table);
  450. index.setName(newIndexName);
  451. indexName = newIndexName;
  452. index.setIndexType(rset.getString("INDEX_TYPE"));
  453. if (rset.getString("UNIQUENESS").compareToIgnoreCase(
  454. "UNIQUE") == 0)
  455. index.setUnique(1);
  456. else
  457. index.setUnique(0);
  458. index.setDeferability(0);
  459. if (rset.getString("COMPRESSION").compareToIgnoreCase(
  460. "ENABLED") == 0)
  461. index.setCompression(1);
  462. else
  463. index.setCompression(0);
  464. index.setPrefixLength(rset.getInt("PREFIX_LENGTH"));
  465. index.setTablespace(rset.getString("TABLESPACE_NAME"));
  466. index.setInitialTrans(rset.getInt("INI_TRANS"));
  467. index.setMaxTrans(rset.getInt("MAX_TRANS"));
  468. index.setInitialExtent(rset.getInt("INITIAL_EXTENT"));
  469. index.setNextExtent(rset.getInt("NEXT_EXTENT"));
  470. index.setMinExtents(rset.getInt("MIN_EXTENTS"));
  471. index.setMaxExtents(rset.getInt("MAX_EXTENTS"));
  472. index.setPctIncrease(rset.getInt("PCT_INCREASE"));
  473. index.setPctTreshold(rset.getInt("PCT_THRESHOLD"));
  474. index.setBlevel(rset.getInt("BLEVEL"));
  475. index.setLeafBlocks(rset.getInt("LEAF_BLOCKS"));
  476. index.setDistinctKeys(rset.getInt("DISTINCT_KEYS"));
  477. index.setAvgLeafBlocksPerKey(rset
  478. .getInt("AVG_LEAF_BLOCKS_PER_KEY"));
  479. index.setAvgDataBlocksPerKey(rset
  480. .getInt("AVG_DATA_BLOCKS_PER_KEY"));
  481. index.setClusteringFactor(rset.getInt("CLUSTERING_FACTOR"));
  482. index.setNumRows(rset.getInt("NUM_ROWS"));
  483. if (rset.getString("GENERATED").compareToIgnoreCase("Y") == 0)
  484. index.setGenerated(1);
  485. else
  486. index.setGenerated(0);
  487. }
  488. String indexColumnName = rset.getString("COLUMN_NAME");
  489. boolean indexColumnDefined = false;
  490. try {
  491. // resolve column names for functional indices
  492. if (indexColumnName.startsWith("SYS_")) {
  493. Grt.getInstance().addMsg("Lookup index column names.");
  494. Grt.getInstance().addMsgDetail(tableIndexColNameLookup);
  495. PreparedStatement colNameStmt = conn
  496. .prepareStatement(tableIndexColNameLookup);
  497. colNameStmt.setString(1, indexColumnName);
  498. colNameStmt.setString(2, schema.getName());
  499. colNameStmt.setString(3, table.getName());
  500. try {
  501. ResultSet colNameRset = colNameStmt.executeQuery();
  502. if (colNameRset.next()) {
  503. indexColumnName = colNameRset.getString(
  504. "COLUMN_NAME").substring(1);
  505. indexColumnName = indexColumnName.substring(0,
  506. indexColumnName.length() - 1);
  507. }
  508. } finally {
  509. colNameStmt.close();
  510. }
  511. }
  512. } catch (Exception e) {
  513. Grt.getInstance().addErr(e.getMessage());
  514. return;
  515. }
  516. // check if an index column with this name has already been
  517. // added t(functional indices)
  518. for (int i = 0; i < index.getColumns().size(); i++) {
  519. if (index.getColumns().get(i).getName().equalsIgnoreCase(
  520. indexColumnName)) {
  521. indexColumnDefined = true;
  522. break;
  523. }
  524. }
  525. if (indexColumnDefined)
  526. continue;
  527. // create new index column
  528. IndexColumn indexColumn = new IndexColumn(index);
  529. indexColumn.setName(indexColumnName);
  530. indexColumn.setColumnLength(rset.getInt("COLUMN_LENGTH"));
  531. if (rset.getString("DESCEND").compareToIgnoreCase("Y") == 0)
  532. indexColumn.setDescend(1);
  533. else
  534. indexColumn.setDescend(0);
  535. // find reference table column
  536. for (int j = 0; j < table.getColumns().size(); j++) {
  537. Column column = (Column) (table.getColumns().get(j));
  538. if (column.getName().compareToIgnoreCase(
  539. indexColumn.getName()) == 0) {
  540. indexColumn.setReferedColumn(column);
  541. break;
  542. }
  543. }
  544. index.getColumns().add(indexColumn);
  545. }
  546. if (index != null)
  547. table.getIndices().add(index);
  548. stmt.close();
  549. } catch (Exception e) {
  550. Grt.getInstance().addErr(e.getMessage());
  551. }
  552. }
  553. private static String tableFKSelect = "SELECT c.TABLE_NAME, c.CONSTRAINT_NAME, "
  554. + "c."DEFERRABLE", c.DELETE_RULE, cc.COLUMN_NAME, "
  555. + "r.OWNER AS R_SCHEMA, r.TABLE_NAME AS R_TABLE, "
  556. + "rc.COLUMN_NAME AS R_COLUMN "
  557. + "FROM ALL_CONSTRAINTS c, ALL_CONS_COLUMNS cc, ALL_CONSTRAINTS r, "
  558. + "ALL_CONS_COLUMNS rc WHERE c.OWNER=? AND "
  559. + "c.CONSTRAINT_TYPE = 'R' AND c.R_OWNER=r.OWNER AND "
  560. + "c.R_CONSTRAINT_NAME=r.CONSTRAINT_NAME AND "
  561. + "c.CONSTRAINT_NAME = cc.CONSTRAINT_NAME AND c.OWNER = cc.OWNER AND "
  562. + "r.CONSTRAINT_NAME = rc.CONSTRAINT_NAME AND r.OWNER = rc.OWNER AND "
  563. + "cc.POSITION = rc.POSITION ORDER BY c.TABLE_NAME, c.CONSTRAINT_NAME, cc.POSITION";
  564. protected void reverseEngineerTableFKs(Connection conn, Catalog catalog,
  565. Schema schema) {
  566. try {
  567. if (schema.getTables().size() < 1)
  568. return;
  569. // get first table
  570. int tableIndex = 0;
  571. Table table = (Table) schema.getTables().get(tableIndex);
  572. Grt.getInstance().addMsg("Fetching FK information.");
  573. Grt.getInstance().addMsgDetail(tableFKSelect);
  574. PreparedStatement stmt = conn.prepareStatement(tableFKSelect);
  575. stmt.setString(1, schema.getName());
  576. ResultSet rset = stmt.executeQuery();
  577. String fkName = "";
  578. ForeignKey foreignKey = null;
  579. while (rset.next()) {
  580. String tableName = rset.getString("TABLE_NAME");
  581. // if the table name has changed, go to next matching table
  582. while (!tableName.equals(table.getName())) {
  583. if (foreignKey != null)
  584. table.getForeignKeys().add(foreignKey);
  585. table = (Table) schema.getTables().get(++tableIndex);
  586. fkName = "";
  587. foreignKey = null;
  588. }
  589. String newFkName = rset.getString("CONSTRAINT_NAME");
  590. if (fkName.compareToIgnoreCase(newFkName) != 0) {
  591. if (foreignKey != null)
  592. table.getForeignKeys().add(foreignKey);
  593. fkName = newFkName;
  594. foreignKey = new ForeignKey(table);
  595. foreignKey.setName(newFkName);
  596. if (rset.getString("DEFERRABLE").equals("NOT DEFERRABLE"))
  597. foreignKey.setDeferability(0);
  598. else
  599. foreignKey.setDeferability(1);
  600. foreignKey.setDeleteRule(rset.getString("DELETE_RULE"));
  601. foreignKey.setUpdateRule("NO ACTION");
  602. foreignKey.setReferedTableSchemaName(rset
  603. .getString("R_SCHEMA"));
  604. foreignKey.setReferedTableName(rset.getString("R_TABLE"));
  605. }
  606. foreignKey.getReferedColumnNames().add(
  607. rset.getString("R_COLUMN"));
  608. // find reference table column
  609. String colName = rset.getString("COLUMN_NAME");
  610. for (int j = 0; j < table.getColumns().size(); j++) {
  611. Column column = (Column) (table.getColumns().get(j));
  612. if (column.getName().compareToIgnoreCase(colName) == 0)
  613. foreignKey.getColumns().add(column);
  614. }
  615. }
  616. if (foreignKey != null)
  617. table.getForeignKeys().add(foreignKey);
  618. stmt.close();
  619. } catch (Exception e) {
  620. Grt.getInstance().addErr(e.getMessage());
  621. }
  622. }
  623. private static String tableTriggerSelect = "SELECT t.TABLE_NAME, t.TRIGGER_NAME, "
  624. + "t.TRIGGER_TYPE, t.TRIGGERING_EVENT, t.BASE_OBJECT_TYPE, "
  625. + "t.COLUMN_NAME, t.REFERENCING_NAMES, t.WHEN_CLAUSE, "
  626. + "t.STATUS, t.DESCRIPTION, t.ACTION_TYPE, t.TRIGGER_BODY "
  627. + "FROM ALL_TRIGGERS t, ALL_TABLES ta "
  628. + "WHERE t.TABLE_OWNER=? AND ta.OWNER=t.OWNER AND t.TABLE_NAME=ta.TABLE_NAME "
  629. + "ORDER BY t.TABLE_NAME";
  630. protected void reverseEngineerTableTriggers(Connection conn,
  631. Catalog catalog, Schema schema) {
  632. try {
  633. if (schema.getTables().size() < 1)
  634. return;
  635. // get first table
  636. int tableIndex = 0;
  637. Table table = (Table) schema.getTables().get(tableIndex);
  638. Grt.getInstance().addMsg("Fetching FK information.");
  639. Grt.getInstance().addMsgDetail(tableTriggerSelect);
  640. PreparedStatement stmt = conn.prepareStatement(tableTriggerSelect);
  641. stmt.setString(1, schema.getName());
  642. ResultSet rset = stmt.executeQuery();
  643. while (rset.next()) {
  644. String tableName = rset.getString("TABLE_NAME");
  645. // if the table name has changed, go to next matching table
  646. while (!tableName.equals(table.getName())) {
  647. table = (Table) schema.getTables().get(++tableIndex);
  648. }
  649. Trigger trigger = new Trigger(table);
  650. trigger.setName(rset.getString("TRIGGER_NAME"));
  651. trigger.setOldName(trigger.getName());
  652. trigger.setComment(rset.getString("DESCRIPTION"));
  653. trigger.setEvent(rset.getString("TRIGGERING_EVENT"));
  654. trigger.setCondition(rset.getString("WHEN_CLAUSE"));
  655. trigger.setStatement(rset.getString("TRIGGER_BODY"));
  656. trigger.setOrder(0);
  657. String s = rset.getString("TRIGGER_TYPE");
  658. if (s.toUpperCase().startsWith("BEFORE"))
  659. trigger.setTiming("BEFORE");
  660. else
  661. trigger.setTiming("AFTER");
  662. if (s.toUpperCase().endsWith("STATEMENT"))
  663. trigger.setOrientation("STATEMENT");
  664. else if (s.toUpperCase().endsWith("ROW"))
  665. trigger.setOrientation("ROW");
  666. else if (s.toUpperCase().endsWith("EVENT"))
  667. trigger.setOrientation("EVENT");
  668. trigger.setReferenceNewRow(rset.getString("REFERENCING_NAMES"));
  669. if (rset.getString("STATUS").equalsIgnoreCase("ENABLED"))
  670. trigger.setEnabled(1);
  671. else
  672. trigger.setEnabled(0);
  673. table.getTriggers().add(trigger);
  674. }
  675. stmt.close();
  676. } catch (Exception e) {
  677. Grt.getInstance().addErr(e.getMessage());
  678. }
  679. }
  680. private static String viewSelect = "SELECT v.*, c.STATUS as CHECK_ENABLED "
  681. + "FROM ALL_VIEWS v, ALL_CONSTRAINTS c, ALL_OBJECTS a WHERE v.OWNER=? AND "
  682. + "  c.TABLE_NAME(+)=v.VIEW_NAME AND c.CONSTRAINT_TYPE(+)='V' AND "
  683. + "  a.OWNER=v.OWNER AND a.OBJECT_NAME=v.VIEW_NAME AND "
  684. + "  a.OBJECT_TYPE='VIEW' AND a.STATUS='VALID' "
  685. + "ORDER BY v.OWNER, v.VIEW_NAME";
  686. protected void reverseEngineerViews(Connection conn, Catalog catalog,
  687. Schema schema) throws Exception {
  688. Grt.getInstance().addMsg(
  689. "Fetch all views of the schema " + schema.getName() + ".");
  690. Grt.getInstance().addMsgDetail(viewSelect);
  691. Grt.getInstance().flushMessages();
  692. PreparedStatement stmt = conn.prepareStatement(viewSelect);
  693. stmt.setString(1, schema.getName());
  694. ResultSet rset = stmt.executeQuery();
  695. while (rset.next()) {
  696. // Create new view
  697. View view = new View(schema);
  698. schema.getViews().add(view);
  699. view.setName(rset.getString("VIEW_NAME"));
  700. Grt.getInstance().addMsg("Processing view " + view.getName() + ".");
  701. view.setQueryExpression(rset.getString("TEXT"));
  702. try {
  703. view.setTypedText(rset.getString("TYPE_TEXT"));
  704. view.setOidText(rset.getString("OID_TEXT"));
  705. view.setViewTypeOwner(rset.getString("VIEW_TYPE_OWNER"));
  706. view.setViewType(rset.getString("VIEW_TYPE"));
  707. view.setSuperViewName(rset.getString("SUPERVIEW_NAME"));
  708. } catch (Exception e) {
  709. // ignore missing fields in Oracle 8
  710. }
  711. if (rset.getString("CHECK_ENABLED") != null)
  712. view.setWithCheckCondition(1);
  713. else
  714. view.setWithCheckCondition(0);
  715. }
  716. stmt.close();
  717. reverseEngineerViewColumns(conn, catalog, schema);
  718. Grt.getInstance().addMsg("Views fetched.");
  719. }
  720. private static String viewColumnsSelect = "SELECT tc.TABLE_NAME, tc.COLUMN_NAME "
  721. + "FROM ALL_TAB_COLUMNS tc, ALL_VIEWS v "
  722. + "WHERE tc.OWNER=? AND v.OWNER=tc.OWNER AND tc.TABLE_NAME=v.VIEW_NAME "
  723. + "ORDER BY tc.TABLE_NAME, tc.COLUMN_ID";
  724. protected void reverseEngineerViewColumns(Connection conn, Catalog catalog,
  725. Schema schema) {
  726. try {
  727. if (schema.getTables().size() < 1)
  728. return;
  729. // get first view
  730. int viewIndex = 0;
  731. View view = (View) schema.getViews().get(viewIndex);
  732. Grt.getInstance().addMsg("Fetching column information.");
  733. Grt.getInstance().addMsgDetail(viewColumnsSelect);
  734. PreparedStatement stmt = conn.prepareStatement(viewColumnsSelect);
  735. stmt.setString(1, schema.getName());
  736. ResultSet colRset = stmt.executeQuery();
  737. while (colRset.next()) {
  738. String tableName = colRset.getString("TABLE_NAME");
  739. // if the table name has changed, go to next matching table
  740. while (!tableName.equals(view.getName())) {
  741. view = (View) schema.getViews().get(++viewIndex);
  742. }
  743. // create new column
  744. view.getColumns().add(colRset.getString("COLUMN_NAME"));
  745. }
  746. stmt.close();
  747. } catch (Exception e) {
  748. Grt.getInstance().addErr(e.getMessage());
  749. }
  750. }
  751. private static String procedureCountSelect = "SELECT COUNT(*) AS NUM "
  752. + "FROM ALL_PROCEDURES p, ALL_OBJECTS a WHERE p.OWNER=? AND "
  753. + "  a.OWNER=p.OWNER AND a.OBJECT_NAME=p.OBJECT_NAME AND "
  754. + "  (a.OBJECT_TYPE='PROCEDURE' OR a.OBJECT_TYPE='FUNCTION') AND a.STATUS='VALID' "
  755. + "ORDER BY p.OBJECT_NAME";
  756. private static String procedureSelect = "SELECT p.*, "
  757. + "(SELECT max(s.TYPE) FROM ALL_SOURCE s "
  758. + " WHERE s.OWNER=? AND s.NAME=p.OBJECT_NAME) as TYPE "
  759. + "FROM ALL_PROCEDURES p, ALL_OBJECTS a WHERE p.OWNER=? AND "
  760. + "  a.OWNER=p.OWNER AND a.OBJECT_NAME=p.OBJECT_NAME AND "
  761. + "  (a.OBJECT_TYPE='PROCEDURE' OR a.OBJECT_TYPE='FUNCTION') AND a.STATUS='VALID' "
  762. + "ORDER BY p.OBJECT_NAME";
  763. private static String procedureCodeSelect = "SELECT TEXT "
  764. + "FROM ALL_SOURCE WHERE OWNER=? AND NAME=? " + "ORDER BY LINE";
  765. protected int reverseEngineerProcedures(Connection conn, Catalog catalog,
  766. Schema schema) throws Exception {
  767. int spCount = 0;
  768. int currentSpNumber = 0;
  769. Grt.getInstance().addMsg(
  770. "Fetch count of stored procedures of the schema "
  771. + schema.getName() + ".");
  772. Grt.getInstance().addMsgDetail(procedureCountSelect);
  773. try {
  774. PreparedStatement stmt = conn
  775. .prepareStatement(procedureCountSelect);
  776. stmt.setString(1, schema.getName());
  777. ResultSet rset = stmt.executeQuery();
  778. if (rset.next()) {
  779. spCount = rset.getInt("NUM");
  780. }
  781. Grt.getInstance().addMsg(
  782. "Fetching " + spCount
  783. + " stored procedure(s) of the schema "
  784. + schema.getName() + ".");
  785. Grt.getInstance().addMsgDetail(procedureSelect);
  786. Grt.getInstance().addMsgDetail(procedureCodeSelect);
  787. Grt.getInstance().flushMessages();
  788. stmt = conn.prepareStatement(procedureSelect);
  789. stmt.setString(1, schema.getName());
  790. stmt.setString(2, schema.getName());
  791. rset = stmt.executeQuery();
  792. while (rset.next()) {
  793. // Create new view
  794. Routine proc = new Routine(schema);
  795. schema.getRoutines().add(proc);
  796. proc.setName(rset.getString("OBJECT_NAME"));
  797. currentSpNumber++;
  798. Grt.getInstance().addProgress(
  799. "Processing procedure " + proc.getName() + ".",
  800. (currentSpNumber * 100) / spCount);
  801. if (Grt.getInstance().flushMessages() != 0) {
  802. Grt.getInstance().addMsg("Migration canceled by user.");
  803. return 1;
  804. }
  805. Grt.getInstance().addMsg(
  806. "Processing procedure " + proc.getName() + ".");
  807. proc.setRoutineType(rset.getString("TYPE"));
  808. proc.setImplTypeOwner(rset.getString("IMPLTYPEOWNER"));
  809. proc.setImplTypeName(rset.getString("IMPLTYPENAME"));
  810. if (rset.getString("AGGREGATE").equalsIgnoreCase("YES"))
  811. proc.setAggregate(1);
  812. else
  813. proc.setAggregate(0);
  814. if (rset.getString("PIPELINED").equalsIgnoreCase("YES"))
  815. proc.setPipelined(1);
  816. else
  817. proc.setPipelined(0);
  818. if (rset.getString("PARALLEL").equalsIgnoreCase("YES"))
  819. proc.setParallel(1);
  820. else
  821. proc.setParallel(0);
  822. PreparedStatement stmtCode = conn
  823. .prepareStatement(procedureCodeSelect);
  824. stmtCode.setString(1, schema.getName());
  825. stmtCode.setString(2, proc.getName());
  826. ResultSet rsetCode = stmtCode.executeQuery();
  827. StringBuffer code = new StringBuffer(1024);
  828. while (rsetCode.next()) {
  829. code.append(rsetCode.getString("TEXT"));
  830. }
  831. stmtCode.close();
  832. proc.setRoutineCode(code.toString());
  833. }
  834. stmt.close();
  835. Grt.getInstance().addMsg("Stored procedures fetched.");
  836. Grt.getInstance().addProgress("", -1);
  837. } catch (Exception e) {
  838. Grt.getInstance().addMsg("Stored procedures cannot be fetched.");
  839. Grt.getInstance().addMsgDetail(e.getMessage());
  840. }
  841. return 0;
  842. }
  843. private static String sequencesCountSelect = "SELECT COUNT(*) AS NUM "
  844. + "FROM ALL_SEQUENCES s, ALL_OBJECTS a WHERE s.SEQUENCE_OWNER=? AND "
  845. + "  a.OWNER=s.SEQUENCE_OWNER AND a.OBJECT_NAME=s.SEQUENCE_NAME AND "
  846. + "  a.OBJECT_TYPE='SEQUENCE' AND a.STATUS='VALID'";
  847. private static String sequencesSelect = "SELECT s.SEQUENCE_NAME, s.MIN_VALUE, "
  848. + " s.MAX_VALUE, s.INCREMENT_BY, s.CYCLE_FLAG, s.ORDER_FLAG, "
  849. + " s.CACHE_SIZE, s.LAST_NUMBER "
  850. + "FROM ALL_SEQUENCES s, ALL_OBJECTS a WHERE s.SEQUENCE_OWNER=? AND "
  851. + "  a.OWNER=s.SEQUENCE_OWNER AND a.OBJECT_NAME=s.SEQUENCE_NAME AND "
  852. + "  a.OBJECT_TYPE='SEQUENCE' AND a.STATUS='VALID' "
  853. + "ORDER BY s.SEQUENCE_NAME";
  854. protected void reverseEngineerSequences(Connection conn, Catalog catalog,
  855. Schema schema) throws Exception {
  856. // String sql;
  857. int sequencesCount = 0;
  858. int currentSequenceNumber = 0;
  859. Grt.getInstance().addMsg(
  860. "Fetch the number sequences of the schema " + schema.getName()
  861. + ".");
  862. Grt.getInstance().addMsgDetail(sequencesCountSelect);
  863. try {
  864. PreparedStatement stmt = conn
  865. .prepareStatement(sequencesCountSelect);
  866. stmt.setString(1, schema.getName());
  867. ResultSet rset = stmt.executeQuery();
  868. if (rset.next()) {
  869. sequencesCount = rset.getInt("NUM");
  870. }
  871. Grt.getInstance().addMsg(
  872. "Fetch " + sequencesCount + " sequence(s) of the schema "
  873. + schema.getName() + ".");
  874. Grt.getInstance().addMsgDetail(sequencesSelect);
  875. Grt.getInstance().flushMessages();
  876. stmt = conn.prepareStatement(sequencesSelect);
  877. stmt.setString(1, schema.getName());
  878. rset = stmt.executeQuery();
  879. while (rset.next()) {
  880. Sequence seq = new Sequence(schema);
  881. seq.setName(rset.getString("SEQUENCE_NAME"));
  882. currentSequenceNumber++;
  883. if (currentSequenceNumber % 5 == 0) {
  884. Grt.getInstance().addProgress(
  885. "Processing sequence " + seq.getName() + ".",
  886. (currentSequenceNumber * 100) / sequencesCount);
  887. Grt.getInstance().flushMessages();
  888. }
  889. seq.setMinValue(rset.getString("MIN_VALUE"));
  890. seq.setMaxValue(rset.getString("MAX_VALUE"));
  891. seq.setIncrementBy(rset.getString("INCREMENT_BY"));
  892. if (rset.getString("CYCLE_FLAG").compareToIgnoreCase("Y") == 0)
  893. seq.setCycleFlag(1);
  894. else
  895. seq.setCycleFlag(0);
  896. if (rset.getString("ORDER_FLAG").compareToIgnoreCase("Y") == 0)
  897. seq.setOrderFlag(1);
  898. else
  899. seq.setOrderFlag(0);
  900. seq.setCacheSize(rset.getString("CACHE_SIZE"));
  901. seq.setLastNumber(rset.getString("LAST_NUMBER"));
  902. schema.getSequences().add(seq);
  903. }
  904. stmt.close();
  905. Grt.getInstance().addMsg("Sequences fetched.");
  906. Grt.getInstance().addProgress("", -1);
  907. } catch (Exception e) {
  908. Grt.getInstance().addMsg("Sequences could not be fetched.");
  909. Grt.getInstance().addMsg(e.getMessage());
  910. }
  911. }
  912. }