TPS-3715 : tELTJDBC** generating wrong sql (TUP-25672) (#4506)

* TPS-3715: for TUP-21479 ELTMSSQLMAP generate wrong update query.

* TPS-3715: for TDI-41651 Provide possibility to specify alias for output
table.

* TPS-3715: for TUP-23500 Provide possibility to specify alias for output
table.

main/plugins/org.talend.designer.codegen/jet_stub/header.javajet

@@ -324,6 +324,13 @@ public <%=JavaTypesManager.getTypeToGenerate(ctxParam.getType(),true)%> get<%=Ch
 	if(isRunInMultiThread || NodeUtil.containsMultiThreadComponent(process)){
 	%>
 		private final java.util.Map<String, Object> globalMap = java.util.Collections.synchronizedMap(new java.util.HashMap<String, Object>());
+		<%
+		if(ProcessUtils.isTestContainer(process)) {
+		%>
+			private final static java.util.Map<String, Object> junitGlobalMap = java.util.Collections.synchronizedMap(new java.util.HashMap<String, Object>());
+		<%
+		}
+		%>
 	<%
 	} else {
 	%>

main/plugins/org.talend.designer.codegen/jet_stub/subprocess_header.javajet

@@ -97,7 +97,7 @@
 								}
 
 								// for tRecordMatching
-								if(conn.getTarget().getUniqueName().startsWith("tRecordMatching")){
+								if(conn.getTarget().getUniqueName().indexOf("tRecordMatching")>-1){
 									List<Map<String, String>> joinKeys = (List<Map<String,String>>)ElementParameterParser.getObjectValue(conn.getTarget(), "__BLOCKING_DEFINITION__");
 									for(Map<String, String> joinKeyLine : joinKeys){
 										String lookupKey = joinKeyLine.get("LOOKUP_COLUMN");

main/plugins/org.talend.designer.components.libs/libs_src/mdm_transaction/src/main/java/com/talend/mdm/transaction/client/MDMTransaction.java

@@ -1,6 +1,7 @@
 package com.talend.mdm.transaction.client;
 
 import java.io.IOException;
+import java.util.List;
 
 import org.apache.commons.httpclient.HttpClient;
 import org.apache.commons.httpclient.HttpException;
@@ -10,98 +11,96 @@ import org.apache.commons.httpclient.auth.AuthScope;
 import org.apache.commons.httpclient.methods.DeleteMethod;
 import org.apache.commons.httpclient.methods.PostMethod;
 
+@SuppressWarnings("nls")
 public class MDMTransaction {
 
-    public static final String JVM_STICKY_SESSION = "sticky_session"; //$NON-NLS-1$
-    public static final String DEFAULT_STICKY_SESSION = "JSESSIONID"; //$NON-NLS-1$
+    private String url;
 
-	private String url;
-	private String id;
-	private String username;
-	private String password;
-	private String sessionId;
-	
-	public void commit() throws IOException {
-		HttpClient client = new HttpClient();
-		client.getState().setCredentials(AuthScope.ANY,
-				new UsernamePasswordCredentials(username, password));
+    private String id;
 
-		HttpMethod method = new PostMethod(url + "/" + id);
-		method.setDoAuthentication(true);
-		try {
-		    method.setRequestHeader("Cookie", getStickySession() + "=" + sessionId); //$NON-NLS-1$ //$NON-NLS-2$
-			client.executeMethod(method);
-		} catch (HttpException e) {
-			throw e;
-		} catch (IOException e) {
-			throw e;
-		} finally {
-			method.releaseConnection();
-		}
+    private String username;
 
-		int statuscode = method.getStatusCode();
-		if (statuscode >= 400) {
-		    throw new MDMTransactionException("Commit failed. The commit operation has returned the code " + statuscode + ".");
-		}
-	}
+    private String password;
 
-	public void rollback() throws IOException {
-		HttpClient client = new HttpClient();
-		client.getState().setCredentials(AuthScope.ANY,
-				new UsernamePasswordCredentials(username, password));
+    private List<String> cookies;
 
-		HttpMethod method = new DeleteMethod(url + "/" + id);
-		method.setDoAuthentication(true);
-		try {
-		    method.setRequestHeader("Cookie", getStickySession() + "=" + sessionId); //$NON-NLS-1$ //$NON-NLS-2$
-			client.executeMethod(method);
-		} catch (HttpException e) {
-			throw e;
-		} catch (IOException e) {
-			throw e;
-		} finally {
-			method.releaseConnection();
-		}
+    public void commit() throws IOException {
+        HttpClient client = new HttpClient();
+        client.getState().setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
 
-		int statuscode = method.getStatusCode();
-		if (statuscode >= 400) {
-		    throw new MDMTransactionException("Rollback failed. The rollback operation has returned the code " + statuscode + ".");
-		}
-	}
-	
-	public void setUrl(String url) {
-		this.url = url;
-	}
-
-	public void setId(String id) {
-		this.id = id;
-	}
-	
-	public String getId() {
-		return id;
-	}
-
-	public void setUsername(String username) {
-		this.username = username;
-	}
-
-	public void setPassword(String password) {
-		this.password = password;
-	}
-
-	public String getSessionId() {
-        return sessionId;
-    }
-
-    public void setSessionId(String sessionId) {
-        this.sessionId = sessionId;
-    }
-
-	public static String getStickySession() {
-        String stickySession = System.getProperty(JVM_STICKY_SESSION);
-        if(stickySession == null) {
-            stickySession = DEFAULT_STICKY_SESSION;
+        HttpMethod method = new PostMethod(url + "/" + id);
+        method.setDoAuthentication(true);
+        try {
+            for (String cookie : cookies) {
+                method.addRequestHeader("Cookie", cookie);
+            }
+            client.executeMethod(method);
+        } catch (HttpException e) {
+            throw e;
+        } catch (IOException e) {
+            throw e;
+        } finally {
+            method.releaseConnection();
+        }
+
+        int statuscode = method.getStatusCode();
+        if (statuscode >= 400) {
+            throw new MDMTransactionException("Commit failed. The commit operation has returned the code " + statuscode + ".");
         }
-        return stickySession;
     }
+
+    public void rollback() throws IOException {
+        HttpClient client = new HttpClient();
+        client.getState().setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
+
+        HttpMethod method = new DeleteMethod(url + "/" + id);
+        method.setDoAuthentication(true);
+        try {
+            for (String cookie : cookies) {
+                method.addRequestHeader("Cookie", cookie);
+            }
+            client.executeMethod(method);
+        } catch (HttpException e) {
+            throw e;
+        } catch (IOException e) {
+            throw e;
+        } finally {
+            method.releaseConnection();
+        }
+
+        int statuscode = method.getStatusCode();
+        if (statuscode >= 400) {
+            throw new MDMTransactionException(
+                    "Rollback failed. The rollback operation has returned the code " + statuscode + ".");
+        }
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public List<String> getCookies() {
+        return cookies;
+    }
+
+    public void setCookies(List<String> cookies) {
+        this.cookies = cookies;
+    }
+
 }

main/plugins/org.talend.designer.components.libs/libs_src/mdm_transaction/src/main/java/com/talend/mdm/transaction/client/MDMTransactionClient.java

@@ -1,6 +1,8 @@
 package com.talend.mdm.transaction.client;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 
 import org.apache.commons.httpclient.Header;
 import org.apache.commons.httpclient.HttpClient;
@@ -10,13 +12,10 @@ import org.apache.commons.httpclient.UsernamePasswordCredentials;
 import org.apache.commons.httpclient.auth.AuthScope;
 import org.apache.commons.httpclient.methods.GetMethod;
 import org.apache.commons.httpclient.methods.PutMethod;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 
+@SuppressWarnings("nls")
 public class MDMTransactionClient {
 
-    private static final Log LOG = LogFactory.getLog(MDMTransactionClient.class);
-
     public static MDMTransaction newTransaction(String url, String username, String password) throws IOException {
         HttpClient client = new HttpClient();
         client.getState().setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
@@ -25,11 +24,11 @@ public class MDMTransactionClient {
         PutMethod put = new PutMethod(url);
         put.setDoAuthentication(true);
         String tid;
-        String sessionID;
+        List<String> cookies;
         try {
             client.executeMethod(put);
             tid = put.getResponseBodyAsString();
-            sessionID = parseSessionID(put);
+            cookies = parseCookies(put);
         } catch (HttpException e) {
             throw e;
         } catch (IOException e) {
@@ -43,30 +42,30 @@ public class MDMTransactionClient {
         result.setId(tid);
         result.setUsername(username);
         result.setPassword(password);
-        result.setSessionId(sessionID);
+        result.setCookies(cookies);
 
         return result;
     }
 
     public static String getMDMTransactionURL(String url, boolean isNewServer) {
-        if(url == null || "".equals(url)) {
+        if (url == null || "".equals(url)) {
             return "";
         }
 
         int count = 3;
-        int i=0;
-        for(;i<url.length();i++) {
+        int i = 0;
+        for (; i < url.length(); i++) {
             char c = url.charAt(i);
-            if('/' == c) {
+            if ('/' == c) {
                 count--;
             }
-            if(count == 0) {
+            if (count == 0) {
                 break;
             }
         }
 
         String result = url.substring(0, i);
-        if(isNewServer){
+        if (isNewServer) {
             result += "/talendmdm/services/rest/transactions";
         } else {
             result += "/datamanager/services/transactions";
@@ -75,17 +74,17 @@ public class MDMTransactionClient {
         return result;
     }
 
-    public static String getSessionID(String url, String username, String password) throws IOException {
+    public static List<String> getCookies(String url, String username, String password) throws IOException {
         HttpClient client = new HttpClient();
         client.getState().setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
         client.getParams().setAuthenticationPreemptive(true);
 
         GetMethod get = new GetMethod(url);
         get.setDoAuthentication(true);
-        String sessionID;
+        List<String> cookies;
         try {
             client.executeMethod(get);
-            sessionID = parseSessionID(get);
+            cookies = parseCookies(get);
         } catch (HttpException e) {
             throw e;
         } catch (IOException e) {
@@ -93,44 +92,16 @@ public class MDMTransactionClient {
         } finally {
             get.releaseConnection();
         }
-        return sessionID;
+        return cookies;
     }
 
-    private static String parseSessionID(HttpMethod method) {
-        String sessionID = null;
-        String stickySession = MDMTransaction.getStickySession();
-        Header[] setCookie = method.getResponseHeaders("Set-Cookie"); //$NON-NLS-1$
-        for(Header header : setCookie) {
-            String headerValue = header.getValue();
-            if(headerValue.startsWith(stickySession + "=")) { //$NON-NLS-1$
-                int beginIndex = (stickySession + "=").length(); //$NON-NLS-1$
-                int endIndex = headerValue.indexOf(";", beginIndex); //$NON-NLS-1$
-                sessionID = headerValue.substring(beginIndex, endIndex);
-                break;
-            }
+    private static List<String> parseCookies(HttpMethod method) {
+        List<String> cookies = new ArrayList<String>();
+        Header[] setCookie = method.getResponseHeaders("Set-Cookie");
+        for (Header header : setCookie) {
+            cookies.add(header.getValue());
         }
-        if(sessionID == null) {
-            if(LOG.isDebugEnabled()) {
-                LOG.warn("Cookie for sticky session not found!"); //$NON-NLS-1$
-            }
-            sessionID = ""; //$NON-NLS-1$
-        }
-        return sessionID;
-    }
-
-    public static void main(String[] args) throws IOException {
-        String sessionID = MDMTransactionClient.getSessionID("http://localhost:8621/talendmdm/services/rest/transactions", "administrator", "administrator");
-        System.out.println(sessionID);
-
-        MDMTransaction mt = MDMTransactionClient.newTransaction("http://localhost:8180/talendmdm/services/rest/transactions", "administrator", "administrator");
-        mt.commit();
-
-        MDMTransaction mt1 = MDMTransactionClient.newTransaction("http://localhost:8180/talendmdm/services/rest/transactions", "administrator", "administrator");
-        mt1.rollback();
-
-        String url = "http://localhost:8180/talend/TalendPort";
-        String mdmurl = MDMTransactionClient.getMDMTransactionURL(url, true);
-        System.out.println(mdmurl);
+        return cookies;
     }
 
 }

main/plugins/org.talend.designer.components.localprovider/components/tMDMBulkLoad/tMDMBulkLoad_begin.javajet

@@ -40,30 +40,45 @@ org.talend.mdm.bulkload.client.BulkloadClient bulkloadClient_<%=cid %> = new org
         String transKey_<%=cid %> = "<%=trans%>_" + Thread.currentThread().getThreadGroup().getName();
         com.talend.mdm.transaction.client.MDMTransaction mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
         if(mdmTransaction_<%=cid %> == null) {
-            String murl_<%=cid %> = (String)globalMap.get("mdmUrl_<%=connection %>");
-            if(murl_<%=cid %>.endsWith("?wsdl")) {
-                murl_<%=cid %> = murl_<%=cid %>.substring(0, murl_<%=cid %>.length() - 5);
+            Boolean transInitStart_<%=cid%> = false;
+            synchronized(globalMap){
+                if(globalMap.containsKey(transKey_<%=cid %> + "_initStart")){
+                    transInitStart_<%=cid%> = true;
+                }else{
+                    globalMap.put(transKey_<%=cid %> + "_initStart", true);
+                }
             }
-            String turl_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.getMDMTransactionURL(murl_<%=cid %>, true);
-            String username_<%=cid %> = (String)globalMap.get("username_<%=connection %>");
-            String password_<%=cid %> = (String)globalMap.get("password_<%=connection %>");
-            if((Boolean)globalMap.get("useClientTranId_<%=connection %>")) {
-                String sessionID_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.getSessionID(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
-                mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
-                mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
-                mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
-                mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
-                mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
-                mdmTransaction_<%=cid %>.setSessionId(sessionID_<%=cid %>);
-            } else {
-                <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
-                mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+            if(transInitStart_<%=cid%> == false){
+                String murl_<%=cid %> = (String)globalMap.get("mdmUrl_<%=connection %>");
+                if(murl_<%=cid %>.endsWith("?wsdl")) {
+                    murl_<%=cid %> = murl_<%=cid %>.substring(0, murl_<%=cid %>.length() - 5);
+                }
+                String turl_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.getMDMTransactionURL(murl_<%=cid %>, true);
+                String username_<%=cid %> = (String)globalMap.get("username_<%=connection %>");
+                String password_<%=cid %> = (String)globalMap.get("password_<%=connection %>");
+                if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
+                    List<String> cookies_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getCookies(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
+                    mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
+                    mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
+                    mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
+                    mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
+                    mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
+                    mdmTransaction_<%=cid %>.setCookies(cookies_<%=cid%>);
+                }else{
+                    <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
+                    mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                }
+            }else{
+                while(mdmTransaction_<%=cid %> == null){
+                    Thread.sleep(10);
+                    mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
+                }
             }
             globalMap.put(transKey_<%=cid %>, mdmTransaction_<%=cid %>);
             <% logUtil.debug("\"Got transaction successfully with key=\" + transKey_" + cid);%>
         }
         bulkloadClient_<%=cid %>.setTransactionId(mdmTransaction_<%=cid %>.getId());
-        bulkloadClient_<%=cid %>.setSessionId(mdmTransaction_<%=cid%>.getSessionId());
+        bulkloadClient_<%=cid %>.setCookies(mdmTransaction_<%=cid%>.getCookies());
     }
 <%}%>
 

main/plugins/org.talend.designer.components.localprovider/components/tMDMConnection/tMDMConnection_begin.javajet

@@ -31,4 +31,20 @@ globalMap.put("mdmUrl_<%=cid %>", <%=mdmUrl %>);
 globalMap.put("username_<%=cid %>", <%=username %>);
 globalMap.put("password_<%=cid %>", decryptedPassword_<%=cid %>);
 globalMap.put("useTransaction_<%=cid %>", <%=useTransaction %>);
-globalMap.put("useClientTranId_<%=cid %>", <%=useClientTranId %>);
+globalMap.put("useClientTranId_<%=cid %>", <%=useClientTranId %>);
+
+String murl_<%=cid %> = <%=mdmUrl %>;
+String username_<%=cid%> = <%=username %>;
+String password_<%=cid%> = decryptedPassword_<%=cid %>;
+if(murl_<%=cid %>.endsWith("?wsdl")) {
+  murl_<%=cid %> = murl_<%=cid %>.substring(0, murl_<%=cid %>.length() - 5);
+}
+org.talend.mdm.webservice.TMDMService service_<%=cid %> = new org.talend.mdm.webservice.TMDMService_Service(null).getTMDMPort();
+javax.xml.ws.BindingProvider stub_<%=cid %> = (javax.xml.ws.BindingProvider) service_<%=cid %>;
+java.util.Map<String, Object> context_<%=cid %> = stub_<%=cid %>.getRequestContext();
+context_<%=cid %>.put(javax.xml.ws.BindingProvider.SESSION_MAINTAIN_PROPERTY, true);
+context_<%=cid %>.put(javax.xml.ws.BindingProvider.ENDPOINT_ADDRESS_PROPERTY, murl_<%=cid %>);
+context_<%=cid %>.put(javax.xml.ws.BindingProvider.USERNAME_PROPERTY, username_<%=cid %>);
+context_<%=cid %>.put(javax.xml.ws.BindingProvider.PASSWORD_PROPERTY, password_<%=cid %>);
+service_<%=cid %>.ping(new org.talend.mdm.webservice.WSPing());
+service_<%=cid %>.logout(new org.talend.mdm.webservice.WSLogout());

main/plugins/org.talend.designer.components.localprovider/components/tMDMDelete/tMDMDelete_begin.javajet

@@ -74,18 +74,34 @@ int nb_line_<%=cid %> = 0;
             String turl_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.getMDMTransactionURL(murl_<%=cid %>, true);
             com.talend.mdm.transaction.client.MDMTransaction mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
             if(mdmTransaction_<%=cid %> == null){
-                if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
-                    String sessionID_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getSessionID(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
-                    mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
-                    mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
-                    mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setSessionId(sessionID_<%=cid%>);
-                }else{
-                    <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
-                    mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                Boolean transInitStart_<%=cid%> = false;
+                synchronized(globalMap){
+                    if(globalMap.containsKey(transKey_<%=cid %> + "_initStart")){
+                        transInitStart_<%=cid%> = true;
+                    }else{
+                        globalMap.put(transKey_<%=cid %> + "_initStart", true);
+                    }
                 }
+                if(transInitStart_<%=cid%> == false){
+                    if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
+                        List<String> cookies_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getCookies(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
+                        mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
+                        mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
+                        mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setCookies(cookies_<%=cid%>);
+                    }else{
+                        <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
+                        mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                    }
+                }else{
+                    while(mdmTransaction_<%=cid %> == null){
+                        Thread.sleep(10);
+                        mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
+                    }
+                }
+
                 java.util.List<org.apache.cxf.headers.Header> soapHeaders_<%=cid %> = new java.util.ArrayList<org.apache.cxf.headers.Header>();
                 javax.xml.namespace.QName qName_<%=cid %> = new javax.xml.namespace.QName("http://www.talend.com/mdm", "transaction-id");
                 org.apache.cxf.databinding.DataBinding dataBinding_<%=cid %> = new org.apache.cxf.jaxb.JAXBDataBinding(String.class);
@@ -93,8 +109,7 @@ int nb_line_<%=cid %> = 0;
                 context_<%=cid %>.put(org.apache.cxf.headers.Header.HEADER_LIST, soapHeaders_<%=cid %>);
 
                 java.util.Map<String, java.util.List<String>> httpHeaders_<%=cid %> = new java.util.HashMap<String, java.util.List<String>>();
-                String cookie_<%=cid %> = com.talend.mdm.transaction.client.MDMTransaction.getStickySession() + "=" + mdmTransaction_<%=cid%>.getSessionId();
-                httpHeaders_<%=cid %>.put("Cookie", java.util.Arrays.asList(cookie_<%=cid %>));
+                httpHeaders_<%=cid %>.put("Cookie", mdmTransaction_<%=cid %>.getCookies());
                 context_<%=cid %>.put(org.apache.cxf.message.Message.PROTOCOL_HEADERS, httpHeaders_<%=cid %>);
 
                 globalMap.put(transKey_<%=cid %>, mdmTransaction_<%=cid %>);

main/plugins/org.talend.designer.components.localprovider/components/tMDMOutput/tMDMOutput_begin.javajet

@@ -144,18 +144,34 @@ int nb_line_rejected_<%=cid %> = 0;
             String turl_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.getMDMTransactionURL(murl_<%=cid %>, true);
             com.talend.mdm.transaction.client.MDMTransaction mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
             if(mdmTransaction_<%=cid %> == null){
-                if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
-                    String sessionID_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getSessionID(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
-                    mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
-                    mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
-                    mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setSessionId(sessionID_<%=cid%>);
-                }else{
-                    <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
-                    mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                Boolean transInitStart_<%=cid%> = false;
+                synchronized(globalMap){
+                    if(globalMap.containsKey(transKey_<%=cid %> + "_initStart")){
+                        transInitStart_<%=cid%> = true;
+                    }else{
+                        globalMap.put(transKey_<%=cid %> + "_initStart", true);
+                    }
                 }
+                if(transInitStart_<%=cid%> == false){
+                    if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
+                        List<String> cookies_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getCookies(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
+                        mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
+                        mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
+                        mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setCookies(cookies_<%=cid%>);
+                    }else{
+                        <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
+                        mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                    }
+                }else{
+                    while(mdmTransaction_<%=cid %> == null){
+                        Thread.sleep(10);
+                        mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
+                    }
+                }
+
                 java.util.List<org.apache.cxf.headers.Header> soapHeaders_<%=cid %> = new java.util.ArrayList<org.apache.cxf.headers.Header>();
                 javax.xml.namespace.QName qName_<%=cid %> = new javax.xml.namespace.QName("http://www.talend.com/mdm", "transaction-id");
                 org.apache.cxf.databinding.DataBinding dataBinding_<%=cid %> = new org.apache.cxf.jaxb.JAXBDataBinding(String.class);
@@ -163,8 +179,7 @@ int nb_line_rejected_<%=cid %> = 0;
                 context_<%=cid %>.put(org.apache.cxf.headers.Header.HEADER_LIST, soapHeaders_<%=cid %>);
 
                 java.util.Map<String, java.util.List<String>> httpHeaders_<%=cid %> = new java.util.HashMap<String, java.util.List<String>>();
-                String cookie_<%=cid %> = com.talend.mdm.transaction.client.MDMTransaction.getStickySession() + "=" + mdmTransaction_<%=cid%>.getSessionId();
-                httpHeaders_<%=cid %>.put("Cookie", java.util.Arrays.asList(cookie_<%=cid %>));
+                httpHeaders_<%=cid %>.put("Cookie", mdmTransaction_<%=cid %>.getCookies());
                 context_<%=cid %>.put(org.apache.cxf.message.Message.PROTOCOL_HEADERS, httpHeaders_<%=cid %>);
 
                 globalMap.put(transKey_<%=cid %>, mdmTransaction_<%=cid %>);

main/plugins/org.talend.designer.components.localprovider/components/tMDMReadConf/tMDMReadConf_begin.javajet

@@ -117,18 +117,34 @@ if ((metadatas != null) && (metadatas.size() > 0)) {//1
                             String turl_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.getMDMTransactionURL(murl_<%=cid %>, true);
                             com.talend.mdm.transaction.client.MDMTransaction mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
                             if(mdmTransaction_<%=cid %> == null){
-                                if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
-                                    String sessionID_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getSessionID(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
-                                    mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
-                                    mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
-                                    mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
-                                    mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
-                                    mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
-                                    mdmTransaction_<%=cid %>.setSessionId(sessionID_<%=cid%>);
-                                }else{
-                                    <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
-                                    mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                                Boolean transInitStart_<%=cid%> = false;
+                                synchronized(globalMap){
+                                    if(globalMap.containsKey(transKey_<%=cid %> + "_initStart")){
+                                        transInitStart_<%=cid%> = true;
+                                    }else{
+                                        globalMap.put(transKey_<%=cid %> + "_initStart", true);
+                                    }
                                 }
+                                if(transInitStart_<%=cid%> == false){
+                                    if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
+                                        List<String> cookies_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getCookies(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
+                                        mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
+                                        mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
+                                        mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
+                                        mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
+                                        mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
+                                        mdmTransaction_<%=cid %>.setCookies(cookies_<%=cid%>);
+                                    }else{
+                                        <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
+                                        mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                                    }
+                                }else{
+                                    while(mdmTransaction_<%=cid %> == null){
+                                        Thread.sleep(10);
+                                        mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
+                                    }
+                                }
+
                                 java.util.List<org.apache.cxf.headers.Header> soapHeaders_<%=cid %> = new java.util.ArrayList<org.apache.cxf.headers.Header>();
                                 javax.xml.namespace.QName qName_<%=cid %> = new javax.xml.namespace.QName("http://www.talend.com/mdm", "transaction-id");
                                 org.apache.cxf.databinding.DataBinding dataBinding_<%=cid %> = new org.apache.cxf.jaxb.JAXBDataBinding(String.class);
@@ -136,8 +152,7 @@ if ((metadatas != null) && (metadatas.size() > 0)) {//1
                                 context_<%=cid %>.put(org.apache.cxf.headers.Header.HEADER_LIST, soapHeaders_<%=cid %>);
 
                                 java.util.Map<String, java.util.List<String>> httpHeaders_<%=cid %> = new java.util.HashMap<String, java.util.List<String>>();
-                                String cookie_<%=cid %> = com.talend.mdm.transaction.client.MDMTransaction.getStickySession() + "=" + mdmTransaction_<%=cid%>.getSessionId();
-                                httpHeaders_<%=cid %>.put("Cookie", java.util.Arrays.asList(cookie_<%=cid %>));
+                                httpHeaders_<%=cid %>.put("Cookie", mdmTransaction_<%=cid %>.getCookies());
                                 context_<%=cid %>.put(org.apache.cxf.message.Message.PROTOCOL_HEADERS, httpHeaders_<%=cid %>);
 
                                 globalMap.put(transKey_<%=cid %>, mdmTransaction_<%=cid %>);

main/plugins/org.talend.designer.components.localprovider/components/tMDMRouteRecord/tMDMRouteRecord_main.javajet

@@ -79,18 +79,34 @@ int nb_line_<%=cid %> = 0;
             String turl_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.getMDMTransactionURL(murl_<%=cid %>, true);
             com.talend.mdm.transaction.client.MDMTransaction mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
             if(mdmTransaction_<%=cid %> == null){
-                if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
-                    String sessionID_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getSessionID(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
-                    mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
-                    mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
-                    mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setSessionId(sessionID_<%=cid%>);
-                }else{
-                    <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
-                    mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                Boolean transInitStart_<%=cid%> = false;
+                synchronized(globalMap){
+                    if(globalMap.containsKey(transKey_<%=cid %> + "_initStart")){
+                        transInitStart_<%=cid%> = true;
+                    }else{
+                        globalMap.put(transKey_<%=cid %> + "_initStart", true);
+                    }
                 }
+                if(transInitStart_<%=cid%> == false){
+                   if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
+                        List<String> cookies_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getCookies(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
+                        mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
+                        mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
+                        mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setCookies(cookies_<%=cid%>);
+                    }else{
+                        <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
+                        mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                    }
+                }else{
+                    while(mdmTransaction_<%=cid %> == null){
+                        Thread.sleep(10);
+                        mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
+                    }
+                }
+
                 java.util.List<org.apache.cxf.headers.Header> soapHeaders_<%=cid %> = new java.util.ArrayList<org.apache.cxf.headers.Header>();
                 javax.xml.namespace.QName qName_<%=cid %> = new javax.xml.namespace.QName("http://www.talend.com/mdm", "transaction-id");
                 org.apache.cxf.databinding.DataBinding dataBinding_<%=cid %> = new org.apache.cxf.jaxb.JAXBDataBinding(String.class);
@@ -98,8 +114,7 @@ int nb_line_<%=cid %> = 0;
                 context_<%=cid %>.put(org.apache.cxf.headers.Header.HEADER_LIST, soapHeaders_<%=cid %>);
 
                 java.util.Map<String, java.util.List<String>> httpHeaders_<%=cid %> = new java.util.HashMap<String, java.util.List<String>>();
-                String cookie_<%=cid %> = com.talend.mdm.transaction.client.MDMTransaction.getStickySession() + "=" + mdmTransaction_<%=cid%>.getSessionId();
-                httpHeaders_<%=cid %>.put("Cookie", java.util.Arrays.asList(cookie_<%=cid %>));
+                httpHeaders_<%=cid %>.put("Cookie", mdmTransaction_<%=cid %>.getCookies());
                 context_<%=cid %>.put(org.apache.cxf.message.Message.PROTOCOL_HEADERS, httpHeaders_<%=cid %>);
 
                 globalMap.put(transKey_<%=cid %>, mdmTransaction_<%=cid %>);

main/plugins/org.talend.designer.components.localprovider/components/tMDMSP/tMDMSP_begin.javajet

@@ -72,18 +72,34 @@ int nb_line_<%=cid %> = 0;
             String turl_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.getMDMTransactionURL(murl_<%=cid %>, true);
             com.talend.mdm.transaction.client.MDMTransaction mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
             if(mdmTransaction_<%=cid %> == null){
-                if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
-                    String sessionID_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getSessionID(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
-                    mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
-                    mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
-                    mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setSessionId(sessionID_<%=cid%>);
-                }else{
-                    <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
-                    mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                Boolean transInitStart_<%=cid%> = false;
+                synchronized(globalMap){
+                    if(globalMap.containsKey(transKey_<%=cid %> + "_initStart")){
+                        transInitStart_<%=cid%> = true;
+                    }else{
+                        globalMap.put(transKey_<%=cid %> + "_initStart", true);
+                    }
                 }
+                if(transInitStart_<%=cid%> == false){
+                    if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
+                        List<String> cookies_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getCookies(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
+                        mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
+                        mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
+                        mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setCookies(cookies_<%=cid%>);
+                    }else{
+                        <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
+                        mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                    }
+                }else{
+                    while(mdmTransaction_<%=cid %> == null){
+                        Thread.sleep(10);
+                        mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
+                    }
+                }
+
                 java.util.List<org.apache.cxf.headers.Header> soapHeaders_<%=cid %> = new java.util.ArrayList<org.apache.cxf.headers.Header>();
                 javax.xml.namespace.QName qName_<%=cid %> = new javax.xml.namespace.QName("http://www.talend.com/mdm", "transaction-id");
                 org.apache.cxf.databinding.DataBinding dataBinding_<%=cid %> = new org.apache.cxf.jaxb.JAXBDataBinding(String.class);
@@ -91,8 +107,7 @@ int nb_line_<%=cid %> = 0;
                 context_<%=cid %>.put(org.apache.cxf.headers.Header.HEADER_LIST, soapHeaders_<%=cid %>);
 
                 java.util.Map<String, java.util.List<String>> httpHeaders_<%=cid %> = new java.util.HashMap<String, java.util.List<String>>();
-                String cookie_<%=cid %> = com.talend.mdm.transaction.client.MDMTransaction.getStickySession() + "=" + mdmTransaction_<%=cid%>.getSessionId();
-                httpHeaders_<%=cid %>.put("Cookie", java.util.Arrays.asList(cookie_<%=cid %>));
+                httpHeaders_<%=cid %>.put("Cookie", mdmTransaction_<%=cid %>.getCookies());
                 context_<%=cid %>.put(org.apache.cxf.message.Message.PROTOCOL_HEADERS, httpHeaders_<%=cid %>);
 
                 globalMap.put(transKey_<%=cid %>, mdmTransaction_<%=cid %>);

main/plugins/org.talend.designer.components.localprovider/components/tMDMViewSearch/tMDMViewSearch_begin.javajet

@@ -115,18 +115,34 @@ if ((metadatas != null) && (metadatas.size() > 0)) {
                             String turl_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.getMDMTransactionURL(murl_<%=cid %>, true);
                             com.talend.mdm.transaction.client.MDMTransaction mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
                             if(mdmTransaction_<%=cid %> == null){
-                                if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
-                                    String sessionID_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getSessionID(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
-                                    mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
-                                    mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
-                                    mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
-                                    mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
-                                    mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
-                                    mdmTransaction_<%=cid %>.setSessionId(sessionID_<%=cid%>);
-                                }else{
-                                    <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
-                                    mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                                Boolean transInitStart_<%=cid%> = false;
+                                synchronized(globalMap){
+                                    if(globalMap.containsKey(transKey_<%=cid %> + "_initStart")){
+                                        transInitStart_<%=cid%> = true;
+                                    }else{
+                                        globalMap.put(transKey_<%=cid %> + "_initStart", true);
+                                    }
                                 }
+                                if(transInitStart_<%=cid%> == false){
+                                    if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
+                                        List<String> cookies_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getCookies(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
+                                        mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
+                                        mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
+                                        mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
+                                        mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
+                                        mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
+                                        mdmTransaction_<%=cid %>.setCookies(cookies_<%=cid%>);
+                                    }else{
+                                        <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
+                                        mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                                    }
+                                }else{
+                                    while(mdmTransaction_<%=cid %> == null){
+                                        Thread.sleep(10);
+                                        mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
+                                    }
+                                }
+
                                 java.util.List<org.apache.cxf.headers.Header> soapHeaders_<%=cid %> = new java.util.ArrayList<org.apache.cxf.headers.Header>();
                                 javax.xml.namespace.QName qName_<%=cid %> = new javax.xml.namespace.QName("http://www.talend.com/mdm", "transaction-id");
                                 org.apache.cxf.databinding.DataBinding dataBinding_<%=cid %> = new org.apache.cxf.jaxb.JAXBDataBinding(String.class);
@@ -134,8 +150,7 @@ if ((metadatas != null) && (metadatas.size() > 0)) {
                                 context_<%=cid %>.put(org.apache.cxf.headers.Header.HEADER_LIST, soapHeaders_<%=cid %>);
 
                                 java.util.Map<String, java.util.List<String>> httpHeaders_<%=cid %> = new java.util.HashMap<String, java.util.List<String>>();
-                                String cookie_<%=cid %> = com.talend.mdm.transaction.client.MDMTransaction.getStickySession() + "=" + mdmTransaction_<%=cid%>.getSessionId();
-                                httpHeaders_<%=cid %>.put("Cookie", java.util.Arrays.asList(cookie_<%=cid %>));
+                                httpHeaders_<%=cid %>.put("Cookie", mdmTransaction_<%=cid %>.getCookies());
                                 context_<%=cid %>.put(org.apache.cxf.message.Message.PROTOCOL_HEADERS, httpHeaders_<%=cid %>);
 
                                 globalMap.put(transKey_<%=cid %>, mdmTransaction_<%=cid %>);

main/plugins/org.talend.designer.components.localprovider/components/tMDMWriteConf/tMDMWriteConf_begin.javajet

@@ -148,18 +148,34 @@ int nb_line_rejected_<%=cid %> = 0;
             String turl_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.getMDMTransactionURL(murl_<%=cid %>, true);
             com.talend.mdm.transaction.client.MDMTransaction mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
             if(mdmTransaction_<%=cid %> == null){
-                if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
-                    String sessionID_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getSessionID(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
-                    mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
-                    mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
-                    mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
-                    mdmTransaction_<%=cid %>.setSessionId(sessionID_<%=cid%>);
-                }else{
-                    <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
-                    mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                Boolean transInitStart_<%=cid%> = false;
+                synchronized(globalMap){
+                    if(globalMap.containsKey(transKey_<%=cid %> + "_initStart")){
+                        transInitStart_<%=cid%> = true;
+                    }else{
+                        globalMap.put(transKey_<%=cid %> + "_initStart", true);
+                    }
                 }
+                if(transInitStart_<%=cid%> == false){
+                    if((Boolean)globalMap.get("useClientTranId_<%=connection %>")){
+                        List<String> cookies_<%=cid%> = com.talend.mdm.transaction.client.MDMTransactionClient.getCookies(turl_<%=cid%>,username_<%=cid%>,password_<%=cid%>);
+                        mdmTransaction_<%=cid %> = new com.talend.mdm.transaction.client.MDMTransaction();
+                        mdmTransaction_<%=cid %>.setUrl(turl_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setId("<%=cid %>_" + java.util.UUID.randomUUID());
+                        mdmTransaction_<%=cid %>.setUsername(username_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setPassword(password_<%=cid %>);
+                        mdmTransaction_<%=cid %>.setCookies(cookies_<%=cid%>);
+                    }else{
+                        <% logUtil.debug("\"Attempt to get a remote transaction from url: \" + murl_" + cid);%>
+                        mdmTransaction_<%=cid %> = com.talend.mdm.transaction.client.MDMTransactionClient.newTransaction(turl_<%=cid %>,username_<%=cid %>,password_<%=cid %>);
+                    }
+                }else{
+                    while(mdmTransaction_<%=cid %> == null){
+                        Thread.sleep(10);
+                        mdmTransaction_<%=cid %> = (com.talend.mdm.transaction.client.MDMTransaction)globalMap.get(transKey_<%=cid %>);
+                    }
+                }
+
                 java.util.List<org.apache.cxf.headers.Header> soapHeaders_<%=cid %> = new java.util.ArrayList<org.apache.cxf.headers.Header>();
                 javax.xml.namespace.QName qName_<%=cid %> = new javax.xml.namespace.QName("http://www.talend.com/mdm", "transaction-id");
                 org.apache.cxf.databinding.DataBinding dataBinding_<%=cid %> = new org.apache.cxf.jaxb.JAXBDataBinding(String.class);
@@ -167,8 +183,7 @@ int nb_line_rejected_<%=cid %> = 0;
                 context_<%=cid %>.put(org.apache.cxf.headers.Header.HEADER_LIST, soapHeaders_<%=cid %>);
 
                 java.util.Map<String, java.util.List<String>> httpHeaders_<%=cid %> = new java.util.HashMap<String, java.util.List<String>>();
-                String cookie_<%=cid %> = com.talend.mdm.transaction.client.MDMTransaction.getStickySession() + "=" + mdmTransaction_<%=cid%>.getSessionId();
-                httpHeaders_<%=cid %>.put("Cookie", java.util.Arrays.asList(cookie_<%=cid %>));
+                httpHeaders_<%=cid %>.put("Cookie", mdmTransaction_<%=cid %>.getCookies());
                 context_<%=cid %>.put(org.apache.cxf.message.Message.PROTOCOL_HEADERS, httpHeaders_<%=cid %>);
 
                 globalMap.put(transKey_<%=cid %>, mdmTransaction_<%=cid %>);

main/plugins/org.talend.designer.core.generic/src/main/java/org/talend/designer/core/generic/model/migration/NewMarketoMigrationTask.java

@@ -43,6 +43,14 @@ public class NewMarketoMigrationTask extends NewComponentFrameworkMigrationTask
             ParameterUtilTool.addParameterType(node, "RADIO", "USE_SOAP_API", "true");
             paramType = ParameterUtilTool.findParameterType(node, paramName);
         }
+        // Parameter is unassigned, so "LEAD_SELECTOR" parameter isn't processed yet.
+        if ("LEAD_SELECTOR_REST".equals(paramName) && paramType == null) {
+            ElementParameterType leadSelector = ParameterUtilTool.findParameterType(node, "LEAD_SELECTOR");
+            Object selValue = ParameterUtilTool.convertParameterValue(leadSelector);
+            ParameterUtilTool.addParameterType(node, "CLOSED_LIST", "LEAD_SELECTOR_REST", String.valueOf(selValue));
+            paramType = ParameterUtilTool.findParameterType(node, paramName);
+        }
+        //
         if (node != null && paramType != null) {
             String componentName = node.getComponentName();
             Object value = ParameterUtilTool.convertParameterValue(paramType);
@@ -59,7 +67,7 @@ public class NewMarketoMigrationTask extends NewComponentFrameworkMigrationTask
             }
             // Correct ListOperation value
             if ("OPERATION".equals(paramName) && "tMarketoListOperation".equals(componentName)) {
-                switch(String.valueOf(value)){
+                switch (String.valueOf(value)) {
                 case "ADDTOLIST":
                     paramType.setValue("addTo");
                     break;
@@ -98,6 +106,21 @@ public class NewMarketoMigrationTask extends NewComponentFrameworkMigrationTask
             if ("LEAD_KEYVALUES".equals(paramName)) {
                 paramType.setValue(TalendQuoteUtils.addQuotesIfNotExist(String.valueOf(value)));
             }
+            // creates a parameter for REST LeadSelector based on original value
+            if ("LEAD_SELECTOR".equals(paramName)) {
+                ParameterUtilTool.addParameterType(node, "CLOSED_LIST", "LEAD_SELECTOR_REST", String.valueOf(value));
+            }
+            // Manage include/exclude REST types
+            if ("INCLUDE_TYPES".equals(paramName) || "EXCLUDE_TYPES".equals(paramName)) {
+                ElementParameterType isSOAP = ParameterUtilTool.findParameterType(node, "USE_SOAP_API");
+                Object isSOAPValue = ParameterUtilTool.convertParameterValue(isSOAP);
+                if ("true".equals(String.valueOf(isSOAPValue))) {
+                    return paramType;
+                }
+                String k = "INCLUDE_TYPES".equals(paramName) ? "INCLUDE_TYPES_REST" : "EXCLUDE_TYPES_REST";
+                ElementParameterType rest = ParameterUtilTool.findParameterType(node, k);
+                return rest;
+            }
         }
         return paramType;
     }

main/plugins/org.talend.designer.core.generic/src/main/java/org/talend/designer/core/generic/model/migration/NewSalesforceMigrationTask.java

@@ -23,6 +23,9 @@ import java.util.Map;
 import java.util.Properties;
 
 import org.apache.commons.lang.StringUtils;
+import org.talend.daikon.NamedThing;
+import org.talend.daikon.properties.property.Property;
+import org.talend.designer.core.generic.model.GenericElementParameter;
 import org.talend.designer.core.generic.utils.ParameterUtilTool;
 import org.talend.designer.core.model.utils.emf.talendfile.ElementParameterType;
 import org.talend.designer.core.model.utils.emf.talendfile.ElementValueType;
@@ -65,7 +68,8 @@ public class NewSalesforceMigrationTask extends NewComponentFrameworkMigrationTa
     			}
         		ElementParameterType customModuleName = ParameterUtilTool.findParameterType(node, paramName);
         		if(customModuleName != null){
-            		paramType.setValue(StringUtils.strip(String.valueOf(ParameterUtilTool.convertParameterValue(customModuleName)),"\""));
+            		String ModuleName = StringUtils.strip(String.valueOf(ParameterUtilTool.convertParameterValue(customModuleName)),"\"");
+            		paramType.setValue(ModuleName.replaceAll("\r|\n|\r\n", ""));
         		}
             }else if("CONNECTION".equals(paramName) && value!=null && !"".equals(value)){
         		ElementParameterType useConnection = ParameterUtilTool.findParameterType(node, "USE_EXISTING_CONNECTION");
@@ -124,4 +128,17 @@ public class NewSalesforceMigrationTask extends NewComponentFrameworkMigrationTa
 		}
 		return tableValue;
 	}
+	
+    @Override
+    protected void processUnmappedElementParameter(Properties props, NodeType nodeType, GenericElementParameter param,
+            NamedThing currNamedThing) {
+
+        if ("tSalesforceInput".equals(nodeType.getComponentName()) && "returnNullValue".equals(param.getName())) {
+            if (currNamedThing instanceof Property) {
+                ((Property<?>) currNamedThing).setStoredValue(true);
+            }
+        } else {
+            super.processUnmappedElementParameter(props, nodeType, param, currNamedThing);
+        }
+    }
 }

main/plugins/org.talend.designer.core.generic/src/main/java/org/talend/designer/core/generic/model/migration/NewSalesforceMigrationTask.properties

@@ -63,6 +63,7 @@ tSalesforceInput.connection.proxy.port=PROXY_PORT
 tSalesforceInput.connection.proxy.userPassword.userId=PROXY_USERNAME
 tSalesforceInput.connection.proxy.userPassword.password=PROXY_PASSWORD
 tSalesforceInput.batchSize=BATCH_SIZE
+tSalesforceInput.returnNullValue=
 tSalesforceInput.normalizeDelimiter=NORMALIZE_DELIMITER
 tSalesforceInput.columnNameDelimiter=COLUMNNAME_DELIMITER
 ### tSalesforceInput end  ###

main/plugins/org.talend.designer.core/src/main/java/org/talend/designer/core/model/components/EParameterName.java

@@ -368,6 +368,8 @@ public enum EParameterName {
 
     REPAINT("REPAINT"), //$NON-NLS-1$
 
+    ACTIVE_DATABASE_DELIMITED_IDENTIFIERS("Active database delimited identifiers"), //$NON-NLS-1$
+
     // for tDataprepRun
     PREPARATION_ID("PREPARATION_ID");
 

main/plugins/org.talend.designer.core/src/main/java/org/talend/designer/core/model/process/DataProcess.java

@@ -15,6 +15,7 @@ package org.talend.designer.core.model.process;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -265,8 +266,207 @@ public class DataProcess implements IGeneratingProcess {
             return buildCheckMap.get(graphicalNode);
         }
 
-        AbstractNode dataNode;
+        AbstractNode dataNode = createDataNode(graphicalNode, prefix);
 
+        INode addedNode = addDataNode(dataNode);
+        buildCheckMap.put(graphicalNode, addedNode);
+
+        List<IConnection> outgoingConnections = new ArrayList<IConnection>();
+        List<IConnection> incomingConnections = new ArrayList<IConnection>();
+        dataNode.setIncomingConnections(incomingConnections);
+        dataNode.setOutgoingConnections(outgoingConnections);
+
+        // if the component is a hash, and that there is a lookup connection just after, don't generate the node.
+        // if (graphicalNode.getComponent().isHashComponent()) {
+        // if (graphicalNode.getOutgoingConnections(EConnectionType.FLOW_REF).size() != 0) {
+        // dataNode.setSubProcessStart(false);
+        // }
+        // }
+
+        for (IConnection connection : graphicalNode.getOutgoingConnections()) {
+            if (!connection.isActivate()) {
+                continue;
+            }
+            IElementParameter monitorParam = connection.getElementParameter(EParameterName.MONITOR_CONNECTION.getName());
+            if (monitorParam != null && (!connection.getLineStyle().equals(EConnectionType.FLOW_REF))
+                    && ((Boolean) monitorParam.getValue())) {
+                addvFlowMeterBetween(dataNode, buildDataNodeFromNode(connection.getTarget(), prefix), connection,
+                        graphicalNode.getProcess(), connection.getElementParameters());
+            } else {
+                INode target = buildDataNodeFromNode(connection.getTarget(), prefix);
+                createDataConnection(dataNode, (AbstractNode) target, connection, prefix);
+            }
+        }
+
+        dataNode.setRealGraphicalNode(graphicalNode);
+
+        return dataNode;
+    }
+
+    private DataConnection createDataConnection(AbstractNode sourceDataNode, AbstractNode targetDataNode, IConnection connection,
+            String prefix) {
+        DataConnection dataConnec = new DataConnection();
+        dataConnec.setActivate(connection.isActivate());
+        dataConnec.setLineStyle(connection.getLineStyle());
+        dataConnec.setTraceConnection(connection.isTraceConnection());
+        dataConnec.setTracesCondition(connection.getTracesCondition());
+        dataConnec.setMonitorConnection(connection.isMonitorConnection());
+        dataConnec.setEnabledTraceColumns(connection.getEnabledTraceColumns());
+        if ((connection.getLineStyle().hasConnectionCategory(IConnectionCategory.EXECUTION_ORDER))
+                && (connection.getTarget().getMetadataList().size() > 0)) {
+            dataConnec.setMetadataTable(connection.getTarget().getMetadataList().get(0));
+        } else {
+            dataConnec.setMetadataTable(connection.getMetadataTable());
+        }
+        String name = connection.getName();
+        if (prefix != null) {
+            name = prefix + name;
+        }
+        dataConnec.setName(name);
+        String uniqueName2 = connection.getUniqueName();
+        if (prefix != null) {
+            uniqueName2 = prefix + uniqueName2;
+        }
+        dataConnec.setUniqueName(uniqueName2);
+        dataConnec.setSource(sourceDataNode);
+        dataConnec.setCondition(connection.getCondition());
+        dataConnec.setRouteConnectionType(connection.getRouteConnectionType());
+        dataConnec.setEndChoice(connection.getEndChoice());// TESB-8043
+        dataConnec.setExceptionList(connection.getExceptionList());
+        dataConnec.setConnectorName(connection.getConnectorName());
+        dataConnec.setInputId(connection.getInputId());
+        dataConnec.setOutputId(connection.getOutputId());
+        if (connection.getLineStyle().equals(EConnectionType.ITERATE)) {
+            IElementParameter param = new ElementParameter(dataConnec);
+            param.setFieldType(EParameterFieldType.CHECK);
+            param.setCategory(EComponentCategory.BASIC);
+            param.setValue(Boolean.FALSE);
+            param.setName("ENABLE_PARALLEL"); //$NON-NLS-1$
+            param.setDisplayName(Messages.getString("DataProcess.enableParallel")); //$NON-NLS-1$
+            param.setShow(true);
+            param.setNumRow(1);
+            ((List<IElementParameter>) dataConnec.getElementParameters()).add(param);
+
+            param = new ElementParameter(dataConnec);
+            param.setFieldType(EParameterFieldType.TEXT);
+            param.setCategory(EComponentCategory.BASIC);
+            // param.setListItemsDisplayName(new String[] { "2", "3", "4" });
+            // param.setListItemsDisplayCodeName(new String[] { "2", "3", "4" });
+            // param.setListItemsValue(new String[] { "2", "3", "4" });
+            param.setValue("2"); //$NON-NLS-1$
+            param.setName("NUMBER_PARALLEL"); //$NON-NLS-1$
+            param.setDisplayName(Messages.getString("DataProcess.numberParallel")); //$NON-NLS-1$
+            param.setShow(true);
+            param.setShowIf("ENABLE_PARALLEL == 'true'"); //$NON-NLS-1$
+            param.setNumRow(1);
+            ((List<IElementParameter>) dataConnec.getElementParameters()).add(param);
+        }
+        if (dataConnec.getLineStyle().hasConnectionCategory(IConnectionCategory.FLOW)) {
+            IElementParameter param = new ElementParameter(dataConnec);
+            param.setName(EParameterName.TRACES_CONNECTION_ENABLE.getName());
+            param.setDisplayName(EParameterName.TRACES_CONNECTION_ENABLE.getDisplayName());
+            param.setFieldType(EParameterFieldType.CHECK);
+            param.setValue(Boolean.FALSE);
+            param.setCategory(EComponentCategory.ADVANCED);
+            param.setShow(false);
+            param.setNumRow(1);
+            ((List<IElementParameter>) dataConnec.getElementParameters()).add(param);
+        }
+        if (PluginChecker.isTeamEdition()) {
+
+            if ((connection.getLineStyle() == EConnectionType.ON_SUBJOB_OK
+                    || connection.getLineStyle() == EConnectionType.ON_SUBJOB_ERROR
+                    || connection.getLineStyle() == EConnectionType.RUN_IF
+                    || connection.getLineStyle() == EConnectionType.ROUTE_WHEN
+                    || connection.getLineStyle() == EConnectionType.ROUTE_CATCH
+                    || connection.getLineStyle() == EConnectionType.ON_COMPONENT_OK
+                    || connection.getLineStyle() == EConnectionType.ON_COMPONENT_ERROR)) {
+                IElementParameter param = new ElementParameter(dataConnec);
+                param.setName(EParameterName.RESUMING_CHECKPOINT.getName());
+                param.setValue(Boolean.FALSE);
+                param.setDisplayName(EParameterName.RESUMING_CHECKPOINT.getDisplayName());
+                param.setFieldType(EParameterFieldType.CHECK);
+                param.setCategory(EComponentCategory.RESUMING);
+                param.setNumRow(2);
+                param.setShow(true);
+                ((List<IElementParameter>) dataConnec.getElementParameters()).add(param); // breakpoint
+            }
+
+            if (dataConnec.getLineStyle().hasConnectionCategory(IConnectionCategory.FLOW)) {
+                IElementParameter param = new ElementParameter(dataConnec);
+                param.setName(EParameterName.ACTIVEBREAKPOINT.getName());
+                param.setDisplayName(EParameterName.ACTIVEBREAKPOINT.getDisplayName());
+                param.setFieldType(EParameterFieldType.CHECK);
+                param.setCategory(EComponentCategory.BREAKPOINT);
+                param.setNumRow(13);
+                param.setValue(false);
+                param.setContextMode(false);
+                param.setShow(true);
+
+                ((List<IElementParameter>) dataConnec.getElementParameters()).add(param);
+                IComponent component = ComponentsFactoryProvider.getInstance().get("tFilterRow",
+                        ComponentCategory.CATEGORY_4_DI.getName());
+                DataNode tmpNode = new DataNode(component, "breakpointNode");
+                IElementParameter tmpParam = tmpNode.getElementParameter("LOGICAL_OP");
+                if (tmpParam != null) {
+                    tmpParam.setCategory(EComponentCategory.BREAKPOINT);
+                    tmpParam.setNumRow(14);
+                    ((List<IElementParameter>) dataConnec.getElementParameters()).add(tmpParam);
+                }
+                tmpParam = tmpNode.getElementParameter("CONDITIONS");
+                if (tmpParam != null) {
+                    tmpParam.setCategory(EComponentCategory.BREAKPOINT);
+                    tmpParam.setNumRow(15);
+                    ((List<IElementParameter>) dataConnec.getElementParameters()).add(tmpParam);
+                }
+
+                tmpParam = tmpNode.getElementParameter("USE_ADVANCED");
+                if (tmpParam != null) {
+                    tmpParam.setCategory(EComponentCategory.BREAKPOINT);
+                    tmpParam.setNumRow(16);
+                    ((List<IElementParameter>) dataConnec.getElementParameters()).add(tmpParam);
+                }
+                tmpParam = tmpNode.getElementParameter("ADVANCED_COND");
+                if (tmpParam != null) {
+                    tmpParam.setCategory(EComponentCategory.BREAKPOINT);
+                    tmpParam.setNumRow(17);
+                    ((List<IElementParameter>) dataConnec.getElementParameters()).add(tmpParam);
+                }
+            }
+        }
+        copyElementParametersValue(connection, dataConnec);
+
+        dataConnec.setTarget(targetDataNode);
+        List<IConnection> incomingConnections = (List<IConnection>) targetDataNode.getIncomingConnections();
+        if (incomingConnections == null) {
+            incomingConnections = new ArrayList<IConnection>();
+            targetDataNode.setIncomingConnections(incomingConnections);
+        }
+        List<IConnection> outgoingConnections = (List<IConnection>) sourceDataNode.getOutgoingConnections();
+        if (outgoingConnections == null) {
+            outgoingConnections = new ArrayList<IConnection>();
+            sourceDataNode.setOutgoingConnections(outgoingConnections);
+        }
+
+        outgoingConnections.add(dataConnec);
+        incomingConnections.add(dataConnec);
+
+        if (!connection.getName().equals(name)) {
+            if (targetDataNode instanceof AbstractExternalNode) {
+                // System.out.println("dataProcess: rename input:" + connection.getName() + " to " + name);
+                ((AbstractExternalNode) targetDataNode).renameInputConnection(connection.getName(), name);
+            }
+            if (sourceDataNode instanceof AbstractExternalNode) {
+                // System.out.println("dataProcess: rename output:" + connection.getName() + " to " + name);
+                ((AbstractExternalNode) sourceDataNode).renameOutputConnection(connection.getName(), name);
+            }
+        }
+
+        return dataConnec;
+    }
+
+    private AbstractNode createDataNode(final INode graphicalNode, String prefix) {
+        AbstractNode dataNode;
         if (graphicalNode.getExternalNode() == null) {
             dataNode = new DataNode();
         } else {
@@ -336,184 +536,6 @@ public class DataProcess implements IGeneratingProcess {
             }
         }
         dataNode.setDesignSubjobStartNode(graphicalNode.getDesignSubjobStartNode());
-
-        INode addedNode = addDataNode(dataNode);
-        buildCheckMap.put(graphicalNode, addedNode);
-
-        List<IConnection> outgoingConnections = new ArrayList<IConnection>();
-        List<IConnection> incomingConnections = new ArrayList<IConnection>();
-        dataNode.setIncomingConnections(incomingConnections);
-        dataNode.setOutgoingConnections(outgoingConnections);
-
-        // if the component is a hash, and that there is a lookup connection just after, don't generate the node.
-        // if (graphicalNode.getComponent().isHashComponent()) {
-        // if (graphicalNode.getOutgoingConnections(EConnectionType.FLOW_REF).size() != 0) {
-        // dataNode.setSubProcessStart(false);
-        // }
-        // }
-
-        DataConnection dataConnec;
-        for (IConnection connection : graphicalNode.getOutgoingConnections()) {
-            if (!connection.isActivate()) {
-                continue;
-            }
-            IElementParameter monitorParam = connection.getElementParameter(EParameterName.MONITOR_CONNECTION.getName());
-            if (monitorParam != null && (!connection.getLineStyle().equals(EConnectionType.FLOW_REF))
-                    && ((Boolean) monitorParam.getValue())) {
-                addvFlowMeterBetween(dataNode, buildDataNodeFromNode(connection.getTarget(), prefix), connection,
-                        graphicalNode.getProcess(), connection.getElementParameters());
-            } else {
-                dataConnec = new DataConnection();
-                dataConnec.setActivate(connection.isActivate());
-                dataConnec.setLineStyle(connection.getLineStyle());
-                dataConnec.setTraceConnection(connection.isTraceConnection());
-                dataConnec.setTracesCondition(connection.getTracesCondition());
-                dataConnec.setMonitorConnection(connection.isMonitorConnection());
-                dataConnec.setEnabledTraceColumns(connection.getEnabledTraceColumns());
-                if ((connection.getLineStyle().hasConnectionCategory(IConnectionCategory.EXECUTION_ORDER))
-                        && (connection.getTarget().getMetadataList().size() > 0)) {
-                    dataConnec.setMetadataTable(connection.getTarget().getMetadataList().get(0));
-                } else {
-                    dataConnec.setMetadataTable(connection.getMetadataTable());
-                }
-                String name = connection.getName();
-                if (prefix != null) {
-                    name = prefix + name;
-                }
-                dataConnec.setName(name);
-                String uniqueName2 = connection.getUniqueName();
-                if (prefix != null) {
-                    uniqueName2 = prefix + uniqueName2;
-                }
-                dataConnec.setUniqueName(uniqueName2);
-                dataConnec.setSource(dataNode);
-                dataConnec.setCondition(connection.getCondition());
-                dataConnec.setRouteConnectionType(connection.getRouteConnectionType());
-                dataConnec.setEndChoice(connection.getEndChoice());// TESB-8043
-                dataConnec.setExceptionList(connection.getExceptionList());
-                dataConnec.setConnectorName(connection.getConnectorName());
-                dataConnec.setInputId(connection.getInputId());
-                dataConnec.setOutputId(connection.getOutputId());
-                if (connection.getLineStyle().equals(EConnectionType.ITERATE)) {
-                    IElementParameter param = new ElementParameter(dataConnec);
-                    param.setFieldType(EParameterFieldType.CHECK);
-                    param.setCategory(EComponentCategory.BASIC);
-                    param.setValue(Boolean.FALSE);
-                    param.setName("ENABLE_PARALLEL"); //$NON-NLS-1$
-                    param.setDisplayName(Messages.getString("DataProcess.enableParallel")); //$NON-NLS-1$
-                    param.setShow(true);
-                    param.setNumRow(1);
-                    ((List<IElementParameter>) dataConnec.getElementParameters()).add(param);
-
-                    param = new ElementParameter(dataConnec);
-                    param.setFieldType(EParameterFieldType.TEXT);
-                    param.setCategory(EComponentCategory.BASIC);
-                    // param.setListItemsDisplayName(new String[] { "2", "3", "4" });
-                    // param.setListItemsDisplayCodeName(new String[] { "2", "3", "4" });
-                    // param.setListItemsValue(new String[] { "2", "3", "4" });
-                    param.setValue("2"); //$NON-NLS-1$
-                    param.setName("NUMBER_PARALLEL"); //$NON-NLS-1$
-                    param.setDisplayName(Messages.getString("DataProcess.numberParallel")); //$NON-NLS-1$
-                    param.setShow(true);
-                    param.setShowIf("ENABLE_PARALLEL == 'true'"); //$NON-NLS-1$
-                    param.setNumRow(1);
-                    ((List<IElementParameter>) dataConnec.getElementParameters()).add(param);
-                }
-                if (dataConnec.getLineStyle().hasConnectionCategory(IConnectionCategory.FLOW)) {
-                    IElementParameter param = new ElementParameter(dataConnec);
-                    param.setName(EParameterName.TRACES_CONNECTION_ENABLE.getName());
-                    param.setDisplayName(EParameterName.TRACES_CONNECTION_ENABLE.getDisplayName());
-                    param.setFieldType(EParameterFieldType.CHECK);
-                    param.setValue(Boolean.FALSE);
-                    param.setCategory(EComponentCategory.ADVANCED);
-                    param.setShow(false);
-                    param.setNumRow(1);
-                    ((List<IElementParameter>) dataConnec.getElementParameters()).add(param);
-                }
-                if (PluginChecker.isTeamEdition()) {
-
-                    if ((connection.getLineStyle() == EConnectionType.ON_SUBJOB_OK
-                            || connection.getLineStyle() == EConnectionType.ON_SUBJOB_ERROR
-                            || connection.getLineStyle() == EConnectionType.RUN_IF
-                            || connection.getLineStyle() == EConnectionType.ROUTE_WHEN
-                            || connection.getLineStyle() == EConnectionType.ROUTE_CATCH
-                            || connection.getLineStyle() == EConnectionType.ON_COMPONENT_OK || connection.getLineStyle() == EConnectionType.ON_COMPONENT_ERROR)) {
-                        IElementParameter param = new ElementParameter(dataConnec);
-                        param.setName(EParameterName.RESUMING_CHECKPOINT.getName());
-                        param.setValue(Boolean.FALSE);
-                        param.setDisplayName(EParameterName.RESUMING_CHECKPOINT.getDisplayName());
-                        param.setFieldType(EParameterFieldType.CHECK);
-                        param.setCategory(EComponentCategory.RESUMING);
-                        param.setNumRow(2);
-                        param.setShow(true);
-                        ((List<IElementParameter>) dataConnec.getElementParameters()).add(param); // breakpoint
-                    }
-
-                    if (dataConnec.getLineStyle().hasConnectionCategory(IConnectionCategory.FLOW)) {
-                        IElementParameter param = new ElementParameter(dataConnec);
-                        param.setName(EParameterName.ACTIVEBREAKPOINT.getName());
-                        param.setDisplayName(EParameterName.ACTIVEBREAKPOINT.getDisplayName());
-                        param.setFieldType(EParameterFieldType.CHECK);
-                        param.setCategory(EComponentCategory.BREAKPOINT);
-                        param.setNumRow(13);
-                        param.setValue(false);
-                        param.setContextMode(false);
-                        param.setShow(true);
-
-                        ((List<IElementParameter>) dataConnec.getElementParameters()).add(param);
-                        IComponent component = ComponentsFactoryProvider.getInstance().get("tFilterRow",
-                                ComponentCategory.CATEGORY_4_DI.getName());
-                        DataNode tmpNode = new DataNode(component, "breakpointNode");
-                        IElementParameter tmpParam = tmpNode.getElementParameter("LOGICAL_OP");
-                        if (tmpParam != null) {
-                            tmpParam.setCategory(EComponentCategory.BREAKPOINT);
-                            tmpParam.setNumRow(14);
-                            ((List<IElementParameter>) dataConnec.getElementParameters()).add(tmpParam);
-                        }
-                        tmpParam = tmpNode.getElementParameter("CONDITIONS");
-                        if (tmpParam != null) {
-                            tmpParam.setCategory(EComponentCategory.BREAKPOINT);
-                            tmpParam.setNumRow(15);
-                            ((List<IElementParameter>) dataConnec.getElementParameters()).add(tmpParam);
-                        }
-
-                        tmpParam = tmpNode.getElementParameter("USE_ADVANCED");
-                        if (tmpParam != null) {
-                            tmpParam.setCategory(EComponentCategory.BREAKPOINT);
-                            tmpParam.setNumRow(16);
-                            ((List<IElementParameter>) dataConnec.getElementParameters()).add(tmpParam);
-                        }
-                        tmpParam = tmpNode.getElementParameter("ADVANCED_COND");
-                        if (tmpParam != null) {
-                            tmpParam.setCategory(EComponentCategory.BREAKPOINT);
-                            tmpParam.setNumRow(17);
-                            ((List<IElementParameter>) dataConnec.getElementParameters()).add(tmpParam);
-                        }
-                    }
-                }
-                copyElementParametersValue(connection, dataConnec);
-                INode target = buildDataNodeFromNode(connection.getTarget(), prefix);
-                dataConnec.setTarget(target);
-                incomingConnections = (List<IConnection>) target.getIncomingConnections();
-                if (incomingConnections == null) {
-                    incomingConnections = new ArrayList<IConnection>();
-                }
-                outgoingConnections.add(dataConnec);
-                incomingConnections.add(dataConnec);
-
-                if (!connection.getName().equals(name)) {
-                    if (target instanceof AbstractExternalNode) {
-                        // System.out.println("dataProcess: rename input:" + connection.getName() + " to " + name);
-                        ((AbstractExternalNode) target).renameInputConnection(connection.getName(), name);
-                    }
-                    if (dataNode instanceof AbstractExternalNode) {
-                        // System.out.println("dataProcess: rename output:" + connection.getName() + " to " + name);
-                        ((AbstractExternalNode) dataNode).renameOutputConnection(connection.getName(), name);
-                    }
-                }
-            }
-        }
-
         return dataNode;
     }
 
@@ -3092,6 +3114,45 @@ public class DataProcess implements IGeneratingProcess {
         return null;
     }
 
+    private Node cloneGraphicalNode(IProcess process, INode node) {
+        IComponent component = node.getComponent();
+        Node newGraphicalNode = null;
+        if (EComponentType.GENERIC.equals(component.getComponentType())) {
+            newGraphicalNode = new Node(node, (IProcess2) process);
+        } else {
+            newGraphicalNode = new Node(node.getComponent(), (IProcess2) process);
+        }
+        newGraphicalNode.setMetadataList(node.getMetadataList());
+
+        IExternalNode externalNode = node.getExternalNode();
+        if (externalNode != null) {
+            AbstractExternalData externalEmfData = externalNode.getExternalEmfData();
+            newGraphicalNode.getExternalNode().setExternalEmfData(externalEmfData);
+        }
+        // fwang fixed bug TDI-8027
+        IExternalData externalData = node.getExternalData();
+        if (externalData != null) {
+            try {
+                newGraphicalNode.setExternalData(externalData.clone());
+            } catch (CloneNotSupportedException e) {
+                newGraphicalNode.setExternalData(externalData);
+            }
+        }
+
+        copyElementParametersValue(node, newGraphicalNode);
+        if (newGraphicalNode.getComponentProperties() != null) {
+            List<Form> forms = newGraphicalNode.getComponentProperties().getForms();
+            for (Form form : forms) {
+                newGraphicalNode.getComponentProperties().refreshLayout(form);
+            }
+        }
+        newGraphicalNode.setDummy(node.isDummy());
+
+        ValidationRulesUtil.createRejectConnector(newGraphicalNode);
+        ValidationRulesUtil.updateRejectMetatable(newGraphicalNode, node);
+        return newGraphicalNode;
+    }
+
     @SuppressWarnings("unchecked")
     public INode buildNodeFromNode(final INode graphicalNode, final IProcess process) {
         if (buildCheckMap == null) {
@@ -3101,56 +3162,15 @@ public class DataProcess implements IGeneratingProcess {
             return (INode) buildGraphicalMap.get(graphicalNode);
         }
 
-        IComponent component = graphicalNode.getComponent();
-        Node newGraphicalNode = null;
-        if (EComponentType.GENERIC.equals(component.getComponentType())) {
-            newGraphicalNode = new Node(graphicalNode, (IProcess2) process);
-        } else {
-            newGraphicalNode = new Node(graphicalNode.getComponent(), (IProcess2) process);
-        }
-        newGraphicalNode.setMetadataList(graphicalNode.getMetadataList());
-
-        // // for bug 11771
-        // IExternalData externalData = graphicalNode.getExternalData();
-        // if (externalData != null) {
-        // newGraphicalNode.setExternalData(externalData);
-        // }
-
-        // IExternalData externalData = graphicalNode.getExternalData();
-
-        IExternalNode externalNode = graphicalNode.getExternalNode();
-        if (externalNode != null) {
-            AbstractExternalData externalEmfData = externalNode.getExternalEmfData();
-            newGraphicalNode.getExternalNode().setExternalEmfData(externalEmfData);
-        }
-        // fwang fixed bug TDI-8027
-        IExternalData externalData = graphicalNode.getExternalData();
-        if (externalData != null) {
-            try {
-                newGraphicalNode.setExternalData(externalData.clone());
-            } catch (CloneNotSupportedException e) {
-                newGraphicalNode.setExternalData(externalData);
-            }
-        }
-
-        copyElementParametersValue(graphicalNode, newGraphicalNode);
-        if (newGraphicalNode.getComponentProperties() != null) {
-            List<Form> forms = newGraphicalNode.getComponentProperties().getForms();
-            for (Form form : forms) {
-                newGraphicalNode.getComponentProperties().refreshLayout(form);
-            }
-        }
-        newGraphicalNode.setDummy(graphicalNode.isDummy());
-
-        ValidationRulesUtil.createRejectConnector(newGraphicalNode);
-        ValidationRulesUtil.updateRejectMetatable(newGraphicalNode, graphicalNode);
-
+        Node newGraphicalNode = cloneGraphicalNode(process, graphicalNode);
         NodeContainer nc = ((Process) process).loadNodeContainer(newGraphicalNode, false);
-
         ((Process) process).addNodeContainer(nc);
+
+        if(buildGraphicalMap == null){
+            initialize();
+        }
         buildGraphicalMap.put(graphicalNode, newGraphicalNode);
 
-        IConnection dataConnec;
         for (IConnection connection : (List<IConnection>) graphicalNode.getOutgoingConnections()) {
             if (!connection.isActivate()) {
                 continue;
@@ -3161,8 +3181,9 @@ public class DataProcess implements IGeneratingProcess {
             }
             INode target = buildNodeFromNode(connTarget, process);
 
-            dataConnec = new Connection(newGraphicalNode, target, connection.getLineStyle(), connection.getConnectorName(),
-                    connection.getMetaName(), connection.getName(), connection.getUniqueName(), connection.isMonitorConnection());
+            IConnection dataConnec = new Connection(newGraphicalNode, target, connection.getLineStyle(),
+                    connection.getConnectorName(), connection.getMetaName(), connection.getName(), connection.getUniqueName(),
+                    connection.isMonitorConnection());
             // incomingConnections = (List<Connection>) target.getIncomingConnections();
             // if (incomingConnections == null) {
             // incomingConnections = new ArrayList<Connection>();
@@ -3172,6 +3193,7 @@ public class DataProcess implements IGeneratingProcess {
             copyElementParametersValue(connection, dataConnec);
             dataConnec.setTraceConnection(connection.isTraceConnection());
         }
+
         newGraphicalNode.setActivate(graphicalNode.isActivate());
         newGraphicalNode.setStart(graphicalNode.isStart());
         newGraphicalNode.setComponentProperties(graphicalNode.getComponentProperties());
@@ -3179,6 +3201,40 @@ public class DataProcess implements IGeneratingProcess {
         return newGraphicalNode;
     }
 
+    private void buildGraphicalNodeForInputConnections(IProcess process, INode graphicalNode, INode newGraphicalNode,
+            Set<INode> visitedNodes) {
+        if (visitedNodes.contains(graphicalNode)) {
+            return;
+        } else {
+            visitedNodes.add(graphicalNode);
+        }
+        List<IConnection> connections = (List<IConnection>) graphicalNode.getIncomingConnections();
+        if (connections == null || connections.isEmpty()) {
+            return;
+        }
+        for (IConnection connection : connections) {
+            if (!connection.isActivate()) {
+                continue;
+            }
+            INode sourceNode = connection.getSource();
+            // if it exists in the essential nodes, means the input and output are already both created, then no need to
+            // create it again
+            INode newSourceNode = (INode) buildGraphicalMap.get(sourceNode);
+            if (newSourceNode == null) {
+                // if it not exists in the essential nodes, create a new one, and don't put it into the Map!
+                newSourceNode = cloneGraphicalNode(process, sourceNode);
+                NodeContainer nc = ((Process) process).loadNodeContainer((Node) newSourceNode, false);
+                ((Process) process).addNodeContainer(nc);
+                IConnection dataConnec = new Connection(newSourceNode, newGraphicalNode, connection.getLineStyle(),
+                        connection.getConnectorName(), connection.getMetaName(), connection.getName(), connection.getUniqueName(),
+                        connection.isMonitorConnection());
+                copyElementParametersValue(connection, dataConnec);
+                dataConnec.setTraceConnection(connection.isTraceConnection());
+                buildGraphicalNodeForInputConnections(process, sourceNode, newSourceNode, visitedNodes);
+            }
+        }
+    }
+
     /**
      * nrousseau Comment method "buildCopyOfGraphicalNodeList".
      *
@@ -3227,6 +3283,13 @@ public class DataProcess implements IGeneratingProcess {
                 buildNodeFromNode(node, duplicatedProcess);
             }
         }
+        Set<INode> visitedNodes = new HashSet<INode>();
+        Set<Map.Entry> entrySet = buildGraphicalMap.entrySet();
+        for (Map.Entry entry : entrySet) {
+            INode node = (INode) entry.getKey();
+            INode newNode = (INode) entry.getValue();
+            buildGraphicalNodeForInputConnections(duplicatedProcess, node, newNode, visitedNodes);
+        }
 
         // make sure the new tUnite incomingConnections order is the same as the old one. @see
         // Connection.setInputId(int id)

main/plugins/org.talend.designer.core/src/main/java/org/talend/designer/core/model/process/jobsettings/JobSettingsManager.java

@@ -945,7 +945,7 @@ public class JobSettingsManager {
                     .getValue();
             String fileSparator = (String) process.getElementParameter(EParameterName.FIELDSEPARATOR.getName()).getValue();
             tContextLoadNode.getElementParameter(EParameterName.IMPLICIT_TCONTEXTLOAD_FILE.getName()).setValue(inputFile);
-            String regex = FileSeparator.getSeparatorsRegexp(TalendQuoteUtils.removeQuotes(fileSparator));
+            String regex = FileSeparator.getSeparatorsRegexp(fileSparator);
             tContextLoadNode.getElementParameter(JobSettingsConstants.IMPLICIT_TCONTEXTLOAD_REGEX).setValue(regex);
         } else {
             // is db
@@ -1204,7 +1204,7 @@ public class JobSettingsManager {
             realDbTypeForJDBC = ExtractMetaDataUtils.getInstance().getDbTypeByClassName(driverClassValue);
         }
         return realDbTypeForJDBC;
-    }
+    }    
 
     private static List<String> getMetadataChars() {
         String[] metaChars = new String[] { "\\", "^", "$", ".", "?", "|", "[", "+", "*", "{", "(", ")", "}", "]" };
@@ -1213,24 +1213,35 @@ public class JobSettingsManager {
 
     public static class FileSeparator {
 
+        private static List<String> METADATA_CHAR = getMetadataChars();
+
         static String doRegexpQuote(String separators) {
             if (StringUtils.isEmpty(separators)) {
-                return separators;
-            } else if (separators.length() == 1) {
-                if (separators.equals("\\")) { // special \ //$NON-NLS-1$ 
-                    return "\\\\\\" + separators;//$NON-NLS-1$ 
-                } else if (getMetadataChars().contains(separators)) {
-                    return "\\\\" + separators;//$NON-NLS-1$ 
+                return TalendQuoteUtils.addQuotes("");
+            }
+            String filedSeparator = TalendQuoteUtils.removeQuotes(separators);
+            if (filedSeparator.length() == 1) {
+                if (filedSeparator.equals("\\")) { // special \ //$NON-NLS-1$
+                    return TalendQuoteUtils.addQuotes("\\\\\\" + filedSeparator);//$NON-NLS-1$
+                } else if (METADATA_CHAR.contains(filedSeparator)) {
+                    return TalendQuoteUtils.addQuotes("\\\\" + filedSeparator);//$NON-NLS-1$
                 }
-            } else {
-                return doRegexpQuote(separators.substring(0, 1)) + doRegexpQuote(separators.substring(1));
+            } else if (filedSeparator.equals("||")) {// TUP-17232
+                return TalendQuoteUtils.addQuotes("\\\\" + "|" + "\\\\" + "|");//$NON-NLS-1$
             }
             return separators;
         }
 
         static String getSeparatorsRegexp(String fileSeparator) {
-            fileSeparator = TalendQuoteUtils.addQuotes(doRegexpQuote(fileSeparator));
+            fileSeparator = doRegexpQuote(fileSeparator);
             return "\"^([^\"+" + fileSeparator + "+\"]*)\"+" + fileSeparator + "+\"(.*)$\""; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
         }
+
+        private static List<String> getMetadataChars() {
+            String[] metaChars = new String[] { "\\", "^", "$", ".", "?", "|", "[", "+", "*", "{", "(", ")", "}", "]", "\"" };
+            return Arrays.asList(metaChars);
+        }
     }
 }
+
+

main/plugins/org.talend.designer.core/src/main/java/org/talend/designer/core/ui/AbstractMultiPageTalendEditor.java

@@ -110,6 +110,7 @@ import org.talend.core.language.ECodeLanguage;
 import org.talend.core.model.components.IComponent;
 import org.talend.core.model.components.IMultipleComponentManager;
 import org.talend.core.model.context.JobContextManager;
+import org.talend.core.model.general.ModuleNeeded;
 import org.talend.core.model.metadata.builder.connection.Properties;
 import org.talend.core.model.process.IContextManager;
 import org.talend.core.model.process.IContextParameter;
@@ -970,6 +971,16 @@ public abstract class AbstractMultiPageTalendEditor extends MultiPageEditorPart
 
         if (DesignerPlugin.getDefault().getPreferenceStore().getBoolean(TalendDesignerPrefConstants.GENERATE_CODE_WHEN_OPEN_JOB)) {
             generateCode();
+        }else {
+            Set<ModuleNeeded> neededLibraries = CorePlugin.getDefault().getDesignerCoreService()
+                .getNeededLibrariesForProcess(process, false);
+            if (neededLibraries != null) {
+                try {
+            	    CorePlugin.getDefault().getRunProcessService()
+     			        .updateLibraries(neededLibraries, process, new HashSet<ModuleNeeded>());
+     			} catch (Exception e) {
+     		    }
+            }
         }
     }
 

main/plugins/org.talend.designer.core/src/main/java/org/talend/designer/core/ui/editor/cmd/PropertyChangeCommand.java

@@ -296,6 +296,10 @@ public class PropertyChangeCommand extends Command {
             }
             List<? extends IConnection> connections = ((Node) elem).getOutgoingConnections();
             for (IConnection connection : connections) {
+                if (!connection.getName().equals(oldELTValue)) {
+                    //do nothing when custom connection name.
+                    continue;
+                }
                 INode targetNode = connection.getTarget();
                 String componentName = targetNode.getComponent().getName();
                 if (componentName.matches("tELT.+Map")) { //$NON-NLS-1$

main/plugins/org.talend.designer.core/src/main/java/org/talend/designer/core/ui/editor/nodes/Node.java

@@ -2869,12 +2869,15 @@ public class Node extends Element implements IGraphicalNode {
                 case COMPONENT_LIST:
                     if (param != null) {
                         String errorMessage;
+                        boolean isContextMode = false;
                         if (param.getValue() == null || "".equals(param.getValue())) { //$NON-NLS-1$
                             errorMessage = Messages.getString("Node.parameterEmpty", param.getDisplayName()); //$NON-NLS-1$
                         } else {
                             errorMessage = Messages.getString("Node.parameterNotExist", param.getDisplayName(), param.getValue()); //$NON-NLS-1$
+                            isContextMode = param.isDynamicSettings();
                         }
-                        if ((!hasUseExistingConnection(this)) || (isUseExistedConnetion(this))) {
+
+                        if (!isContextMode && ((!hasUseExistingConnection(this)) || (isUseExistedConnetion(this)))) {
                             List<INode> list = (List<INode>) this.getProcess().getNodesOfType(param.getFilter());
                             if (list == null || list.size() == 0 || list.isEmpty()) {
                                 Problems.add(ProblemStatus.ERROR, this, errorMessage);

main/plugins/org.talend.designer.core/src/main/java/org/talend/designer/core/ui/editor/process/Process.java

@@ -1351,6 +1351,34 @@ public class Process extends Element implements IProcess2, IGEFProcess, ILastVer
                             }
                         }
                         loadElementParameters(elemParam, pType, param, pType.getName(), paraValue, false);
+                    } else {
+                        boolean canAddElementParameter = false;
+                        String paramName = pType.getName();
+                        if (EParameterName.ACTIVE_DATABASE_DELIMITED_IDENTIFIERS.getName().equals(paramName)) {
+                            canAddElementParameter = true;
+                        }
+                        if (canAddElementParameter) {
+                            param = new ElementParameter(elemParam);
+                            param.setValue(pType.getValue());
+                            param.setName(pType.getName());
+                            param.setCategory(EComponentCategory.TECHNICAL);
+                            String fieldName = pType.getField();
+                            EParameterFieldType fieldType = null;
+                            if (StringUtils.isNotBlank(fieldName)) {
+                                fieldType = EParameterFieldType.valueOf(fieldName);
+                            }
+                            if (fieldType == null) {
+                                ExceptionHandler.process(new Exception("Can't find filed of " + fieldName));
+                                continue;
+                            }
+                            param.setFieldType(fieldType);
+                            param.setNumRow(99);
+                            param.setShow(false);
+                            param.setReadOnly(false);
+                            elemParam.addElementParameter(param);
+                            param = null;
+                            continue;
+                        }
                     }
                 }
             }

main/plugins/org.talend.designer.core/src/main/java/org/talend/designer/core/ui/editor/properties/controllers/AbstractElementPropertySectionController.java

@@ -1483,12 +1483,16 @@ public abstract class AbstractElementPropertySectionController implements Proper
 
         String driverClass = getValueFromRepositoryName(element, EConnectionParameterName.DRIVER_CLASS.getName(),
                 basePropertyParameter);
-        String dbVersion = getValueFromRepositoryName(element, "DB_VERSION", basePropertyParameter);
-        connParameters.setDbVersion(dbVersion);
-        if (EDatabaseVersion4Drivers.VERTICA_5_1.getVersionValue().equals(dbVersion)
-                || EDatabaseVersion4Drivers.VERTICA_6.getVersionValue().equals(dbVersion)
-                || EDatabaseVersion4Drivers.VERTICA_6_1_X.getVersionValue().equals(dbVersion)
-                || EDatabaseVersion4Drivers.VERTICA_7.getVersionValue().equals(dbVersion)) {
+        String driverName = getValueFromRepositoryName(element, "DB_VERSION", basePropertyParameter); //$NON-NLS-1$
+        if (StringUtils.isBlank(driverName) && EDatabaseTypeName.MSSQL.getDisplayName().equals(connParameters.getDbType())) {
+            driverName = getValueFromRepositoryName(element, "DRIVER", basePropertyParameter); //$NON-NLS-1$
+        }
+        String dbVersionName = EDatabaseVersion4Drivers.getDbVersionName(type, driverName);
+        connParameters.setDbVersion(dbVersionName);
+        if (EDatabaseVersion4Drivers.VERTICA_5_1.getVersionValue().equals(dbVersionName)
+                || EDatabaseVersion4Drivers.VERTICA_6.getVersionValue().equals(dbVersionName)
+                || EDatabaseVersion4Drivers.VERTICA_6_1_X.getVersionValue().equals(dbVersionName)
+                || EDatabaseVersion4Drivers.VERTICA_7.getVersionValue().equals(dbVersionName)) {
             driverClass = EDatabase4DriverClassName.VERTICA2.getDriverClass();
         }
 

main/plugins/org.talend.designer.core/src/main/java/org/talend/designer/core/utils/JavaProcessUtil.java

@@ -42,6 +42,7 @@ import org.talend.core.model.properties.Item;
 import org.talend.core.model.properties.ProcessItem;
 import org.talend.core.model.utils.ContextParameterUtils;
 import org.talend.core.model.utils.TalendTextUtils;
+import org.talend.core.runtime.process.LastGenerationInfo;
 import org.talend.designer.core.IDesignerCoreService;
 import org.talend.designer.core.model.components.EParameterName;
 import org.talend.designer.core.model.components.EmfComponent;
@@ -178,6 +179,9 @@ public class JavaProcessUtil {
             Set<ModuleNeeded> nodeNeededModules = getNeededModules(node, searchItems, withChildrens, forMR);
             if (nodeNeededModules != null) {
                 modulesNeeded.addAll(nodeNeededModules);
+                if (node.getComponent().getName().equals("tLibraryLoad")) { //$NON-NLS-1$
+                    LastGenerationInfo.getInstance().getHighPriorityModuleNeeded().addAll(nodeNeededModules);
+                }
             }
         }
 

main/plugins/org.talend.designer.dbmap/src/main/java/messages.properties

@@ -68,7 +68,9 @@ ToolbarInputZone.widgetTooltip.removeAlias=Remove alias
 ToolbarOutputZone.widgetTooltip.addOutputTable=Add output table
 ToolbarOutputZone.widgetTooltip.removeOutputTable=Remove selected output table
 ToolbarOutputZone.widgetTooltip.mapInputAndOutput=Map automatically inputs and outputs (for empty expressions only)
+ToolbarOutputZone.widgetTooltip.delimitedIdentifiers=Active me to add double quotes for schemas to support delimited identifiers.
 ToolbarOutputZone.widgetText.autoMap=Auto map\!
+ToolbarOutputZone.widgetText.delimitedIdentifiers=Delimited identifiers
 
 EntryContentProposal.metadataColumn=Metadata column
 EntryContentProposal.properties=properties :

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/DbMapComponent.java

@@ -29,16 +29,21 @@ import org.talend.core.model.components.IODataComponentContainer;
 import org.talend.core.model.genhtml.HTMLDocUtils;
 import org.talend.core.model.metadata.ColumnNameChanged;
 import org.talend.core.model.metadata.IMetadataTable;
+import org.talend.core.model.process.EComponentCategory;
+import org.talend.core.model.process.EParameterFieldType;
 import org.talend.core.model.process.IComponentDocumentation;
 import org.talend.core.model.process.IConnection;
 import org.talend.core.model.process.IElementParameter;
 import org.talend.core.model.process.IExternalData;
 import org.talend.core.model.process.IExternalNode;
+import org.talend.core.model.process.INode;
 import org.talend.core.model.process.Problem;
 import org.talend.core.model.process.node.IExternalMapEntry;
 import org.talend.core.model.temp.ECodePart;
 import org.talend.designer.abstractmap.AbstractMapComponent;
 import org.talend.designer.codegen.ICodeGeneratorService;
+import org.talend.designer.core.model.components.EParameterName;
+import org.talend.designer.core.model.components.ElementParameter;
 import org.talend.designer.core.model.utils.emf.talendfile.AbstractExternalData;
 import org.talend.designer.core.ui.editor.connections.Connection;
 import org.talend.designer.dbmap.external.converter.ExternalNodeUtils;
@@ -159,6 +164,23 @@ public class DbMapComponent extends AbstractMapComponent {
      */
     @Override
     public void restoreMapperModelFromInternalData() {
+        INode origNode = getOriginalNode();
+        if (origNode != null) {
+            IElementParameter activeDelimitedIdentifiersEP = origNode
+                    .getElementParameter(EParameterName.ACTIVE_DATABASE_DELIMITED_IDENTIFIERS.getName());
+            if (activeDelimitedIdentifiersEP == null) {
+                activeDelimitedIdentifiersEP = new ElementParameter(origNode);
+                activeDelimitedIdentifiersEP.setShow(false);
+                activeDelimitedIdentifiersEP.setFieldType(EParameterFieldType.TEXT);
+                activeDelimitedIdentifiersEP.setName(EParameterName.ACTIVE_DATABASE_DELIMITED_IDENTIFIERS.getName());
+                activeDelimitedIdentifiersEP.setCategory(EComponentCategory.TECHNICAL);
+                activeDelimitedIdentifiersEP.setNumRow(99);
+                activeDelimitedIdentifiersEP.setReadOnly(false);
+                List<IElementParameter> elemParams = (List<IElementParameter>) origNode.getElementParameters();
+                elemParams.add(activeDelimitedIdentifiersEP);
+            }
+            activeDelimitedIdentifiersEP.setValue(getGenerationManager().isUseDelimitedIdentifiers());
+        }
         mapperMain.loadModelFromInternalData();
         metadataListOut = mapperMain.getMetadataListOut();
         externalData = mapperMain.buildExternalData();
@@ -572,11 +594,37 @@ public class DbMapComponent extends AbstractMapComponent {
             } else {
                 throw new IllegalArgumentException(Messages.getString("DbMapComponent.unknowValue") + value); //$NON-NLS-1$
             }
+            updateUseDelimitedIdentifiersStatus();
         }
 
         return generationManager;
     }
 
+    @Override
+    public void setOriginalNode(INode originalNode) {
+        super.setOriginalNode(originalNode);
+        updateUseDelimitedIdentifiersStatus();
+    }
+
+    private void updateUseDelimitedIdentifiersStatus() {
+        if (generationManager == null) {
+            return;
+        }
+        INode oriNode = getOriginalNode();
+        if (oriNode != null) {
+            IElementParameter activeDelimitedIdentifiersEP = oriNode
+                    .getElementParameter(EParameterName.ACTIVE_DATABASE_DELIMITED_IDENTIFIERS.getName());
+            boolean activeDelimitedIdentifiers = false;
+            if (activeDelimitedIdentifiersEP != null) {
+                Object value = activeDelimitedIdentifiersEP.getValue();
+                if (value != null) {
+                    activeDelimitedIdentifiers = Boolean.valueOf(value.toString());
+                }
+            }
+            generationManager.setUseDelimitedIdentifiers(activeDelimitedIdentifiers);
+        }
+    }
+
     /*
      * (non-Javadoc)
      * 

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/command/UpdateELTMapComponentCommand.java

@@ -2,6 +2,7 @@ package org.talend.designer.dbmap.command;
 
 import java.util.List;
 
+import org.apache.commons.lang3.StringUtils;
 import org.eclipse.gef.commands.Command;
 import org.talend.core.model.process.IConnection;
 import org.talend.core.model.process.INode;
@@ -36,6 +37,8 @@ public class UpdateELTMapComponentCommand extends Command {
 
     private void execute(String oldValue, String newValue) {
         connection.setName(newValue);
+        // may have several tables with different aliases.
+        boolean isAliasIncludeTableName = false;
         // update table name
         for (IExternalMapTable input : newInputTables) {
             if (input instanceof ExternalDbMapTable) {
@@ -43,6 +46,12 @@ public class UpdateELTMapComponentCommand extends Command {
                 if (oldValue.equals(dbMapTable.getName()) || oldValue.equals(dbMapTable.getTableName())) {
                     dbMapTable.setName(newValue);
                     dbMapTable.setTableName(newValue);
+                    String alias = dbMapTable.getAlias();
+                    if (alias != null) {
+                        if (alias.contains(oldValue)) {
+                            isAliasIncludeTableName = true;
+                        }
+                    }
                 }
             }
         }
@@ -52,15 +61,8 @@ public class UpdateELTMapComponentCommand extends Command {
                 List<ExternalDbMapEntry> entries = ((ExternalDbMapTable) output).getMetadataTableEntries();
                 for (ExternalDbMapEntry entry : entries) {
                     String expression = entry.getExpression();
-                    if (expression != null && !"".equals(expression.trim())) { //$NON-NLS-1$
-                        int index = expression.lastIndexOf("."); //$NON-NLS-1$
-                        // at least "a.b"
-                        if (index > 0) {
-                            String connectionName = expression.substring(0, index);
-                            if (oldValue.equals(connectionName)) {
-                                entry.setExpression(newValue + expression.substring(index, expression.length()));
-                            }
-                        }
+                    if (!StringUtils.isBlank(expression) && expression.contains(oldValue) && !isAliasIncludeTableName) {
+                        entry.setExpression(expression.replace(oldValue, newValue));
                     }
                 }
             }

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/language/generation/DbGenerationManager.java

@@ -34,9 +34,14 @@ import org.talend.core.model.process.EConnectionType;
 import org.talend.core.model.process.IConnection;
 import org.talend.core.model.process.IContext;
 import org.talend.core.model.process.IContextParameter;
+import org.talend.core.model.process.IElementParameter;
+import org.talend.core.model.process.IExternalNode;
 import org.talend.core.model.process.INode;
 import org.talend.core.model.process.IProcess;
 import org.talend.core.model.utils.ContextParameterUtils;
+import org.talend.core.model.utils.TalendTextUtils;
+import org.talend.core.utils.TalendQuoteUtils;
+import org.talend.designer.core.model.components.EParameterName;
 import org.talend.designer.dbmap.DbMapComponent;
 import org.talend.designer.dbmap.external.data.ExternalDbMapData;
 import org.talend.designer.dbmap.external.data.ExternalDbMapEntry;
@@ -70,6 +75,14 @@ public abstract class DbGenerationManager {
     protected String tabSpaceString = DEFAULT_TAB_SPACE_STRING;
 
     protected static final String DEFAULT_TAB_SPACE_STRING = ""; //$NON-NLS-1$
+    
+    protected List<String> queryColumnsSegments = new ArrayList<String>();
+    
+    protected List<String> querySegments = new ArrayList<String>();
+
+    private Boolean useDelimitedIdentifiers;
+    
+    protected INode source;
 
     /**
      * DOC amaumont GenerationManager constructor comment.
@@ -233,7 +246,12 @@ public abstract class DbGenerationManager {
      * @return
      */
     public String buildSqlSelect(DbMapComponent component, String outputTableName) {
-        return buildSqlSelect(component, outputTableName, DEFAULT_TAB_SPACE_STRING);
+        boolean checkUseUpdateStatement = checkUseUpdateStatement(component, outputTableName);
+        if (checkUseUpdateStatement) {
+            return buildSqlSelect(component, outputTableName, DEFAULT_TAB_SPACE_STRING, checkUseUpdateStatement);
+        } else {
+            return buildSqlSelect(component, outputTableName, DEFAULT_TAB_SPACE_STRING);
+        }
     }
 
     protected String getAliasOf(String tableName) {
@@ -249,10 +267,14 @@ public abstract class DbGenerationManager {
      * @param tabSpaceString
      * @return
      */
-    public String buildSqlSelect(DbMapComponent component, String outputTableName, String tabString) {
+    public String buildSqlSelect(DbMapComponent dbMapComponent, String outputTableName, String tabString) {
         queryColumnsName = "\""; //$NON-NLS-1$
         aliasAlreadyDeclared.clear();
+        queryColumnsSegments.clear();
+        querySegments.clear();
+        
         this.tabSpaceString = tabString;
+        DbMapComponent component = getDbMapComponent(dbMapComponent);
 
         List<IConnection> outputConnections = (List<IConnection>) component.getOutgoingConnections();
 
@@ -288,10 +310,10 @@ public abstract class DbGenerationManager {
                     // outputTable = removeUnmatchingEntriesWithColumnsOfMetadataTable(outputTable, metadataTable);
                 }
             }
-            sb.append("\""); //$NON-NLS-1$
-            sb.append(DbMapSqlConstants.SELECT);
-            sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
-
+            appendSqlQuery(sb, "\"", false); //$NON-NLS-1$
+            appendSqlQuery(sb, DbMapSqlConstants.SELECT);
+            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+            appendSqlQuery(sb, tabSpaceString);
             List<ExternalDbMapEntry> metadataTableEntries = outputTable.getMetadataTableEntries();
             if (metadataTableEntries != null) {
                 int lstSizeOutTableEntries = metadataTableEntries.size();
@@ -311,28 +333,29 @@ public abstract class DbGenerationManager {
                         expression += DbMapSqlConstants.SPACE + DbMapSqlConstants.AS + DbMapSqlConstants.SPACE
                                 + getAliasOf(dbMapEntry.getName());
                     }
+                    String columnSegment = expression;
                     if (i > 0) {
-                        sb.append(DbMapSqlConstants.COMMA);
-                        sb.append(DbMapSqlConstants.SPACE);
-
+                        appendSqlQuery(sb, DbMapSqlConstants.COMMA);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
                         queryColumnsName += DbMapSqlConstants.COMMA + DbMapSqlConstants.SPACE;
+                        columnSegment = DbMapSqlConstants.COMMA + DbMapSqlConstants.SPACE + columnSegment;
                     }
                     if (expression != null && expression.trim().length() > 0) {
-                        sb.append(expression);
-
+                        appendSqlQuery(sb, expression);
                         queryColumnsName += expression;
+                        queryColumnsSegments.add(columnSegment);
                     } else {
-                        sb.append(DbMapSqlConstants.LEFT_COMMENT);
+                        appendSqlQuery(sb, DbMapSqlConstants.LEFT_COMMENT);
                         String str = outputTable.getName() + DbMapSqlConstants.DOT + dbMapEntry.getName();
-                        sb.append(Messages.getString("DbGenerationManager.OuputExpSetMessage", str)); //$NON-NLS-1$
-                        sb.append(DbMapSqlConstants.RIGHT_COMMENT);
+                        appendSqlQuery(sb, Messages.getString("DbGenerationManager.OuputExpSetMessage", str));//$NON-NLS-1$
+                        appendSqlQuery(sb, DbMapSqlConstants.RIGHT_COMMENT);
                     }
                 }
             }
 
-            sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
-            sb.append(DbMapSqlConstants.FROM);
-
+            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+            appendSqlQuery(sb, tabSpaceString);
+            appendSqlQuery(sb, DbMapSqlConstants.FROM);
             List<ExternalDbMapTable> inputTables = data.getInputTables();
 
             // load input table in hash
@@ -358,8 +381,8 @@ public abstract class DbGenerationManager {
                 }
             }
 
-            sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
-
+            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+            appendSqlQuery(sb, tabSpaceString);
             IJoinType previousJoinType = null;
 
             for (int i = 0; i < lstSizeInputTables; i++) {
@@ -381,13 +404,14 @@ public abstract class DbGenerationManager {
                             buildTableDeclaration(component, sb, inputTables.get(i - 1), commaCouldBeAdded, crCouldBeAdded, true);
                             previousJoinType = joinType;
                         } else {
-                            sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
+                            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                            appendSqlQuery(sb, tabSpaceString);
                         }
-                        sb.append(DbMapSqlConstants.SPACE);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
                     }
                     String labelJoinType = joinType.getLabel();
-                    sb.append(labelJoinType);
-                    sb.append(DbMapSqlConstants.SPACE);
+                    appendSqlQuery(sb, labelJoinType);
+                    appendSqlQuery(sb, DbMapSqlConstants.SPACE);
                     if (joinType == AbstractDbLanguage.JOIN.CROSS_JOIN) {
                         ExternalDbMapTable nextTable = null;
                         if (i < lstSizeInputTables) {
@@ -403,19 +427,19 @@ public abstract class DbGenerationManager {
                         // } else {
                         // sb.append(" <!! NO JOIN CLAUSES FOR '" + inputTable.getName() + "' !!> ");
                         // }
-                        sb.append(DbMapSqlConstants.SPACE);
-                        sb.append(DbMapSqlConstants.ON);
-                        sb.append(DbMapSqlConstants.LEFT_BRACKET);
-                        sb.append(DbMapSqlConstants.SPACE);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                        appendSqlQuery(sb, DbMapSqlConstants.ON);
+                        appendSqlQuery(sb, DbMapSqlConstants.LEFT_BRACKET);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
                         if (!buildConditions(component, sb, inputTable, true, true)) {
-                            sb.append(DbMapSqlConstants.LEFT_COMMENT);
-                            sb.append(DbMapSqlConstants.SPACE);
-                            sb.append(Messages.getString("DbGenerationManager.conditionNotSet")); //$NON-NLS-1$
-                            sb.append(DbMapSqlConstants.SPACE);
-                            sb.append(DbMapSqlConstants.RIGHT_COMMENT);
+                            appendSqlQuery(sb, DbMapSqlConstants.LEFT_COMMENT);
+                            appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                            appendSqlQuery(sb, Messages.getString("DbGenerationManager.conditionNotSet"));//$NON-NLS-1$
+                            appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                            appendSqlQuery(sb, DbMapSqlConstants.RIGHT_COMMENT);
                         }
-                        sb.append(DbMapSqlConstants.SPACE);
-                        sb.append(DbMapSqlConstants.RIGHT_BRACKET);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                        appendSqlQuery(sb, DbMapSqlConstants.RIGHT_BRACKET);
                     }
 
                 }
@@ -473,35 +497,39 @@ public abstract class DbGenerationManager {
 
             boolean whereOriginalFlag = !originalWhereAddition.isEmpty();
             if (whereFlag || whereAddFlag || whereOriginalFlag) {
-                sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
-                sb.append(DbMapSqlConstants.WHERE);
+                appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                appendSqlQuery(sb, tabSpaceString);
+                appendSqlQuery(sb, DbMapSqlConstants.WHERE);
             }
             if (whereFlag) {
-                sb.append(whereClauses);
+                appendSqlQuery(sb, whereClauses);
             }
             if (whereAddFlag) {
                 for (int i = 0; i < whereAddition.size(); i++) {
                     if (i == 0 && whereFlag || i > 0) {
-                        sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
-                        sb.append(DbMapSqlConstants.SPACE);
-                        sb.append(DbMapSqlConstants.AND);
+                        appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                        appendSqlQuery(sb, tabSpaceString);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                        appendSqlQuery(sb, DbMapSqlConstants.AND);
                     }
-                    sb.append(DbMapSqlConstants.SPACE);
-                    sb.append(whereAddition.get(i));
+                    appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                    appendSqlQuery(sb, whereAddition.get(i));
                 }
             }
             if (whereOriginalFlag) {
                 for (String s : originalWhereAddition) {
-                    sb.append(DbMapSqlConstants.NEW_LINE);
-                    sb.append(DbMapSqlConstants.SPACE);
-                    sb.append(s);
+                    appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                    appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                    appendSqlQuery(sb, s);
                 }
             }
             if (!otherAddition.isEmpty()) {
-                sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
+                appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                appendSqlQuery(sb, tabSpaceString);
                 for (String s : otherAddition) {
-                    sb.append(s);
-                    sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
+                    appendSqlQuery(sb, s);
+                    appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                    appendSqlQuery(sb, tabSpaceString);
                 }
             }
         }
@@ -514,9 +542,11 @@ public abstract class DbGenerationManager {
                     sqlQuery = sqlQuery.replaceAll("\\b" + context + "\\b", "\" +" + context + "+ \""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
                     haveReplace = true;
                 }
+                replaceQueryContext(querySegments, context);
                 if (queryColumnsName.contains(context)) {
                     queryColumnsName = queryColumnsName.replaceAll("\\b" + context + "\\b", "\" +" + context + "+ \""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
                 }
+                replaceQueryContext(queryColumnsSegments, context);
             }
             if (!haveReplace) {
                 List<String> connContextList = getConnectionContextList(component);
@@ -524,9 +554,11 @@ public abstract class DbGenerationManager {
                     if (sqlQuery.contains(context)) {
                         sqlQuery = sqlQuery.replaceAll("\\b" + context + "\\b", "\" +" + context + "+ \""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
                     }
+                    replaceQueryContext(querySegments, context);
                     if (queryColumnsName.contains(context)) {
                         queryColumnsName = queryColumnsName.replaceAll("\\b" + context + "\\b", "\" +" + context + "+ \""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
                     }
+                    replaceQueryContext(queryColumnsSegments, context);
                 }
             }
         }
@@ -535,6 +567,335 @@ public abstract class DbGenerationManager {
 
         return sqlQuery;
     }
+    
+    public String buildSqlSelect(DbMapComponent dbMapComponent, String outputTableName, String tabString,
+            boolean checkUseUpdateStatement) {
+        queryColumnsName = "\""; //$NON-NLS-1$
+        aliasAlreadyDeclared.clear();
+        queryColumnsSegments.clear();
+        querySegments.clear();
+
+        this.tabSpaceString = tabString;
+        DbMapComponent component = getDbMapComponent(dbMapComponent);
+
+        List<IConnection> outputConnections = (List<IConnection>) component.getOutgoingConnections();
+
+        Map<String, IConnection> nameToOutputConnection = new HashMap<String, IConnection>();
+        for (IConnection connection : outputConnections) {
+            nameToOutputConnection.put(connection.getUniqueName(), connection);
+        }
+
+        ExternalDbMapData data = (ExternalDbMapData)component.getExternalData();
+        StringBuilder sb = new StringBuilder();
+
+        List<ExternalDbMapTable> outputTables = data.getOutputTables();
+        int lstOutputTablesSize = outputTables.size();
+        ExternalDbMapTable outputTable = null;
+        for (int i = 0; i < lstOutputTablesSize; i++) {
+            ExternalDbMapTable temp = outputTables.get(i);
+            if (outputTableName.equals(temp.getName())) {
+                outputTable = temp;
+                break;
+            }
+        }
+
+        if (outputTable != null) {
+            String outTableName = outputTable.getTableName();
+            IConnection connection = nameToOutputConnection.get(outputTable.getName());
+            List<IMetadataColumn> columns = new ArrayList<IMetadataColumn>();
+            if (connection != null) {
+                IMetadataTable metadataTable = connection.getMetadataTable();
+                if (metadataTable != null) {
+                    columns.addAll(metadataTable.getListColumns());
+                }
+            }
+            // Update
+            String targetSchemaTable = outTableName;
+            IElementParameter eltSchemaNameParam = source.getElementParameter("ELT_SCHEMA_NAME"); //$NON-NLS-1$
+            if (eltSchemaNameParam != null && eltSchemaNameParam.getValue() != null) {
+                String schema = TalendQuoteUtils.removeQuotesIfExist(String.valueOf(eltSchemaNameParam.getValue()));
+                if (org.apache.commons.lang.StringUtils.isNotEmpty(schema)) {
+                    targetSchemaTable = schema + DbMapSqlConstants.DOT + outTableName;
+                }
+            }
+
+            appendSqlQuery(sb, "\"", false); //$NON-NLS-1$
+            appendSqlQuery(sb, DbMapSqlConstants.UPDATE);
+            appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+            appendSqlQuery(sb, targetSchemaTable);
+            appendSqlQuery(sb, tabSpaceString);
+            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+
+            // Set
+            String keyColumn = DbMapSqlConstants.EMPTY;
+            List<ExternalDbMapEntry> metadataTableEntries = outputTable.getMetadataTableEntries();
+            if (metadataTableEntries != null) {
+                appendSqlQuery(sb, "SET"); //$NON-NLS-1$
+                appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                boolean isKey = false;
+                int lstSizeOutTableEntries = metadataTableEntries.size();
+                for (int i = 0; i < lstSizeOutTableEntries; i++) {
+                    ExternalDbMapEntry dbMapEntry = metadataTableEntries.get(i);
+                    String columnEntry = dbMapEntry.getName();
+                    String expression = dbMapEntry.getExpression();
+                    expression = initExpression(component, dbMapEntry);
+                    expression = addQuoteForSpecialChar(expression, component);
+                    //
+                    if (!DEFAULT_TAB_SPACE_STRING.equals(this.tabSpaceString)) {
+                        expression += DbMapSqlConstants.SPACE + DbMapSqlConstants.AS + DbMapSqlConstants.SPACE
+                                + getAliasOf(dbMapEntry.getName());
+                    }
+                    
+                    String columnSegment = expression;
+                    if (i > 0) {
+                        queryColumnsName += DbMapSqlConstants.COMMA + DbMapSqlConstants.SPACE;
+                        columnSegment = DbMapSqlConstants.COMMA + DbMapSqlConstants.SPACE + columnSegment;
+                    }
+                    if (expression != null && expression.trim().length() > 0) {
+                        queryColumnsName += expression;
+                        queryColumnsSegments.add(columnSegment);
+                    }
+                    //
+                    if (!isKey) {
+                        for (IMetadataColumn column : columns) {
+                            String columnName = column.getLabel();
+                            if (columnName.equals(dbMapEntry.getName()) && column.isKey()) {
+                                isKey = column.isKey();
+                                keyColumn = columnEntry + " = " + expression;//$NON-NLS-1$
+                                break;
+                            }
+                        }
+                        if (isKey) {
+                            continue;
+                        }
+                    }
+                    if (expression != null && expression.trim().length() > 0) {
+                        appendSqlQuery(sb, columnEntry + " = " + expression); //$NON-NLS-1$
+                        if (i < lstSizeOutTableEntries - 1) {
+                            appendSqlQuery(sb, DbMapSqlConstants.COMMA);
+                            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                        }
+                    }
+                }
+            }
+            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+
+            // From
+            appendSqlQuery(sb, tabSpaceString);
+            appendSqlQuery(sb, DbMapSqlConstants.FROM);
+
+            List<ExternalDbMapTable> inputTables = data.getInputTables();
+            // load input table in hash
+            boolean explicitJoin = false;
+            int lstSizeInputTables = inputTables.size();
+            Map<String, ExternalDbMapTable> nameToInputTable = new HashMap<String, ExternalDbMapTable>();
+            for (int i = 0; i < lstSizeInputTables; i++) {
+                ExternalDbMapTable inputTable = inputTables.get(i);
+                nameToInputTable.put(inputTable.getName(), inputTable);
+                IJoinType joinType = language.getJoin(inputTable.getJoinType());
+                if (!language.unuseWithExplicitJoin().contains(joinType) && i > 0) {
+                    explicitJoin = true;
+                }
+            }
+            appendSqlQuery(sb, tabSpaceString);
+
+            for (int i = 0; i < lstSizeInputTables; i++) {
+                ExternalDbMapTable inputTable = inputTables.get(i);
+                IJoinType joinType = null;
+                if (i == 0) {
+                    joinType = AbstractDbLanguage.JOIN.NO_JOIN;
+                } else {
+                    joinType = language.getJoin(inputTable.getJoinType());
+                }
+                boolean commaCouldBeAdded = !explicitJoin && i > 0;
+                if (language.unuseWithExplicitJoin().contains(joinType) && !explicitJoin) {
+                    buildTableDeclaration(component, sb, inputTable, commaCouldBeAdded, false, false);
+                }
+            }
+
+            // where
+            StringBuilder sbWhere = new StringBuilder();
+            this.tabSpaceString = DEFAULT_TAB_SPACE_STRING;
+            boolean isFirstClause = true;
+            for (int i = 0; i < lstSizeInputTables; i++) {
+                ExternalDbMapTable inputTable = inputTables.get(i);
+                if (buildConditions(component, sbWhere, inputTable, false, isFirstClause)) {
+                    isFirstClause = false;
+                }
+            }
+            /*
+             * for addition conditions
+             */
+            // like as input.newcolumn1>100
+            List<String> whereAddition = new ArrayList<String>();
+            // olny pure start with group or order, like as order/group by input.newcolumn1
+            // List<String> byAddition = new ArrayList<String>();
+            // like as input.newcolumn1>100 group/oder by input.newcolumn1
+            // List<String> containWhereAddition = new ArrayList<String>();
+            // like as "OR/AND input.newcolumn1", will keep original
+            List<String> originalWhereAddition = new ArrayList<String>();
+            List<String> otherAddition = new ArrayList<String>();
+
+            if (outputTable != null) {
+                List<ExternalDbMapEntry> customWhereConditionsEntries = outputTable.getCustomWhereConditionsEntries();
+                if (customWhereConditionsEntries != null) {
+                    for (ExternalDbMapEntry entry : customWhereConditionsEntries) {
+                        String exp = initExpression(component, entry);
+                        if (exp != null && !DbMapSqlConstants.EMPTY.equals(exp.trim())) {
+                            if (containWith(exp, DbMapSqlConstants.OR, true) || containWith(exp, DbMapSqlConstants.AND, true)) {
+                                originalWhereAddition.add(exp);
+                            } else {
+                                whereAddition.add(exp);
+                            }
+                        }
+                    }
+                }
+
+                List<ExternalDbMapEntry> customOtherConditionsEntries = outputTable.getCustomOtherConditionsEntries();
+                if (customOtherConditionsEntries != null) {
+                    for (ExternalDbMapEntry entry : customOtherConditionsEntries) {
+                        String exp = initExpression(component, entry);
+                        if (exp != null && !DbMapSqlConstants.EMPTY.equals(exp.trim())) {
+                            otherAddition.add(exp);
+                        }
+                    }
+                }
+            }
+            this.tabSpaceString = tabString;
+
+            String whereClauses = sbWhere.toString();
+            boolean whereFlag = whereClauses.trim().length() > 0;
+            boolean whereAddFlag = !whereAddition.isEmpty();
+            boolean whereOriginalFlag = !originalWhereAddition.isEmpty();
+            if (whereFlag || whereAddFlag || whereOriginalFlag) {
+                appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                appendSqlQuery(sb, tabSpaceString);
+                appendSqlQuery(sb, DbMapSqlConstants.WHERE);
+            }
+            if (whereFlag) {
+                appendSqlQuery(sb, whereClauses);
+            }
+            if (whereAddFlag) {
+                for (int i = 0; i < whereAddition.size(); i++) {
+                    if (i == 0 && whereFlag || i > 0) {
+                        appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                        appendSqlQuery(sb, tabSpaceString);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                        appendSqlQuery(sb, DbMapSqlConstants.AND);
+                    }
+                    appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                    appendSqlQuery(sb, whereAddition.get(i));
+                }
+            }
+            if (whereOriginalFlag) {
+                for (String s : originalWhereAddition) {
+                    appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                    appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                    appendSqlQuery(sb, s);
+                }
+            }
+            if (!otherAddition.isEmpty()) {
+                appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                appendSqlQuery(sb, tabSpaceString);
+                for (String s : otherAddition) {
+                    appendSqlQuery(sb, s);
+                    appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                    appendSqlQuery(sb, tabSpaceString);
+                }
+            }
+        }
+
+        String sqlQuery = sb.toString();
+        sqlQuery = handleQuery(sqlQuery);
+        queryColumnsName = handleQuery(queryColumnsName);
+        return sqlQuery;
+    }
+
+    protected DbMapComponent getDbMapComponent(DbMapComponent dbMapComponent) {
+        DbMapComponent component = dbMapComponent;
+        INode realGraphicalNode = dbMapComponent.getRealGraphicalNode();
+        if (realGraphicalNode != null) {
+            IExternalNode externalNode = realGraphicalNode.getExternalNode();
+            if (externalNode instanceof DbMapComponent) {
+                component = (DbMapComponent) externalNode;
+            }
+        }
+        checkParameters(component);
+        return component;
+    }
+
+    protected void checkParameters(DbMapComponent component) {
+        checkUseDelimitedIdentifiers(component);
+    }
+    
+    protected boolean checkUseUpdateStatement(DbMapComponent dbMapComponent, String outputTableName) {
+        List<IConnection> outputConnections = (List<IConnection>) dbMapComponent.getOutgoingConnections();
+        if (outputConnections != null) {
+            IConnection iconn = this.getConnectonByMetadataName(outputConnections, outputTableName);
+            if (iconn != null&&iconn.getTarget()!=null) {
+                source = iconn.getTarget();
+                IElementParameter useUpdateStatementParam = source.getElementParameter("USE_UPDATE_STATEMENT"); //$NON-NLS-1$
+                if (useUpdateStatementParam != null && useUpdateStatementParam.isShow(source.getElementParameters())
+                        && useUpdateStatementParam.getValue() != null) {
+                    return Boolean.valueOf(useUpdateStatementParam.getValue().toString());
+                }
+            }
+        }
+        return false;
+    }
+
+    protected void checkUseDelimitedIdentifiers(DbMapComponent component) {
+        /**
+         * in elt related component javajets(like tELTMSSqlMap_main.javajet), they don't get DbGenerationManager by
+         * DbMapComponent#getGenerationManager() while they construct a new manager manually, so some parameters may not
+         * be initialised, then need to check these parameters here manually to make sure they are initialised.
+         */
+        if (this.useDelimitedIdentifiers == null) {
+            this.useDelimitedIdentifiers = false;
+            IElementParameter activeDelimitedIdentifiersEP = component
+                    .getElementParameter(EParameterName.ACTIVE_DATABASE_DELIMITED_IDENTIFIERS.getName());
+            if (activeDelimitedIdentifiersEP != null) {
+                Object value = activeDelimitedIdentifiersEP.getValue();
+                if (value != null) {
+                    setUseDelimitedIdentifiers(Boolean.valueOf(value.toString()));
+                }
+            }
+        }
+    }
+
+    protected void replaceQueryContext(List<String> querySegments, String context) {
+        if (querySegments == null || querySegments.size() == 0) {
+            return;
+        }
+        for (int i = 0; i < querySegments.size(); i++) {
+            String segment = querySegments.get(i);
+            if (segment.contains(context)) {
+                segment = segment.replaceAll("\\b" + context + "\\b", "\" +" + context + "+ \""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+                querySegments.set(i, segment);
+            }
+        }
+    }
+
+    protected void appendSqlQuery(StringBuilder sb, String value) {
+        appendSqlQuery(sb, value, true);
+    }
+
+    protected void appendSqlQuery(StringBuilder sb, String value, boolean addToQuerySegment) {
+        if (!"".equals(value)) {//$NON-NLS-1$
+            sb.append(value);
+            if (addToQuerySegment) {
+                querySegments.add(value);
+            }
+        }
+    }
+
+    public List<String> getQuerySegments() {
+        return querySegments;
+    }
+
+    public List<String> getQueryColumnsSegments() {
+        return queryColumnsSegments;
+    }
 
     protected String handleQuery(String query) {
         if (query != null) {
@@ -645,6 +1006,7 @@ public abstract class DbGenerationManager {
             } else {
                 tableName = getHandledField(table.getAlias());
             }
+            entryName = getColumnName(null, entryName);
             String locationInputEntry = language.getLocation(tableName, getHandledField(entryName));
             sbWhere.append(DbMapSqlConstants.SPACE);
             sbWhere.append(locationInputEntry);
@@ -697,7 +1059,7 @@ public abstract class DbGenerationManager {
      */
     protected void buildTableDeclaration(DbMapComponent component, StringBuilder sb, ExternalDbMapTable inputTable,
             boolean commaCouldBeAdded, boolean crCouldBeAdded, boolean writingInJoin) {
-        sb.append(DbMapSqlConstants.SPACE);
+        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
         String alias = inputTable.getAlias();
         if (alias != null) {
             List<IConnection> inputConnections = (List<IConnection>) component.getIncomingConnections();
@@ -714,31 +1076,34 @@ public abstract class DbGenerationManager {
                 buildTableDeclaration(component, sb, inputTable);
             } else if (!aliasAlreadyDeclared.contains(inputTable.getName())) {
                 if (crCouldBeAdded) {
-                    sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
+                    appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                    appendSqlQuery(sb, tabSpaceString);
                 }
                 if (commaCouldBeAdded) {
-                    sb.append(DbMapSqlConstants.COMMA);
-                    sb.append(DbMapSqlConstants.SPACE);
+                    appendSqlQuery(sb, DbMapSqlConstants.COMMA);
+                    appendSqlQuery(sb, DbMapSqlConstants.SPACE);
                 }
-                sb.append(getHandledTableName(component, inputTable.getTableName()));
-                sb.append(DbMapSqlConstants.SPACE);
-                sb.append(getHandledField(alias));
+                String handledTableName = getHandledTableName(component, inputTable.getTableName());
+                appendSqlQuery(sb, handledTableName);
+                appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                String handledField = getHandledField(alias);
+                appendSqlQuery(sb, handledField);
                 aliasAlreadyDeclared.add(alias);
             } else {
                 if (writingInJoin) {
-                    sb.append(getHandledTableName(component, inputTable.getName()));
+                    appendSqlQuery(sb, getHandledTableName(component, inputTable.getName()));
                 }
             }
         } else {
             if (crCouldBeAdded) {
-                sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
+                appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                appendSqlQuery(sb, tabSpaceString);
             }
             if (commaCouldBeAdded) {
-                sb.append(DbMapSqlConstants.COMMA);
-                sb.append(DbMapSqlConstants.SPACE);
+                appendSqlQuery(sb, DbMapSqlConstants.COMMA);
+                appendSqlQuery(sb, DbMapSqlConstants.SPACE);
             }
             buildTableDeclaration(component, sb, inputTable);
-
         }
     }
 
@@ -754,6 +1119,19 @@ public abstract class DbGenerationManager {
         }
         return retConnection;
     }
+    
+    protected IConnection getConnectonByMetadataName(List<IConnection> connections, String metaTableName) {
+        IConnection retConnection = null;
+        for (IConnection iconn : connections) {
+            IMetadataTable metadataTable = iconn.getMetadataTable();
+            String tName = iconn.getMetaName() != null ? iconn.getMetaName() : iconn.getUniqueName();
+            if (tName.equals(metaTableName) && metadataTable != null) {
+                retConnection = iconn;
+                break;
+            }
+        }
+        return retConnection;
+    }
 
     protected void buildTableDeclaration(DbMapComponent component, StringBuilder sb, ExternalDbMapTable inputTable) {
         Object inConns = component.getIncomingConnections();
@@ -788,9 +1166,15 @@ public abstract class DbGenerationManager {
                 int begin = 1;
                 int end = deliveredTable.length() - 1;
                 if (begin <= end) {
-                    sb.append("(").append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString).append("  "); //$NON-NLS-1$ //$NON-NLS-2$
-                    sb.append(deliveredTable.substring(begin, end)).append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString)
-                            .append(" ) "); //$NON-NLS-1$
+                    appendSqlQuery(sb, "("); //$NON-NLS-1$
+                    appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                    appendSqlQuery(sb, tabSpaceString);
+                    appendSqlQuery(sb, "  "); //$NON-NLS-1$
+
+                    appendSqlQuery(sb, deliveredTable.substring(begin, end));
+                    appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                    appendSqlQuery(sb, tabSpaceString);
+                    appendSqlQuery(sb, " ) "); //$NON-NLS-1$
                 }
             }
             String tableColneName = tableName;
@@ -807,9 +1191,8 @@ public abstract class DbGenerationManager {
                         String tableLabel = tableEntry.getKey();
                         String schemaValue = tableEntry.getValue();
                         if (tableLabel.equals(metadataTable.getLabel()) && tableColneName.equals(tableLabel)) {
-                            sb.append(schemaValue);
-                            sb.append("."); //$NON-NLS-1$
-                            sb.append(tableName);
+                            String name = schemaValue + "." + tableName; //$NON-NLS-1$                            
+                            appendSqlQuery(sb, name);
                             replace = true;
                         }
                     }
@@ -817,16 +1200,14 @@ public abstract class DbGenerationManager {
                 }
             } else if (tableName != null) {
                 if (inputTableName.equals(metadataTable.getLabel()) && tableColneName.equals(inputTableName)) {
-                    sb.append(tableName);
+                    appendSqlQuery(sb, tableName);
                     replace = true;
                 }
             }
             if (!replace) {
-                sb.append(inputTable.getName());
+                appendSqlQuery(sb, inputTable.getName());
             }
-
         }
-
     }
 
     protected static boolean isELTDBMap(INode node) {
@@ -934,16 +1315,24 @@ public abstract class DbGenerationManager {
                                         continue;
                                     }
                                     if (expression.trim().equals(tableValue + "." + oriName)) {
+                                        expression = tableValue + "." + getColumnName(iconn, oriName);
+                                        expression = expression.replace("\"", "\\\"");
                                         continue;
                                     }
                                     if (expression.trim().equals(originaltableName + "." + oriName)) {
+                                        expression = originaltableName + "." + getColumnName(iconn, oriName);
+                                        expression = expression.replace("\"", "\\\"");
                                         continue;
                                     }
                                     // if it is temp delived table, use label to generate sql
                                     if (iconn.getLineStyle() == EConnectionType.TABLE_REF) {
                                         continue;
                                     }
-                                    oriName = oriName.replaceAll("\\$", "\\\\\\$"); //$NON-NLS-1$ //$NON-NLS-2$
+                                    if (!isRefTableConnection(iconn) && isUseDelimitedIdentifiers()) {
+                                        oriName = getColumnName(iconn, oriName);
+                                    } else {
+                                        oriName = oriName.replaceAll("\\$", "\\\\\\$"); //$NON-NLS-1$ //$NON-NLS-2$
+                                    }
                                     expression = expression.replaceFirst("\\." + co.getLabel(), //$NON-NLS-1$
                                             "\\." + oriName); //$NON-NLS-1$
                                     expression = expression.replace("\"", "\\\"");
@@ -1022,8 +1411,43 @@ public abstract class DbGenerationManager {
         return name;
     }
 
+    protected String getColumnName(IConnection conn, String name) {
+        if (!isRefTableConnection(conn) && isUseDelimitedIdentifiers()) {
+            return getNameWithDelimitedIdentifier(name);
+        } else {
+            return name;
+        }
+    }
+
+    protected boolean isRefTableConnection(IConnection conn) {
+        return conn != null && conn.getLineStyle() == EConnectionType.TABLE_REF;
+    }
+
+    protected String getNameWithDelimitedIdentifier(String name) {
+        final String delimitedIdentifier = getDelimitedIdentifiers();
+        String newName = name;
+        newName = newName.replaceAll("\"", "\"\"");
+        newName = delimitedIdentifier + newName + delimitedIdentifier;
+        return newName;
+    }
+
+    protected String getDelimitedIdentifiers() {
+        return "\""; //$NON-NLS-1$
+    }
+
     protected String getHandledField(String field) {
+        if (field != null) {
+            field = field.replace("\"", "\\\"");
+        }
         return field;
     }
 
+    public boolean isUseDelimitedIdentifiers() {
+        return Boolean.TRUE.equals(this.useDelimitedIdentifiers);
+    }
+
+    public void setUseDelimitedIdentifiers(boolean useDelimitedIdentifiers) {
+        this.useDelimitedIdentifiers = useDelimitedIdentifiers;
+    }
+
 }

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/language/generation/DbMapSqlConstants.java

@@ -42,8 +42,12 @@ public interface DbMapSqlConstants {
      * 
      */
     public final static String SELECT = "SELECT"; //$NON-NLS-1$
+    
+    public final static String UPDATE = "UPDATE"; //$NON-NLS-1$
 
     public final static String FROM = "FROM"; //$NON-NLS-1$
+    
+    public final static String INNER_JOIN = "INNER JOIN"; //$NON-NLS-1$
 
     public final static String WHERE = "WHERE"; //$NON-NLS-1$
 

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/language/hive/HiveGenerationManager.java

@@ -42,7 +42,12 @@ public class HiveGenerationManager extends DbGenerationManager {
             if (inputTableName != null && inputTableName.contains(".")) {
                 String[] inputTableNames = inputTableName.split("\\.");
                 if (inputTableNames.length > 1) {
-                    query = query.replaceAll(inputTableName + "\\.", inputTableNames[1] + ".");
+                    query = query.replaceAll(inputTableName + "\\.", inputTableNames[1] + "."); //$NON-NLS-1$ //$NON-NLS-2$ 
+                    for (int i = 0; i < querySegments.size(); i++) {
+                        String segment = querySegments.get(i);
+                        segment = segment.replaceAll(inputTableName + "\\.", inputTableNames[1] + "."); //$NON-NLS-1$ //$NON-NLS-2$
+                        querySegments.set(i, segment);
+                    }
                 }
             }
         }

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/language/oracle/OracleGenerationManager.java

@@ -62,11 +62,15 @@ public class OracleGenerationManager extends DbGenerationManager {
      * @return
      */
     @Override
-    public String buildSqlSelect(DbMapComponent component, String outputTableName, String tabString) {
+    public String buildSqlSelect(DbMapComponent dbMapComponent, String outputTableName, String tabString) {
         queryColumnsName = "\""; //$NON-NLS-1$
         aliasAlreadyDeclared.clear();
+        queryColumnsSegments.clear();
+        querySegments.clear();
         this.tabSpaceString = tabString;
 
+        DbMapComponent component = getDbMapComponent(dbMapComponent);
+
         List<IConnection> outputConnections = (List<IConnection>) component.getOutgoingConnections();
 
         Map<String, IConnection> nameToOutputConnection = new HashMap<String, IConnection>();
@@ -101,9 +105,10 @@ public class OracleGenerationManager extends DbGenerationManager {
                     // outputTable = removeUnmatchingEntriesWithColumnsOfMetadataTable(outputTable, metadataTable);
                 }
             }
-            sb.append("\""); //$NON-NLS-1$
-            sb.append(DbMapSqlConstants.SELECT);
-            sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
+            appendSqlQuery(sb, "\"", false); //$NON-NLS-1$
+            appendSqlQuery(sb, DbMapSqlConstants.SELECT);
+            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+            appendSqlQuery(sb, tabSpaceString);
 
             List<ExternalDbMapEntry> metadataTableEntries = outputTable.getMetadataTableEntries();
             if (metadataTableEntries != null) {
@@ -126,14 +131,15 @@ public class OracleGenerationManager extends DbGenerationManager {
                                 + getAliasOf(dbMapEntry.getName());
                         added = true;
                     }
+                    String columnSegment = expression;
                     if (i > 0) {
-                        sb.append(DbMapSqlConstants.COMMA);
-                        sb.append(DbMapSqlConstants.SPACE);
-
+                        appendSqlQuery(sb, DbMapSqlConstants.COMMA);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
                         queryColumnsName += DbMapSqlConstants.COMMA + DbMapSqlConstants.SPACE;
+                        columnSegment = DbMapSqlConstants.COMMA + DbMapSqlConstants.SPACE + columnSegment;
                     }
                     if (expression != null && expression.trim().length() > 0) {
-                        sb.append(expression);
+                        appendSqlQuery(sb, expression);
                         if (component.getMapperMain() == null) {
                             component.getExternalEmfData();
                         }
@@ -158,22 +164,25 @@ public class OracleGenerationManager extends DbGenerationManager {
                                 }
                             }
                             if (!added && columnChanged) {
-                                sb.append(DbMapSqlConstants.SPACE + DbMapSqlConstants.AS + DbMapSqlConstants.SPACE
-                                        + getAliasOf(dbMapEntry.getName()));
+                                String name = DbMapSqlConstants.SPACE + DbMapSqlConstants.AS + DbMapSqlConstants.SPACE
+                                        + getAliasOf(dbMapEntry.getName());
+                                appendSqlQuery(sb, name);
                             }
                         }
                         queryColumnsName += expression;
+                        queryColumnsSegments.add(columnSegment);
                     } else {
-                        sb.append(DbMapSqlConstants.LEFT_COMMENT);
+                        appendSqlQuery(sb, DbMapSqlConstants.LEFT_COMMENT);
                         String str = outputTable.getName() + DbMapSqlConstants.DOT + dbMapEntry.getName();
-                        sb.append(Messages.getString("DbGenerationManager.OuputExpSetMessage", str)); //$NON-NLS-1$
-                        sb.append(DbMapSqlConstants.RIGHT_COMMENT);
+                        appendSqlQuery(sb, Messages.getString("DbGenerationManager.OuputExpSetMessage", str));//$NON-NLS-1$
+                        appendSqlQuery(sb, DbMapSqlConstants.RIGHT_COMMENT);
                     }
                 }
             }
 
-            sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
-            sb.append(DbMapSqlConstants.FROM);
+            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+            appendSqlQuery(sb, tabSpaceString);
+            appendSqlQuery(sb, DbMapSqlConstants.FROM);
 
             List<ExternalDbMapTable> inputTables = data.getInputTables();
 
@@ -200,7 +209,8 @@ public class OracleGenerationManager extends DbGenerationManager {
                 }
             }
 
-            sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
+            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+            appendSqlQuery(sb, tabSpaceString);
 
             IJoinType previousJoinType = null;
 
@@ -223,13 +233,14 @@ public class OracleGenerationManager extends DbGenerationManager {
                             buildTableDeclaration(component, sb, inputTables.get(i - 1), commaCouldBeAdded, crCouldBeAdded, true);
                             previousJoinType = joinType;
                         } else {
-                            sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
+                            appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                            appendSqlQuery(sb, tabSpaceString);
                         }
-                        sb.append(DbMapSqlConstants.SPACE);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
                     }
                     String labelJoinType = joinType.getLabel();
-                    sb.append(labelJoinType);
-                    sb.append(DbMapSqlConstants.SPACE);
+                    appendSqlQuery(sb, labelJoinType);
+                    appendSqlQuery(sb, DbMapSqlConstants.SPACE);
                     if (joinType == AbstractDbLanguage.JOIN.CROSS_JOIN) {
                         ExternalDbMapTable nextTable = null;
                         if (i < lstSizeInputTables) {
@@ -244,20 +255,20 @@ public class OracleGenerationManager extends DbGenerationManager {
                         // if (rightTable != null) {
                         // } else {
                         // sb.append(" <!! NO JOIN CLAUSES FOR '" + inputTable.getName() + "' !!> ");
-                        // }
-                        sb.append(DbMapSqlConstants.SPACE);
-                        sb.append(DbMapSqlConstants.ON);
-                        sb.append(DbMapSqlConstants.LEFT_BRACKET);
-                        sb.append(DbMapSqlConstants.SPACE);
+                        // }                       
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                        appendSqlQuery(sb, DbMapSqlConstants.ON);
+                        appendSqlQuery(sb, DbMapSqlConstants.LEFT_BRACKET);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
                         if (!buildConditions(component, sb, inputTable, true, true)) {
-                            sb.append(DbMapSqlConstants.LEFT_COMMENT);
-                            sb.append(DbMapSqlConstants.SPACE);
-                            sb.append(Messages.getString("DbGenerationManager.conditionNotSet")); //$NON-NLS-1$
-                            sb.append(DbMapSqlConstants.SPACE);
-                            sb.append(DbMapSqlConstants.RIGHT_COMMENT);
+                            appendSqlQuery(sb, DbMapSqlConstants.LEFT_COMMENT);
+                            appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                            appendSqlQuery(sb, Messages.getString("DbGenerationManager.conditionNotSet"));//$NON-NLS-1$
+                            appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                            appendSqlQuery(sb, DbMapSqlConstants.RIGHT_COMMENT);
                         }
-                        sb.append(DbMapSqlConstants.SPACE);
-                        sb.append(DbMapSqlConstants.RIGHT_BRACKET);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                        appendSqlQuery(sb, DbMapSqlConstants.RIGHT_BRACKET);
                     }
 
                 }
@@ -315,35 +326,39 @@ public class OracleGenerationManager extends DbGenerationManager {
 
             boolean whereOriginalFlag = !originalWhereAddition.isEmpty();
             if (whereFlag || whereAddFlag || whereOriginalFlag) {
-                sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
-                sb.append(DbMapSqlConstants.WHERE);
+                appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                appendSqlQuery(sb, tabSpaceString);
+                appendSqlQuery(sb, DbMapSqlConstants.WHERE);
             }
             if (whereFlag) {
                 sb.append(whereClauses);
             }
             if (whereAddFlag) {
                 for (int i = 0; i < whereAddition.size(); i++) {
-                    if (i == 0 && whereFlag || i > 0) {
-                        sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
-                        sb.append(DbMapSqlConstants.SPACE);
-                        sb.append(DbMapSqlConstants.AND);
+                    if (i == 0 && whereFlag || i > 0) {                      
+                        appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                        appendSqlQuery(sb, tabSpaceString);
+                        appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                        appendSqlQuery(sb, DbMapSqlConstants.AND);
                     }
-                    sb.append(DbMapSqlConstants.SPACE);
-                    sb.append(whereAddition.get(i));
+                    appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                    appendSqlQuery(sb, whereAddition.get(i));
                 }
             }
             if (whereOriginalFlag) {
                 for (String s : originalWhereAddition) {
-                    sb.append(DbMapSqlConstants.NEW_LINE);
-                    sb.append(DbMapSqlConstants.SPACE);
-                    sb.append(s);
+                    appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                    appendSqlQuery(sb, DbMapSqlConstants.SPACE);
+                    appendSqlQuery(sb, s);
                 }
             }
             if (!otherAddition.isEmpty()) {
-                sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
+                appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                appendSqlQuery(sb, tabSpaceString);
                 for (String s : otherAddition) {
-                    sb.append(s);
-                    sb.append(DbMapSqlConstants.NEW_LINE).append(tabSpaceString);
+                    appendSqlQuery(sb, s);
+                    appendSqlQuery(sb, DbMapSqlConstants.NEW_LINE);
+                    appendSqlQuery(sb, tabSpaceString);
                 }
             }
         }
@@ -356,9 +371,11 @@ public class OracleGenerationManager extends DbGenerationManager {
                     sqlQuery = sqlQuery.replaceAll("\\b" + context + "\\b", "\" +" + context + "+ \""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
                     haveReplace = true;
                 }
+                replaceQueryContext(querySegments, context);
                 if (queryColumnsName.contains(context)) {
                     queryColumnsName = queryColumnsName.replaceAll("\\b" + context + "\\b", "\" +" + context + "+ \""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
                 }
+                replaceQueryContext(queryColumnsSegments, context);
             }
             if (!haveReplace) {
                 List<String> connContextList = getConnectionContextList(component);
@@ -366,9 +383,11 @@ public class OracleGenerationManager extends DbGenerationManager {
                     if (sqlQuery.contains(context)) {
                         sqlQuery = sqlQuery.replaceAll("\\b" + context + "\\b", "\" +" + context + "+ \""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
                     }
+                    replaceQueryContext(querySegments, context);
                     if (queryColumnsName.contains(context)) {
                         queryColumnsName = queryColumnsName.replaceAll("\\b" + context + "\\b", "\" +" + context + "+ \""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
                     }
+                    replaceQueryContext(queryColumnsSegments, context);
                 }
             }
         }

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/language/postgres/PostgresGenerationManager.java

@@ -200,6 +200,11 @@ public class PostgresGenerationManager extends DbGenerationManager {
         return getHandledField(field, false);
     }
 
+    @Override
+    protected String getColumnName(IConnection conn, String name) {
+        return name;
+    }
+
     @Override
     protected void buildTableDeclaration(DbMapComponent component, StringBuilder sb, ExternalDbMapTable inputTable) {
         sb.append(getHandledTableName(component, inputTable.getTableName(), inputTable.getAlias(), true));

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/managers/MapperManager.java

@@ -776,6 +776,11 @@ public class MapperManager extends AbstractMapperManager {
         uiManager.refreshSqlExpression();
     }
 
+    public void useDelimitedIdentifiers(boolean useDelimitedIdentifiers) {
+        getComponent().getGenerationManager().setUseDelimitedIdentifiers(useDelimitedIdentifiers);
+        uiManager.refreshSqlExpression();
+    }
+
     /**
      * Getter for problemsManager.
      * 

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/service/DbMapDesignerService.java

@@ -1,16 +1,10 @@
 package org.talend.designer.dbmap.service;
 
-import java.util.List;
-
 import org.eclipse.gef.commands.Command;
 import org.talend.core.model.process.IConnection;
 import org.talend.core.model.process.INode;
-import org.talend.core.model.process.node.IExternalMapTable;
 import org.talend.designer.core.IDbMapDesignerService;
-import org.talend.designer.dbmap.DbMapComponent;
 import org.talend.designer.dbmap.command.UpdateELTMapComponentCommand;
-import org.talend.designer.dbmap.external.data.ExternalDbMapEntry;
-import org.talend.designer.dbmap.external.data.ExternalDbMapTable;
 
 public class DbMapDesignerService implements IDbMapDesignerService {
 

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/service/DbMapService.java

@@ -14,6 +14,7 @@ package org.talend.designer.dbmap.service;
 
 import java.util.List;
 
+import org.apache.commons.lang3.StringUtils;
 import org.talend.core.model.process.IExternalNode;
 import org.talend.core.service.IDbMapService;
 import org.talend.designer.core.model.utils.emf.talendfile.AbstractExternalData;
@@ -42,25 +43,28 @@ public class DbMapService implements IDbMapService {
         AbstractExternalData nodeData = nodeType.getNodeData();
         if (nodeData instanceof DBMapData) {
             DBMapData dbMapData = (DBMapData) nodeData;
+            // may have several tables with different aliases.
+            boolean isAliasIncludeTableName = false;
             for (InputTable input : dbMapData.getInputTables()) {
                 if (input.getName().equals(oldValue) || input.getTableName().equals(oldValue)) {
                     input.setName(newValue);
                     input.setTableName(newValue);
+                    String alias = input.getAlias();
+                    if (alias != null) {
+                        if (alias.contains(oldValue)) {
+                            isAliasIncludeTableName = true;
+                        }
+                    }
                 }
             }
+            
+            // do this when no alias in expression(or has alias which alias = old tableName, when tableName change to new, don't change alias in expression)
             for (OutputTable output : dbMapData.getOutputTables()) {
                 List<DBMapperTableEntry> entries = output.getDBMapperTableEntries();
                 for (DBMapperTableEntry entry : entries) {
                     String expression = entry.getExpression();
-                    if (expression != null && !"".equals(expression.trim())) { //$NON-NLS-1$
-                        int index = expression.lastIndexOf("."); //$NON-NLS-1$
-                        // at least "a.b"
-                        if (index > 0) {
-                            String connectionName = expression.substring(0, index);
-                            if (oldValue.equals(connectionName)) {
-                                entry.setExpression(newValue + expression.substring(index, expression.length()));
-                            }
-                        }
+                    if (!StringUtils.isBlank(expression) && expression.contains(oldValue) && !isAliasIncludeTableName) {
+                        entry.setExpression(expression.replace(oldValue, newValue));
                     }
                 }
             }

main/plugins/org.talend.designer.dbmap/src/main/java/org/talend/designer/dbmap/ui/visualmap/zone/toolbar/ToolbarOutputZone.java

@@ -36,6 +36,8 @@ public class ToolbarOutputZone extends ToolbarZone {
 
     private ToolItem guessItem;
 
+    private ToolItem delimitedIdentifiersItem;
+
     public static final String MINIMIZE_TOOLTIP = Messages.getString("ToolbarOutputZone.minimizeTooltip"); //$NON-NLS-1$
 
     public static final String RESTORE_TOOLTIP = Messages.getString("ToolbarOutputZone.restorTooltip"); //$NON-NLS-1$
@@ -82,6 +84,11 @@ public class ToolbarOutputZone extends ToolbarZone {
         guessItem.setToolTipText(Messages.getString("ToolbarOutputZone.widgetTooltip.mapInputAndOutput")); //$NON-NLS-1$
         guessItem.setText(Messages.getString("ToolbarOutputZone.widgetText.autoMap")); //$NON-NLS-1$
 
+        delimitedIdentifiersItem = new ToolItem(getToolBarActions(), SWT.CHECK);
+        delimitedIdentifiersItem.setToolTipText(Messages.getString("ToolbarOutputZone.widgetTooltip.delimitedIdentifiers")); //$NON-NLS-1$
+        delimitedIdentifiersItem.setText(Messages.getString("ToolbarOutputZone.widgetText.delimitedIdentifiers")); //$NON-NLS-1$
+        delimitedIdentifiersItem
+                .setSelection(getMapperManager().getComponent().getGenerationManager().isUseDelimitedIdentifiers());
     }
 
     /**
@@ -91,6 +98,7 @@ public class ToolbarOutputZone extends ToolbarZone {
         // final UIManager uiManager = getMapperManager().getUiManager();
         addOutputItem.addListener(SWT.Selection, new Listener() {
 
+            @Override
             public void handleEvent(Event event) {
                 getMapperManager().addOutput();
             }
@@ -99,6 +107,7 @@ public class ToolbarOutputZone extends ToolbarZone {
 
         removeOutputItem.addListener(SWT.Selection, new Listener() {
 
+            @Override
             public void handleEvent(Event event) {
                 getMapperManager().removeSelectedOutputTable();
             }
@@ -107,26 +116,40 @@ public class ToolbarOutputZone extends ToolbarZone {
 
         guessItem.addListener(SWT.Selection, new Listener() {
 
+            @Override
             public void handleEvent(Event event) {
                 getMapperManager().mapAutomaticallly();
             }
 
         });
 
+        delimitedIdentifiersItem.addListener(SWT.Selection, new Listener() {
+
+            @Override
+            public void handleEvent(Event event) {
+                getMapperManager().useDelimitedIdentifiers(delimitedIdentifiersItem.getSelection());
+            }
+
+        });
+
     }
 
+    @Override
     public String getMinimizeTooltipText() {
         return MINIMIZE_TOOLTIP;
     }
 
+    @Override
     public String getRestoreTooltipText() {
         return RESTORE_TOOLTIP;
     }
 
+    @Override
     public String getMoveUpTooltipText() {
         return MOVE_UP_TOOLTIP;
     }
 
+    @Override
     public String getMoveDownTooltipText() {
         return MOVE_DOWN_TOOLTIP;
     }

main/plugins/org.talend.designer.mapper/src/main/java/org/talend/designer/mapper/MapperComponent.java

@@ -478,12 +478,18 @@ public class MapperComponent extends AbstractMapComponent implements IHashableIn
         ExternalMapperData data = mapperMain.buildExternalData();
         if (mapperMain != null && data != null) {
             if (externalData != null) {
-                this.externalData = data;// fwang fixed bug TDI-8027
+                if(!isConnectionEmpty()) {
+                    this.externalData = data;// fwang fixed bug TDI-8027
+                }
                 MapperHelper.saveDataToEmf(data, emfMapperData);
             }
         }
         return emfMapperData;
     }
+    
+    private boolean isConnectionEmpty() {
+        return getIncomingConnections().isEmpty() && getOutgoingConnections().isEmpty();
+    }
 
     public void renameInputConnection(String oldConnectionName, String newConnectionName) {
         if (oldConnectionName == null || newConnectionName == null) {

main/plugins/org.talend.designer.maven.job/resources/templates/standalone/assembly_job_template.xml

@@ -6,7 +6,7 @@
 	<id>bin</id>
 	<includeBaseDirectory>false</includeBaseDirectory>
 	<formats>
-		<format>zip</format>
+		<format>${assembly.format}</format>
 	</formats>
 
 	<files>
@@ -218,6 +218,7 @@
 	<moduleSets>
 		<moduleSet>
 			<!-- for routines or talend libs -->
+			<includeSubModules>false</includeSubModules>
 			<useAllReactorProjects>true</useAllReactorProjects>
 			<includes>
 				<include>${routines.binaries.includes.set}</include>
@@ -232,6 +233,7 @@
 		</moduleSet>
 		<moduleSet>
 			<!-- for pigudfs or talend libs -->
+			<includeSubModules>false</includeSubModules>
 			<useAllReactorProjects>true</useAllReactorProjects>
 			<includes>
 				<include>${pigudfs.binaries.includes.set}</include>

main/plugins/org.talend.designer.maven.job/resources/templates/standalone/pom_job_template.xml

@@ -15,6 +15,8 @@
 	<name>@ProjectName@ @JobName@ (@JobType@)</name>
 
 	<properties>
+		<maven.deploy.skip>false</maven.deploy.skip>
+		<assembly.format>zip</assembly.format>
 		<talend.job.path>@JobPath@</talend.job.path>
 		<talend.job.package>@JobPackage@</talend.job.package>
 
@@ -22,7 +24,6 @@
 		<talend.project.name>@ProjectName@</talend.project.name>
 		<talend.project.name.lowercase>@ProjectName@</talend.project.name.lowercase>
 		<talend.project.id>@ProjectId@</talend.project.id>
-		<talend.project.branch>@ProjectBranch@</talend.project.branch>
 		<talend.job.name>@JobName@</talend.job.name>
 		<talend.job.version>@TalendJobVersion@</talend.job.version>
 		<talend.job.date>@JobDate@</talend.job.date>
@@ -111,6 +112,12 @@
 										<include>contexts/*.properties</include>
 									</includes>
 								</resource>
+								<resource>
+									<directory>${current.resources.dir}/metadata/survivorship/</directory>
+									<includes>
+										<include>**/*.*</include>
+									</includes>
+								</resource>
 							</resources>
 						</configuration>
 					</execution>
@@ -131,12 +138,37 @@
                       <!-- only package the job classes -->
                       <include>${talend.job.path}/*.class</include>
                       <include>${talend.job.path}/**/*.wsdl</include>
+                      <include>/metadata/survivorship/**/*.*</include>
                     </includes>
                   </configuration>
                 </execution>
              </executions>
-           </plugin>			
-		 </plugins>
+            </plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-deploy-plugin</artifactId>
+				<executions>
+					<execution>
+						<id>default-deploy</id>
+						<phase>none</phase>
+					</execution>
+					<execution>
+						<id>deploy-file</id>
+						<phase>deploy</phase>
+						<goals>
+							<goal>deploy-file</goal>
+						</goals>
+						<configuration>
+							<file>${project.build.directory}/${talend.job.finalName}.${assembly.format}</file>
+							<groupId>${project.groupId}</groupId>
+							<artifactId>${project.artifactId}</artifactId>
+							<version>${project.version}</version>
+							<packaging>${assembly.format}</packaging>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
 	</build>
 	<profiles>
 	    <profile>
@@ -162,6 +194,7 @@
                        <tarLongFileMode>gnu</tarLongFileMode>
                        <appendAssemblyId>false</appendAssemblyId>
                        <finalName>${talend.job.finalName}</finalName>
+                       <attach>false</attach>
                      </configuration>
                    </execution>
                 </executions>

main/plugins/org.talend.designer.runprocess/src/main/java/org/talend/designer/runprocess/java/JavaProcessor.java

@@ -29,6 +29,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -89,6 +90,7 @@ import org.eclipse.swt.widgets.Display;
 import org.eclipse.ui.PlatformUI;
 import org.talend.commons.CommonsPlugin;
 import org.talend.commons.exception.ExceptionHandler;
+import org.talend.commons.exception.PersistenceException;
 import org.talend.commons.exception.SystemException;
 import org.talend.commons.ui.runtime.exception.RuntimeExceptionHandler;
 import org.talend.commons.utils.generation.JavaUtils;
@@ -114,9 +116,11 @@ import org.talend.core.model.process.ProcessUtils;
 import org.talend.core.model.properties.Item;
 import org.talend.core.model.properties.ProcessItem;
 import org.talend.core.model.properties.Property;
+import org.talend.core.model.repository.IRepositoryViewObject;
 import org.talend.core.model.runprocess.IJavaProcessorStates;
 import org.talend.core.model.utils.JavaResourcesHelper;
 import org.talend.core.prefs.ITalendCorePrefConstants;
+import org.talend.core.repository.model.ProxyRepositoryFactory;
 import org.talend.core.runtime.process.ITalendProcessJavaProject;
 import org.talend.core.runtime.process.LastGenerationInfo;
 import org.talend.core.runtime.process.TalendProcessOptionConstants;
@@ -321,8 +325,23 @@ public class JavaProcessor extends AbstractJavaProcessor implements IJavaBreakpo
         String jobClassPackageFolder = null;
         String jobClassFilePath = null;
         // only for "standard" job
+        Item item = null;
+        if (property != null) {
+            item = property.getItem();
+            if (item != null && item.getParent() == null) {
+                try {
+                    IRepositoryViewObject object = ProxyRepositoryFactory.getInstance().getSpecificVersion(property.getId(),
+                            property.getVersion(), false);
+                    if (object != null) {
+                        property = object.getProperty();
+                        item = property.getItem();
+                    }
+                } catch (PersistenceException e) {
+                    throw new ProcessorException(e);
+                }
+            }
+        }
         if (isStandardJob()) {
-            Item item = property.getItem();
             // test/testjob_0_1
             jobClassPackageFolder = JavaResourcesHelper.getJobClassPackageFolder(item, isTestJob);
             // test/testjob_0_1/TestJob.java
@@ -1305,7 +1324,7 @@ public class JavaProcessor extends AbstractJavaProcessor implements IJavaBreakpo
                 libPath.append(classPathSeparator);
             }
         } else {
-            Set<String> neededLibraries = new HashSet<String>();
+            Set<String> neededLibraries = new LinkedHashSet<String>();
             for (ModuleNeeded neededModule : neededModules) {
                 neededLibraries.add(neededModule.getModuleName());
             }
@@ -1315,12 +1334,15 @@ public class JavaProcessor extends AbstractJavaProcessor implements IJavaBreakpo
                 return ""; //$NON-NLS-1$
             }
             File[] jarFiles = libDir.listFiles(FilesUtils.getAcceptJARFilesFilter());
-            List<File> listFile = Arrays.asList(jarFiles);
-            Collections.sort(listFile);
-
-            if (jarFiles != null && jarFiles.length > 0) {
-                for (File jarFile : jarFiles) {
-                    if (jarFile.isFile() && neededLibraries.contains(jarFile.getName())) {
+            
+            Map<String, File> jarFileMap = new HashMap<>();
+            for (File file : jarFiles) {
+                jarFileMap.put(file.getName(), file);
+            }
+            for (String neededLibrary : neededLibraries) {
+                if (jarFileMap.containsKey(neededLibrary)) {
+                    File jarFile = jarFileMap.get(neededLibrary);
+                    if (jarFile.isFile()) {
                         String singleLibPath = new Path(jarFile.getAbsolutePath()).toPortableString();
                         libPath.append(singleLibPath).append(classPathSeparator);
                     }

main/plugins/org.talend.designer.runprocess/src/main/java/org/talend/designer/runprocess/java/JavaProcessorUtilities.java

@@ -13,10 +13,14 @@
 package org.talend.designer.runprocess.java;
 
 import java.io.File;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Set;
 import java.util.TreeSet;
 
@@ -241,6 +245,25 @@ public class JavaProcessorUtilities {
                 }
             }
         }
+        // move high priority modules to front.
+        Set<ModuleNeeded> highPriorityModuleNeeded = LastGenerationInfo.getInstance().getHighPriorityModuleNeeded();
+        if (!highPriorityModuleNeeded.isEmpty()) {
+            Iterator<ModuleNeeded> iterator = highPriorityModuleNeeded.iterator();
+            while (iterator.hasNext()) {
+                ModuleNeeded needed = iterator.next();
+                if (highPriorityModuleNeeded.contains(needed)) {
+                    neededLibraries.remove(needed);
+                }
+            }
+            // order should be main -> sub1 -> sub_sub1 -> normal modules
+            List<ModuleNeeded> tempList = new ArrayList<>(highPriorityModuleNeeded);
+            Collections.reverse(tempList);
+            Set<ModuleNeeded> orderedNeededLibraries = new LinkedHashSet<>();
+            orderedNeededLibraries.addAll(tempList);
+            orderedNeededLibraries.addAll(neededLibraries);
+            return orderedNeededLibraries;
+        }
+        
         return neededLibraries;
     }
 
@@ -473,7 +496,7 @@ public class JavaProcessorUtilities {
 
                     });
                 }
-            } else {
+            } else if (!Boolean.getBoolean("skip_missing_jars")) {
                 throw new ProcessorException(missingJars);
             }
 

main/plugins/org.talend.designer.runprocess/src/main/java/org/talend/designer/runprocess/maven/MavenJavaProcessor.java

@@ -48,6 +48,7 @@ import org.talend.designer.maven.model.TalendMavenConstants;
 import org.talend.designer.maven.tools.ProjectPomManager;
 import org.talend.designer.maven.tools.creator.CreateMavenJobPom;
 import org.talend.designer.maven.utils.PomUtil;
+import org.talend.designer.runprocess.IMavenProcessor;
 import org.talend.designer.runprocess.ProcessorException;
 import org.talend.designer.runprocess.ProcessorUtilities;
 import org.talend.designer.runprocess.java.JavaProcessor;
@@ -58,14 +59,26 @@ import org.talend.repository.ui.wizards.exportjob.scriptsmanager.BuildJobManager
  * created by ggu on 2 Feb 2015 Detailled comment
  *
  */
-public class MavenJavaProcessor extends JavaProcessor {
+public class MavenJavaProcessor extends JavaProcessor implements IMavenProcessor {
 
     protected String windowsClasspath, unixClasspath;
 
+    private String[] childrenJobDependencies;
+
     public MavenJavaProcessor(IProcess process, Property property, boolean filenameFromLabel) {
         super(process, property, filenameFromLabel);
     }
 
+    @Override
+    public String[] getChildrenJobDependencies() {
+        return childrenJobDependencies;
+    }
+
+    @Override
+    public void setChildrenJobDependencies(String[] dependencies) {
+        this.childrenJobDependencies = dependencies;
+    }
+
     @Override
     public void generateCode(boolean statistics, boolean trace, boolean javaProperties, int option) throws ProcessorException {
         super.generateCode(statistics, trace, javaProperties, option);

main/plugins/org.talend.repository/src/main/java/org/talend/repository/model/migration/UpdateELTComponentMigrationTask.java

@@ -53,20 +53,19 @@ public class UpdateELTComponentMigrationTask extends AbstractJobMigrationTask {
                 if (connection.getLabel().equals(tableName)) {
                     connection.setLabel(connectionName);
                     isModified = true;
+                } else {
+                    // if user custom connection name, keep everything currently they had.
+                    break;
                 }
-                List<MetadataTypeImpl> tables = eltInputNode.getMetadata();
-                for (MetadataTypeImpl table : tables) {
-                    if (table.getLabel().equals(tableName)) {
-                        table.setLabel(connectionName);
-                        isModified = true;
-                    }
+                MetadataTypeImpl table = (MetadataTypeImpl) eltInputNode.getMetadata().get(0);
+                if (table.getLabel().equals(tableName)) {
+                    table.setLabel(connectionName);
                 }
 
                 NodeType eltMapNode = getNodeTypeByUniqueName(nodes, targetNodeName);
                 if (GlobalServiceRegister.getDefault().isServiceRegistered(IDbMapService.class)) {
                     IDbMapService service = (IDbMapService) GlobalServiceRegister.getDefault().getService(IDbMapService.class);
                     service.updateEMFDBMapData(eltMapNode, tableName, connectionName);
-                    isModified = true;
                 }
             }
         }

main/plugins/org.talend.repository/src/main/java/org/talend/repository/ui/login/LoginProjectPage.java

@@ -611,7 +611,7 @@ public class LoginProjectPage extends AbstractLoginActionPage {
             if (selectedConnBean != null) {
                 connectionsViewer.setSelection(new StructuredSelection(new Object[] { selectedConnBean }));
                 IStructuredSelection sel = (IStructuredSelection) connectionsViewer.getSelection();
-                if (sel.getFirstElement() == selectedConnBean) {
+                if (selectedConnBean.equals(sel.getFirstElement())) {
                     selected = true;
                 }
             }
@@ -671,7 +671,9 @@ public class LoginProjectPage extends AbstractLoginActionPage {
                     // if (beforeConnBean != null && connection.equals(beforeConnBean)) {
                     // return;
                     // }
-                    if (connection == loginHelper.getCurrentSelectedConnBean()) {
+                    if (connection.equals(loginHelper.getCurrentSelectedConnBean())) {
+                        // in case they are equal but different object id
+                        loginHelper.setCurrentSelectedConnBean(connection);
                         return;
                     } else {
                         loginHelper.setCurrentSelectedConnBean(connection);
@@ -823,6 +825,7 @@ public class LoginProjectPage extends AbstractLoginActionPage {
                 finishButton.setEnabled(false);
                 Project project = getProject();
                 if (project != null) {
+                    selectedProjectBeforeRefresh = project.getLabel();
 
                     // last used project will be saved when click finish
                     // loginHelper.getPrefManipulator().setLastProject(project.getLabel());
@@ -1867,7 +1870,6 @@ public class LoginProjectPage extends AbstractLoginActionPage {
                 try {
                     selectProject(project);
                 } catch (JSONException e) {
-                    // TODO Auto-generated catch block
                     ExceptionHandler.process(e);
                 }
             }
@@ -1876,6 +1878,7 @@ public class LoginProjectPage extends AbstractLoginActionPage {
 
     private void selectProject(Project goodProject) throws JSONException {
         projectViewer.setSelection(new StructuredSelection(new Object[] { goodProject }), true);
+        selectedProjectBeforeRefresh = goodProject.getLabel();
         fetchLicenseIfNeeded(goodProject);
         fillUIBranches(goodProject, true);
         // if (PluginChecker.isTIS()) {

main/plugins/org.talend.repository/src/main/java/org/talend/repository/ui/wizards/exportjob/handler/AbstractBuildJobHandler.java

@@ -188,10 +188,13 @@ public abstract class AbstractBuildJobHandler implements IBuildJobHandler {
 
     protected StringBuffer getProfileArgs() {
         StringBuffer profileBuffer = new StringBuffer();
-        profileBuffer.append(TalendMavenConstants.PREFIX_THREAD);
-        profileBuffer.append(SPACE);
-        profileBuffer.append(TalendMavenConstants.PREFIX_THREAD_VALUE);
-        profileBuffer.append(SPACE);
+        String property = System.getProperty("maven.additional.params"); //$NON-NLS-1$
+        if (property != null) {
+            profileBuffer.append(SPACE);
+            profileBuffer.append(property);
+            profileBuffer.append(SPACE);
+        }
+
         profileBuffer.append(TalendMavenConstants.PREFIX_PROFILE);
         profileBuffer.append(SPACE);
 

main/plugins/org.talend.repository/src/main/java/org/talend/repository/ui/wizards/exportjob/handler/BuildJobHandler.java

@@ -356,40 +356,6 @@ public class BuildJobHandler extends AbstractBuildJobHandler {
                     }
                 }
             }
-            // TDQ-12474 copy the "metadata/survivorship/rulePackage" to ".Java.src.main.resources". so that it will be
-            // used by
-            // maven command 'include-survivorship-rules' to export.
-            if (!isOptionChoosed(ExportChoice.needJobItem)) {
-                ExportFileResource resouece = new ExportFileResource();
-                BuildExportManager.getInstance().exportDependencies(resouece, processItem);
-                if (!resouece.getAllResources().isEmpty()) {
-                    final Iterator<String> relativepath = resouece.getRelativePathList().iterator();
-                    String pathStr = "metadata/survivorship"; //$NON-NLS-1$
-                    IFolder targetFolder = talendProcessJavaProject.getResourcesFolder();
-                    if (targetFolder.exists()) {
-                        IFolder survFolder = targetFolder.getFolder(new Path(pathStr));
-                        // only copy self job rules, clear the 'survivorship' folder before copy.
-                        if (survFolder.exists()) {
-                            survFolder.delete(true, null);
-                        }
-                        while (relativepath.hasNext()) {
-                            String relativePath = relativepath.next();
-                            Set<URL> sources = resouece.getResourcesByRelativePath(relativePath);
-                            for (URL sourceUrl : sources) {
-                                File currentResource = new File(org.talend.commons.utils.io.FilesUtils.getFileRealPath(sourceUrl
-                                        .getPath()));
-                                if (currentResource.exists()) {
-                                    FilesUtils.copyDirectory(currentResource, new File(targetFolder.getLocation()
-                                            .toPortableString() + File.separator + pathStr));
-                                }
-                            }
-                        }
-
-                    }
-                }
-                parentFolder.refreshLocal(IResource.DEPTH_INFINITE, null);
-
-            }
         }
     }
 

main/plugins/org.talend.repository/src/main/java/org/talend/repository/ui/wizards/exportjob/scriptsmanager/esb/JobJavaScriptOSGIForESBManager.java

@@ -1,6 +1,6 @@
 // ============================================================================
 //
-// Copyright (C) 2006-2016 Talend Inc. - www.talend.com
+// Copyright (C) 2006-2018 Talend Inc. - www.talend.com
 //
 // This source code is available under agreement available at
 // %InstallDIR%\features\org.talend.rcp.branding.%PRODUCTNAME%\%PRODUCTNAME%license.txt
@@ -31,6 +31,7 @@ import java.util.Properties;
 import java.util.Set;
 import java.util.jar.Manifest;
 
+import org.apache.commons.collections.CollectionUtils;
 import org.apache.commons.collections.map.MultiKeyMap;
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.runtime.Status;
@@ -176,7 +177,18 @@ public class JobJavaScriptOSGIForESBManager extends JobJavaScriptsManager {
                 getJobScriptsUncompressed(jobScriptResource, processItem);
 
                 // dynamic DB XML mapping
-                addXmlMapping(process, isOptionChoosed(ExportChoice.needSourceCode));
+                addXmlMapping(process, true);// isOptionChoosed(ExportChoice.needSourceCode)
+
+                if (CollectionUtils.isNotEmpty(process.getAllResources())) {
+                    ExportFileResource xm = new ExportFileResource(null, JavaUtils.JAVA_XML_MAPPING);
+                    Set<URL> urls = process
+                            .getResourcesByRelativePath(JOB_SOURCE_FOLDER_NAME + PATH_SEPARATOR + JavaUtils.JAVA_XML_MAPPING);
+
+                    if (CollectionUtils.isNotEmpty(urls)) {
+                        xm.addResources(new ArrayList<URL>(urls));
+                        list.add(xm);
+                    }
+                }
 
                 generateConfig(osgiResource, processItem, iProcess);
 

test/plugins/org.talend.designer.core.test/src/org/talend/designer/core/model/process/jobsettings/JobSettingsManagerTest.java

@@ -12,12 +12,11 @@
 // ============================================================================
 package org.talend.designer.core.model.process.jobsettings;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
 
 import java.util.List;
 
-import junit.framework.Assert;
-
 import org.junit.Test;
 import org.talend.core.model.metadata.IMetadataColumn;
 import org.talend.core.model.metadata.IMetadataTable;
@@ -29,6 +28,8 @@ import org.talend.designer.core.model.components.EParameterName;
 import org.talend.designer.core.model.process.DataNode;
 import org.talend.designer.core.ui.editor.process.Process;
 
+import junit.framework.Assert;
+
 /**
  * created by wchen on 2016年1月21日 Detailled comment
  *
@@ -75,9 +76,6 @@ public class JobSettingsManagerTest {
         String separator = "\\";
         Assert.assertEquals("\"^([^\"+\"\\\\\\\\\"+\"]*)\"+\"\\\\\\\\\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "\\\\";
-        Assert.assertEquals("\"^([^\"+\"\\\\\\\\\\\\\\\\\"+\"]*)\"+\"\\\\\\\\\\\\\\\\\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -85,9 +83,6 @@ public class JobSettingsManagerTest {
         String separator = "^";
         Assert.assertEquals("\"^([^\"+\"\\\\^\"+\"]*)\"+\"\\\\^\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "^^";
-        Assert.assertEquals("\"^([^\"+\"\\\\^\\\\^\"+\"]*)\"+\"\\\\^\\\\^\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -95,9 +90,6 @@ public class JobSettingsManagerTest {
         String separator = "$";
         Assert.assertEquals("\"^([^\"+\"\\\\$\"+\"]*)\"+\"\\\\$\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "$$";
-        Assert.assertEquals("\"^([^\"+\"\\\\$\\\\$\"+\"]*)\"+\"\\\\$\\\\$\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -105,9 +97,6 @@ public class JobSettingsManagerTest {
         String separator = ".";
         Assert.assertEquals("\"^([^\"+\"\\\\.\"+\"]*)\"+\"\\\\.\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "..";
-        Assert.assertEquals("\"^([^\"+\"\\\\.\\\\.\"+\"]*)\"+\"\\\\.\\\\.\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -115,9 +104,6 @@ public class JobSettingsManagerTest {
         String separator = "?";
         Assert.assertEquals("\"^([^\"+\"\\\\?\"+\"]*)\"+\"\\\\?\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "??";
-        Assert.assertEquals("\"^([^\"+\"\\\\?\\\\?\"+\"]*)\"+\"\\\\?\\\\?\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -125,9 +111,6 @@ public class JobSettingsManagerTest {
         String separator = "|";
         Assert.assertEquals("\"^([^\"+\"\\\\|\"+\"]*)\"+\"\\\\|\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "||";
-        Assert.assertEquals("\"^([^\"+\"\\\\|\\\\|\"+\"]*)\"+\"\\\\|\\\\|\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -135,9 +118,6 @@ public class JobSettingsManagerTest {
         String separator = "[";
         Assert.assertEquals("\"^([^\"+\"\\\\[\"+\"]*)\"+\"\\\\[\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "[[";
-        Assert.assertEquals("\"^([^\"+\"\\\\[\\\\[\"+\"]*)\"+\"\\\\[\\\\[\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -145,9 +125,6 @@ public class JobSettingsManagerTest {
         String separator = "+";
         Assert.assertEquals("\"^([^\"+\"\\\\+\"+\"]*)\"+\"\\\\+\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "++";
-        Assert.assertEquals("\"^([^\"+\"\\\\+\\\\+\"+\"]*)\"+\"\\\\+\\\\+\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -155,9 +132,6 @@ public class JobSettingsManagerTest {
         String separator = "*";
         Assert.assertEquals("\"^([^\"+\"\\\\*\"+\"]*)\"+\"\\\\*\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "**";
-        Assert.assertEquals("\"^([^\"+\"\\\\*\\\\*\"+\"]*)\"+\"\\\\*\\\\*\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -165,19 +139,13 @@ public class JobSettingsManagerTest {
         String separator = "{";
         Assert.assertEquals("\"^([^\"+\"\\\\{\"+\"]*)\"+\"\\\\{\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "{{";
-        Assert.assertEquals("\"^([^\"+\"\\\\{\\\\{\"+\"]*)\"+\"\\\\{\\\\{\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
     public void testGetSeparatorsRegexp11() {
         String separator = "(";
         Assert.assertEquals("\"^([^\"+\"\\\\(\"+\"]*)\"+\"\\\\(\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "((";
-        Assert.assertEquals("\"^([^\"+\"\\\\(\\\\(\"+\"]*)\"+\"\\\\(\\\\(\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
+                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));       
     }
 
     @Test
@@ -185,9 +153,6 @@ public class JobSettingsManagerTest {
         String separator = ")";
         Assert.assertEquals("\"^([^\"+\"\\\\)\"+\"]*)\"+\"\\\\)\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "))";
-        Assert.assertEquals("\"^([^\"+\"\\\\)\\\\)\"+\"]*)\"+\"\\\\)\\\\)\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -195,9 +160,6 @@ public class JobSettingsManagerTest {
         String separator = "}";
         Assert.assertEquals("\"^([^\"+\"\\\\}\"+\"]*)\"+\"\\\\}\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "}}";
-        Assert.assertEquals("\"^([^\"+\"\\\\}\\\\}\"+\"]*)\"+\"\\\\}\\\\}\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
@@ -205,131 +167,161 @@ public class JobSettingsManagerTest {
         String separator = "]";
         Assert.assertEquals("\"^([^\"+\"\\\\]\"+\"]*)\"+\"\\\\]\"+\"(.*)$\"",
                 JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
-        separator = "]]";
-        Assert.assertEquals("\"^([^\"+\"\\\\]\\\\]\"+\"]*)\"+\"\\\\]\\\\]\"+\"(.*)$\"",
-                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 
     @Test
     public void testDoRegexpQuote4Null() {
-        Assert.assertNull(JobSettingsManager.FileSeparator.doRegexpQuote(null));
+        Assert.assertEquals("\"\"", JobSettingsManager.FileSeparator.doRegexpQuote(null));
     }
 
     @Test
     public void testDoRegexpQuote4EmptyCharacter() {
         String separator = "";
-        Assert.assertEquals("", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote1() {
         String separator = "\\";
-        Assert.assertEquals("\\\\\\\\", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "\\\\";
-        Assert.assertEquals("\\\\\\\\\\\\\\\\", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\\\\\\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote2() {
         String separator = "^";
-        Assert.assertEquals("\\\\^", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "^^";
-        Assert.assertEquals("\\\\^\\\\^", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\^\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote3() {
         String separator = "$";
-        Assert.assertEquals("\\\\$", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "$$";
-        Assert.assertEquals("\\\\$\\\\$", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\$\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote4() {
         String separator = ".";
-        Assert.assertEquals("\\\\.", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "..";
-        Assert.assertEquals("\\\\.\\\\.", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\.\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote5() {
         String separator = "?";
-        Assert.assertEquals("\\\\?", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "??";
-        Assert.assertEquals("\\\\?\\\\?", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\?\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote6() {
         String separator = "|";
-        Assert.assertEquals("\\\\|", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\|\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
         separator = "||";
-        Assert.assertEquals("\\\\|\\\\|", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\|\\\\|\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote7() {
         String separator = "[";
-        Assert.assertEquals("\\\\[", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "[[";
-        Assert.assertEquals("\\\\[\\\\[", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\[\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote8() {
         String separator = "+";
-        Assert.assertEquals("\\\\+", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "++";
-        Assert.assertEquals("\\\\+\\\\+", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\+\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote9() {
         String separator = "*";
-        Assert.assertEquals("\\\\*", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "**";
-        Assert.assertEquals("\\\\*\\\\*", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\*\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote10() {
         String separator = "{";
-        Assert.assertEquals("\\\\{", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "{{";
-        Assert.assertEquals("\\\\{\\\\{", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\{\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote11() {
         String separator = "(";
-        Assert.assertEquals("\\\\(", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "((";
-        Assert.assertEquals("\\\\(\\\\(", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\(\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote12() {
         String separator = ")";
-        Assert.assertEquals("\\\\)", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "))";
-        Assert.assertEquals("\\\\)\\\\)", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\)\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote13() {
         String separator = "}";
-        Assert.assertEquals("\\\\}", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "}}";
-        Assert.assertEquals("\\\\}\\\\}", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\}\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
     }
 
     @Test
     public void testDoRegexpQuote14() {
         String separator = "]";
-        Assert.assertEquals("\\\\]", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
-        separator = "]]";
-        Assert.assertEquals("\\\\]\\\\]", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+        Assert.assertEquals("\"\\\\]\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+    }
+
+    @Test
+    public void testDoRegexpQuoteQuestion() {
+        String separator = "?";
+        Assert.assertEquals("\"\\\\?\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+    }
+    
+    @Test
+    public void testDoRegexpQuoteQuotation() {
+        String separator = "\"";
+        Assert.assertEquals("\"\\\\\\\"\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+    }
+    
+
+    @Test
+    public void testDoRegexpQuoteDoublePipe() {
+        String separator = "||";
+        Assert.assertEquals("\"\\\\|\\\\|\"", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+    }
+
+    @Test
+    public void testDoRegexpQuoteExpress1() {
+        String separator = "context.delimiter";
+        Assert.assertEquals("context.delimiter", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+    }
+
+    @Test
+    public void testDoRegexpQuoteExpress2() {
+        String separator = "String.valueOf((char) 31)";
+        Assert.assertEquals("String.valueOf((char) 31)", JobSettingsManager.FileSeparator.doRegexpQuote(separator));
+    }
+
+    @Test
+    public void testGetSeparatorsRegexpExpress1() {
+        String separator = "context.delimiter";
+        Assert.assertEquals("\"^([^\"+context.delimiter+\"]*)\"+context.delimiter+\"(.*)$\"",
+                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
+    }
+
+    @Test
+    public void testGetSeparatorsRegexpExpress2() {
+        String separator = "String.valueOf((char) 31)";
+        Assert.assertEquals("\"^([^\"+String.valueOf((char) 31)+\"]*)\"+String.valueOf((char) 31)+\"(.*)$\"",
+                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
+    }
+    
+    @Test
+    public void testGetSeparatorsRegexpDoublePipe() {
+        String separator = "||";
+        Assert.assertEquals("\"^([^\"+\"\\\\|\\\\|\"+\"]*)\"+\"\\\\|\\\\|\"+\"(.*)$\"",
+                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
+    }
+    
+    @Test
+    public void testGetSeparatorsRegexpQuotation() {
+        String separator = "\"";
+        Assert.assertEquals("\"^([^\"+\"\\\\\\\"\"+\"]*)\"+\"\\\\\\\"\"+\"(.*)$\"",
+                JobSettingsManager.FileSeparator.getSeparatorsRegexp(separator));
     }
 }

test/plugins/org.talend.designer.dbmap.test/src/org/talend/designer/dbmap/command/UpdateELTMapComponentCommandTest.java

@@ -1,6 +1,6 @@
 package org.talend.designer.dbmap.command;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.*;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -47,6 +47,10 @@ public class UpdateELTMapComponentCommandTest {
     private List<ExternalDbMapTable> inputs;
 
     private List<ExternalDbMapTable> outputs;
+    
+    private ExternalDbMapTable input;
+    
+    private ExternalDbMapEntry outputEntry;
 
     @BeforeClass
     public static void beforeClass() {
@@ -74,16 +78,16 @@ public class UpdateELTMapComponentCommandTest {
         connection = new Connection(sourceNode, targetNode, EConnectionType.FLOW_MAIN, "connector", "meta", "oldTable", true);
 
         inputs = (List<ExternalDbMapTable>) targetNode.getExternalData().getInputTables();
-        ExternalDbMapTable input = new ExternalDbMapTable();
+        input = new ExternalDbMapTable();
         input.setName("oldTable");
         input.setTableName("oldTable");
         inputs.add(input);
         
         outputs = (List<ExternalDbMapTable>) targetNode.getExternalData().getOutputTables();
         ExternalDbMapTable output = new ExternalDbMapTable();
-        ExternalDbMapEntry entry = new ExternalDbMapEntry("oldTable", "oldTable.column");
+        outputEntry = new ExternalDbMapEntry("oldTable", "oldTable.column");
         output.setMetadataTableEntries(new ArrayList<ExternalDbMapEntry>());
-        output.getMetadataTableEntries().add(entry);
+        output.getMetadataTableEntries().add(outputEntry);
         outputs.add(output);
     }
 
@@ -91,18 +95,38 @@ public class UpdateELTMapComponentCommandTest {
     public void testUpdateELTMapComponentCommand() throws InterruptedException {
         UpdateELTMapComponentCommand command = new UpdateELTMapComponentCommand(targetNode, connection, "oldTable", "newTable");
         command.execute();
-        validateResult("newTable");
+        validateResult("newTable", "newTable");
         command.undo();
-        validateResult("oldTable");
+        validateResult("oldTable", "oldTable");
         command.redo();
-        validateResult("newTable");
+        validateResult("newTable", "newTable");
     }
+    
+    @Test
+    public void testUpdateELTMapComponentCommandWithAliasSameWithTableName() throws InterruptedException {
+        input.setAlias("oldTable");
+        UpdateELTMapComponentCommand command = new UpdateELTMapComponentCommand(targetNode, connection, "oldTable", "newTable");
+        command.execute();
+        validateResult("newTable", "oldTable");
+        
+    }
+    
+    @Test
+    public void testUpdateELTMapComponentCommandWithAlias() throws InterruptedException {
+        input.setAlias("aliasName");
+        outputEntry.setExpression("aliasName.column");
+        UpdateELTMapComponentCommand command = new UpdateELTMapComponentCommand(targetNode, connection, "oldTable", "newTable");
+        command.execute();
+        validateResult("newTable", "aliasName");
+        
+    }
+    
 
-    private void validateResult(String value) {
-        assertEquals(value, connection.getName());
-        assertEquals(value, inputs.get(0).getName());
-        assertEquals(value, inputs.get(0).getTableName());
-        assertEquals(value + ".column", outputs.get(0).getMetadataTableEntries().get(0).getExpression());
+    private void validateResult(String tableValue, String expressionValue) {
+        assertEquals(tableValue, connection.getName());
+        assertEquals(tableValue, inputs.get(0).getName());
+        assertEquals(tableValue, inputs.get(0).getTableName());
+        assertEquals(expressionValue + ".column", outputs.get(0).getMetadataTableEntries().get(0).getExpression());
     }
 
     private static Property createProperty() {

test/plugins/org.talend.designer.dbmap.test/src/org/talend/designer/dbmap/language/generation/DbGenerationManagerTest.java

@@ -4,6 +4,7 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 import org.junit.After;
@@ -58,6 +59,10 @@ public class DbGenerationManagerTest {
         incomingConnections.add(createConnection("t1", "t1", "id", columns));
         dbMapComponent.setIncomingConnections(incomingConnections);
 
+        if (dbMapComponent.getElementParameters() == null) {
+            dbMapComponent.setElementParameters(Collections.EMPTY_LIST);
+        }
+
         dbManager = new GenericDbGenerationManager();
 
     }

test/plugins/org.talend.designer.dbmap.test/src/org/talend/designer/dbmap/language/oracle/OracleGenerationManagerTest.java

@@ -16,6 +16,7 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 import org.junit.After;
@@ -52,6 +53,10 @@ public class OracleGenerationManagerTest {
         incomingConnections.add(conn);
         dbMapComponent.setIncomingConnections(incomingConnections);
 
+        if (dbMapComponent.getElementParameters() == null) {
+            dbMapComponent.setElementParameters(Collections.EMPTY_LIST);
+        }
+
         oracleManager = new OracleGenerationManager();
 
     }

test/plugins/org.talend.designer.dbmap.test/src/org/talend/designer/dbmap/language/postgres/PostgresGenerationManagerTest.java

@@ -6,6 +6,7 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 import org.junit.Before;
@@ -30,10 +31,14 @@ import org.talend.designer.dbmap.external.data.ExternalDbMapTable;
 
 public class PostgresGenerationManagerTest {
 
-    DbMapComponent component = new DbMapComponent();
+    DbMapComponent component;
 
     @Before
     public void setUp() throws Exception {
+        component = new DbMapComponent();
+        if (component.getElementParameters() == null) {
+            component.setElementParameters(Collections.EMPTY_LIST);
+        }
     }
 
     private void init(String schema, String main_table, String lookup_table) {

test/plugins/org.talend.designer.dbmap.test/src/org/talend/designer/dbmap/service/DbMapServiceTest.java

@@ -19,13 +19,17 @@ public class DbMapServiceTest {
     private String oldValue = "table";
 
     private String newValue = "context.schema.context.table";
+    
+    private InputTable input;
+    
+    private DBMapperTableEntry outEntry;
 
     @Before
     public void setUp() throws Exception {
         nodeType = TalendFileFactory.eINSTANCE.createNodeType();
         DBMapData data = DbmapFactory.eINSTANCE.createDBMapData();
         nodeType.setNodeData(data);
-        InputTable input = DbmapFactory.eINSTANCE.createInputTable();
+        input = DbmapFactory.eINSTANCE.createInputTable();
         input.setName(oldValue);
         input.setTableName(oldValue);
         DBMapperTableEntry inputEntry = DbmapFactory.eINSTANCE.createDBMapperTableEntry();
@@ -35,7 +39,7 @@ public class DbMapServiceTest {
         OutputTable out = DbmapFactory.eINSTANCE.createOutputTable();
         out.setName("output");
         out.setTableName("output");
-        DBMapperTableEntry outEntry = DbmapFactory.eINSTANCE.createDBMapperTableEntry();
+        outEntry = DbmapFactory.eINSTANCE.createDBMapperTableEntry();
         outEntry.setName("column");
         outEntry.setExpression(oldValue + ".column");
         out.getDBMapperTableEntries().add(outEntry);
@@ -56,5 +60,38 @@ public class DbMapServiceTest {
         DBMapperTableEntry outEntry = out.getDBMapperTableEntries().get(0);
         assertEquals("context.schema.context.table.column", outEntry.getExpression());
     }
+    
+    @Test
+    public void testUpdateEMFDBMapDataWithAliasSameWithTable() {
+        input.setAlias(oldValue);
+        DbMapService service = new DbMapService();
+        service.updateEMFDBMapData(nodeType, oldValue, newValue);
+        DBMapData data = (DBMapData) nodeType.getNodeData();
+        InputTable input = data.getInputTables().get(0);
+        assertEquals("context.schema.context.table", input.getName());
+        assertEquals("context.schema.context.table", input.getTableName());
+        OutputTable out = data.getOutputTables().get(0);
+        // output connection name should not be updated.
+        assertEquals("output", out.getName());
+        DBMapperTableEntry outEntry = out.getDBMapperTableEntries().get(0);
+        assertEquals(oldValue + ".column", outEntry.getExpression());
+    }
+    
+    @Test
+    public void testUpdateEMFDBMapDataWithAlias() {
+        input.setAlias("alias");
+        outEntry.setExpression("alias.column");
+        DbMapService service = new DbMapService();
+        service.updateEMFDBMapData(nodeType, oldValue, newValue);
+        DBMapData data = (DBMapData) nodeType.getNodeData();
+        InputTable input = data.getInputTables().get(0);
+        assertEquals("context.schema.context.table", input.getName());
+        assertEquals("context.schema.context.table", input.getTableName());
+        OutputTable out = data.getOutputTables().get(0);
+        // output connection name should not be updated.
+        assertEquals("output", out.getName());
+        DBMapperTableEntry outEntry = out.getDBMapperTableEntries().get(0);
+        assertEquals("alias.column", outEntry.getExpression());
+    }
 
 }

test/plugins/org.talend.designer.runprocess.test/src/org/talend/designer/runprocess/java/JavaProcessorUtilitiesTest.java

@@ -15,11 +15,13 @@ package org.talend.designer.runprocess.java;
 import static org.junit.Assert.*;
 
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.Set;
 
 import org.junit.Assert;
 import org.junit.Test;
 import org.talend.commons.CommonsPlugin;
+import org.talend.commons.utils.VersionUtils;
 import org.talend.core.CorePlugin;
 import org.talend.core.model.components.ComponentCategory;
 import org.talend.core.model.components.IComponent;
@@ -27,8 +29,11 @@ import org.talend.core.model.general.ModuleNeeded;
 import org.talend.core.model.metadata.IMetadataTable;
 import org.talend.core.model.metadata.MetadataColumn;
 import org.talend.core.model.process.EConnectionType;
+import org.talend.core.model.properties.ProcessItem;
 import org.talend.core.model.properties.PropertiesFactory;
 import org.talend.core.model.properties.Property;
+import org.talend.core.repository.model.ProxyRepositoryFactory;
+import org.talend.core.runtime.process.LastGenerationInfo;
 import org.talend.core.ui.component.ComponentsFactoryProvider;
 import org.talend.designer.core.ui.editor.connections.Connection;
 import org.talend.designer.core.ui.editor.nodecontainer.NodeContainer;
@@ -111,6 +116,63 @@ public class JavaProcessorUtilitiesTest {
         }
     }
 
+    @Test
+    public void testGetNeededModulesForProcess() {
+        String jobId = ProxyRepositoryFactory.getInstance().getNextId();
+        String jobVersion = VersionUtils.DEFAULT_VERSION;
+        Property property = PropertiesFactory.eINSTANCE.createProperty();
+        property.setId(jobId);
+        property.setVersion(jobVersion);
+        Process process = new Process(property);
+        ProcessItem item = PropertiesFactory.eINSTANCE.createProcessItem();
+        item.setProperty(property);
+
+        ModuleNeeded moduleNeeded_A = new ModuleNeeded(null, "a.jar", null, true);
+        ModuleNeeded moduleNeeded_B = new ModuleNeeded(null, "b.jar", null, true);
+        ModuleNeeded moduleNeeded_C = new ModuleNeeded(null, "c.jar", null, true);
+        ModuleNeeded moduleNeeded_D = new ModuleNeeded(null, "d.jar", null, true);
+        ModuleNeeded moduleNeeded_E = new ModuleNeeded(null, "e.jar", null, true);
+
+        Set<ModuleNeeded> neededModules = LastGenerationInfo.getInstance().getModulesNeededWithSubjobPerJob(jobId, jobVersion);
+        neededModules.add(moduleNeeded_A);
+        neededModules.add(moduleNeeded_B);
+        neededModules.add(moduleNeeded_C);
+        neededModules.add(moduleNeeded_D);
+
+        Set<ModuleNeeded> highPriorityNeededModules = LastGenerationInfo.getInstance().getHighPriorityModuleNeeded();
+        highPriorityNeededModules.clear();
+        highPriorityNeededModules.add(moduleNeeded_C);
+        highPriorityNeededModules.add(moduleNeeded_A);
+        highPriorityNeededModules.add(moduleNeeded_E);
+
+        Set<ModuleNeeded> result = JavaProcessorUtilities.getNeededModulesForProcess(process);
+        assertEquals(5, result.size());
+        int i = 0;
+        Iterator<ModuleNeeded> iterator = result.iterator();
+        while (iterator.hasNext()) {
+            ModuleNeeded moduleNeeded = iterator.next();
+            switch (i) {
+            case 0:
+                assertEquals(moduleNeeded, moduleNeeded_E);
+                break;
+            case 1:
+                assertEquals(moduleNeeded, moduleNeeded_A);
+                break;
+            case 2:
+                assertEquals(moduleNeeded, moduleNeeded_C);
+                break;
+            case 3:
+                assertEquals(moduleNeeded, moduleNeeded_B);
+                break;
+            case 4:
+                assertEquals(moduleNeeded, moduleNeeded_D);
+                break;
+            default:
+            }
+            i++;
+        }
+    }
+
     private void createMetadataColumns(IMetadataTable table, int columns) {
         for (int i = 0; i < columns; i++) {
             MetadataColumn newColumn = new MetadataColumn();