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

MySQL数据库

开发平台:

SQL

  1. package com.mysql.grt.modules;
  2. import java.util.HashMap;
  3. import java.util.regex.Pattern;
  4. import java.util.List;
  5. import java.util.ArrayList;
  6. import com.mysql.grt.*;
  7. import com.mysql.grt.base.*;
  8. import com.mysql.grt.db.migration.*;
  9. /**
  10.  * GRT Migration Class
  11.  * 
  12.  * @author MikeZ
  13.  * @version 1.0, 01/23/05
  14.  * 
  15.  */
  16. public class MigrationUtils {
  17. private HashMap logObjects = new HashMap();
  18. private HashMap sourceTargetObjectMapping = new HashMap();
  19. private List ignoreList;
  20. protected final static int logNoText = 0;
  21. protected final static int logWarning = 1;
  22. protected final static int logError = 2;
  23.  
  24. /**
  25.  * Checks if an object is on the ignore list
  26.  * 
  27.  * @param mig
  28.  *            the migration object
  29.  * @param sourceObject
  30.  *            the object that should be migrated
  31.  * @return the migrated object
  32.  */
  33. public boolean isOnIgnoreList(com.mysql.grt.db.migration.Migration migObj,
  34. GrtObject sourceObject) {
  35. // only instances of DatabaseObject can be on the ignore list
  36. // if they are not a Schema
  37. if ((sourceObject instanceof com.mysql.grt.db.DatabaseObject)
  38. && !(sourceObject instanceof com.mysql.grt.db.Schema)) {
  39. // if the ignore list was not needed till now
  40. // build it
  41. if (ignoreList == null) {
  42. ignoreList = new ArrayList();
  43. for (int i = 0; i < migObj.getIgnoreList().size(); i++) {
  44. String ignoreString = (String) migObj.getIgnoreList()
  45. .getObject(i);
  46. ignoreString = Grt.replace(ignoreString, "$", "\$");
  47. ignoreString = ignoreString.replaceAll("\\", "\\")
  48. .replaceAll("\.",
  49. "\\.").replaceAll("\*", ".*")
  50. .replaceAll("\?", ".");
  51. ignoreList.add(Pattern.compile(ignoreString));
  52. }
  53. }
  54. // the format of objectName is, e.g. db.oracle.Table:SCOTT.emp
  55. String objectName = sourceObject.getClass().getName().substring(14)
  56. + ":" + sourceObject.getOwner().getName() + "."
  57. + sourceObject.getName();
  58. // check if that object is on the ignore list
  59. for (int i = 0; i < ignoreList.size(); i++) {
  60. Pattern p = (Pattern) ignoreList.get(i);
  61. // if this is a match, the object is on the ignore list
  62. // so null is returned
  63. if (p.matcher(objectName).matches())
  64. return true;
  65. }
  66. }
  67. return false;
  68. }
  69. /**
  70.  * Migrates an object based on the mappings defined in the migration object.
  71.  * If no explicit mapping is defined, the object is migrated using the
  72.  * default migration method for the source object's class
  73.  * 
  74.  * @param callerObject
  75.  *            the object that is calling this function
  76.  * @param mig
  77.  *            the migration object
  78.  * @param sourceObject
  79.  *            the object that should be migrated
  80.  * @param parent
  81.  *            the object will become the parent of the migrated object
  82.  * @return the migrated object
  83.  */
  84. public GrtObject migrateObject(Object callerObject,
  85. com.mysql.grt.db.migration.Migration migObj,
  86. GrtObject sourceObject, GrtObject parent) {
  87. if (isOnIgnoreList(migObj, sourceObject))
  88. return null;
  89. // check if we have a special mapping for this item
  90. MappingList mappings = migObj.getMappingDefinitions();
  91. if (mappings != null) {
  92. for (int i = 0; i < mappings.size(); i++) {
  93. Mapping mapping = mappings.get(i);
  94. if (mapping.getSourceObject().get_id().equals(
  95. sourceObject.get_id())) {
  96. String sourceStructName = Grt.GrtPackagePrefix
  97. + mapping.getSourceStructName();
  98. return callMigrationMethod(callerObject, migObj, mapping
  99. .getModuleName(), mapping.getMethodName(),
  100. sourceStructName, sourceObject,
  101. mapping.getParams(), parent);
  102. }
  103. }
  104. }
  105. // if it was not found, use default mapping if there is any
  106. MappingList defaultMappings = migObj.getMappingDefaults();
  107. if (defaultMappings != null) {
  108. for (int i = 0; i < defaultMappings.size(); i++) {
  109. Mapping mapping = defaultMappings.get(i);
  110. try {
  111. Class mappingSourceClass = Class
  112. .forName(Grt.GrtPackagePrefix
  113. + mapping.getSourceStructName());
  114. // if this method returns the correct class
  115. if (mappingSourceClass.isInstance(sourceObject)) {
  116. return callMigrationMethod(callerObject, migObj,
  117. mapping.getModuleName(), mapping
  118. .getMethodName(), mappingSourceClass
  119. .getName(), sourceObject, mapping
  120. .getParams(), parent);
  121. }
  122. } catch (ClassNotFoundException e) {
  123. // if the class is not found do not migrate
  124. }
  125. }
  126. }
  127. // now check the complete method list to see if there is a appropriate
  128. // method to migrate the source object. If there are several, take the
  129. // highes rated as it will be the best
  130. MethodList methods = migObj.getMigrationMethods();
  131. if (methods != null) {
  132. com.mysql.grt.db.migration.Method bestMethod = null;
  133. Class bestMethodSourceClass = null;
  134. for (int i = 0; i < methods.size(); i++) {
  135. com.mysql.grt.db.migration.Method method = methods.get(i);
  136. try {
  137. Class mappingSourceClass = Class
  138. .forName(Grt.GrtPackagePrefix
  139. + method.getSourceStructName());
  140. // if this method returns the correct class
  141. // and we do not have any other method yet or
  142. // the method just found has a higher rating than the
  143. // one we had before the method is stored as to best one
  144. // so far
  145. if ((mappingSourceClass.isInstance(sourceObject))
  146. && ((bestMethod == null) || (method.getRating() > bestMethod
  147. .getRating()))) {
  148. bestMethod = method;
  149. bestMethodSourceClass = mappingSourceClass;
  150. }
  151. } catch (ClassNotFoundException e) {
  152. // if the class is not found, ignore it
  153. }
  154. }
  155. try {
  156. if ((bestMethod != null) && (bestMethodSourceClass != null))
  157. return callMigrationMethod(callerObject, migObj, bestMethod
  158. .getModuleName(), bestMethod.getName(),
  159. bestMethodSourceClass.getName(), sourceObject,
  160. bestMethod.getParams(), parent);
  161. } catch (Exception e) {
  162. addMigrationLogEntry(
  163. migObj,
  164. sourceObject,
  165. null,
  166. "An error occured during the call of the "
  167. + bestMethod.getName()
  168. + " function to migrate an object from the class "
  169. + sourceObject.getClass().getName() + ".",
  170. logError);
  171. }
  172. }
  173. // if no mapping was found at all, set make an entry in to the log and
  174. // return null
  175. addMigrationLogEntry(migObj, sourceObject, null,
  176. "There is no method defined to migration an object of the type "
  177. + sourceObject.getClass().getName() + ".", logError);
  178. return null;
  179. }
  180. /**
  181.  * Calls a migration method base on the module and method name
  182.  * 
  183.  * @param moduleName
  184.  *            the module the method belongs to, e.g. MigrationOracle
  185.  * @param methodName
  186.  *            the name of the method
  187.  * @param sourceObject
  188.  *            the object to migrate
  189.  * @param params
  190.  *            the parameters that should be used to migrate the source
  191.  *            object
  192.  * @return the migrated object
  193.  */
  194. public GrtObject callMigrationMethod(Object callerObject,
  195. com.mysql.grt.db.migration.Migration migObj, String moduleName,
  196. String methodName, String sourceObjectClassName,
  197. GrtObject sourceObject, GrtStringHashMap params, GrtObject parent) {
  198. try {
  199. // find the module's class
  200. Class moduleClass = Class.forName(Grt.GrtModulePackagePrefix
  201. + moduleName);
  202. // prepare the method's arguments
  203. Class[] arguments = new Class[] {
  204. com.mysql.grt.db.migration.Migration.class,
  205. Class.forName(sourceObjectClassName),
  206. GrtStringHashMap.class, GrtObject.class };
  207. // find the method
  208. java.lang.reflect.Method method = moduleClass.getDeclaredMethod(
  209. methodName, arguments);
  210. // invoke migration method
  211. return (GrtObject) method.invoke(callerObject, new Object[] {
  212. migObj, sourceObject, params, parent });
  213. } catch (Exception e) {
  214. String name = sourceObject.getName();
  215. if (name == null)
  216. name = "<NULL>";
  217. addMigrationLogEntry(migObj, sourceObject, null,
  218. "An exception occured when the migration method was invoked for "
  219. + name + " (" + e.getMessage()
  220. + ").", logError);
  221. return null;
  222. }
  223. }
  224. public void addMigrationLogEntry(
  225. com.mysql.grt.db.migration.Migration migObj, GrtObject sourceObj,
  226. GrtObject targetObj) {
  227. addMigrationLogEntry(migObj, sourceObj, targetObj, null, logNoText);
  228. }
  229. public void addMigrationLogEntry(
  230. com.mysql.grt.db.migration.Migration migObj, GrtObject sourceObj,
  231. GrtObject targetObj, String message, int messageType) {
  232. // Add sourceObj and targetObj to sourceTargetObjectMapping
  233. // so it is faster to find the sourceObj to a given targetObj
  234. if ((sourceObj != null) && (targetObj != null))
  235. sourceTargetObjectMapping.put(sourceObj.get_id(), targetObj
  236. .get_id());
  237. // try to find existing log entry for this object
  238. ObjectLog objectLog = (ObjectLog) logObjects.get(sourceObj);
  239. // if no entry is found add a new one
  240. if (objectLog == null) {
  241. objectLog = new ObjectLog(null);
  242. objectLog.setLogObject(sourceObj);
  243. if (targetObj != null)
  244. objectLog.setRefObject(targetObj);
  245. // insert log entry into log list and get the global reference back
  246. objectLog = migObj.getMigrationLog().add(objectLog);
  247. // store the entry on the hashmap, so it can be found faster
  248. logObjects.put(sourceObj, objectLog);
  249. }
  250. if ((messageType != logNoText) && (message != null)) {
  251. // if there is a targetObj defined, set it
  252. if (targetObj != null)
  253. objectLog.setRefObject(targetObj);
  254. // create new log message
  255. ObjectLogEntry logMessage = new ObjectLogEntry(null);
  256. // set message members
  257. logMessage.setName(message);
  258. logMessage.setEntryType(messageType);
  259. // store it in the global logEntry
  260. objectLog.getEntries().add(logMessage);
  261. }
  262. }
  263. public GrtObject findTargetObject(GrtObject sourceObj) {
  264. return (GrtObject) Grt.getInstance().getObjectByRefId(
  265. (String) (sourceTargetObjectMapping.get(sourceObj.get_id())));
  266. }
  267. public String getTargetName(GrtStringHashMap migrationParams,
  268. String sourceName) {
  269. String targetName = null;
  270. if (migrationParams != null)
  271. targetName = migrationParams.get("targetName");
  272. if ((targetName != null) && !targetName.equals(""))
  273. return targetName;
  274. else
  275. return sourceName;
  276. }
  277. }