ExplorerViewer.java

/*******************************************************************************
 * Copyright (c) 2013 hangum.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the GNU Lesser Public License v2.1
 * which accompanies this distribution, and is available at
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * 
 * Contributors:
 *     hangum - initial API and implementation
 ******************************************************************************/
package com.hangum.tadpole.rdb.core.viewers.object;

import java.util.Arrays;
import java.util.HashMap;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CTabFolder;
import org.eclipse.swt.custom.CTabItem;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;

import com.hangum.tadpole.commons.google.analytics.AnalyticCaller;
import com.hangum.tadpole.commons.libs.core.define.PublicTadpoleDefine;
import com.hangum.tadpole.commons.libs.core.define.PublicTadpoleDefine.OBJECT_TYPE;
import com.hangum.tadpole.commons.libs.core.define.PublicTadpoleDefine.QUERY_DDL_TYPE;
import com.hangum.tadpole.commons.libs.core.message.CommonMessages;
import com.hangum.tadpole.commons.util.TadpoleWidgetUtils;
import com.hangum.tadpole.commons.viewsupport.SelectionProviderMediator;
import com.hangum.tadpole.engine.define.DBDefine;
import com.hangum.tadpole.engine.define.DBGroupDefine;
import com.hangum.tadpole.engine.manager.InitializeDB;
import com.hangum.tadpole.engine.query.dao.system.UserDBDAO;
import com.hangum.tadpole.engine.query.dao.system.UserDBResourceDAO;
import com.hangum.tadpole.engine.query.dao.system.userdb.DBOtherDAO;
import com.hangum.tadpole.engine.query.dao.system.userdb.ResourcesDAO;
import com.hangum.tadpole.engine.query.sql.DBSystemSchema;
import com.hangum.tadpole.engine.security.TadpoleSecurityManager;
import com.hangum.tadpole.engine.utils.RequestQuery;
import com.hangum.tadpole.rdb.core.Messages;
import com.hangum.tadpole.rdb.core.viewers.connections.ManagerViewer;
import com.hangum.tadpole.rdb.core.viewers.object.sub.AbstractObjectComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.agens.TadpoleGraphPathComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.agens.edge.TadpoleEdgeComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.agens.vertex.TadpoleVertexComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.mongodb.collections.TadpoleMongoDBCollectionComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.mongodb.index.TadpoleMongoDBIndexesComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.mongodb.serversidescript.TadpoleMongoDBJavaScriptComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.dblink.TadpoleDBLinkComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.function.TadpoleFunctionComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.java.TadpoleJavaComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.jobs.TadpoleJobsComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.orapackage.TadpolePackageComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.procedure.TadpoleProcedureComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.sequence.TadpoleSequenceComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.sysnonym.TadpoleSynonymComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.table.TadpoleTableComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.table.trigger.TadpoleTriggerComposite;
import com.hangum.tadpole.rdb.core.viewers.object.sub.rdb.view.TadpoleViewerComposite;

/**
 * object explorer viewer
 * 
 * @author hangum
 * 
 */
public class ExplorerViewer extends ViewPart {
	private static Logger logger = Logger.getLogger(ExplorerViewer.class);
	public static String ID = "com.hangum.tadpole.rdb.core.view.object.explorer"; //$NON-NLS-1$
	
	/** schema list */
	private Combo comboSchema;
	
	/** tabfolder가 초기화 될때는 tab select 이벤트 먹지 않도록 조절하지 않도록 */
	private boolean boolInitObjectHead = true;

	/** multi structured viewer */
	private StructuredViewer[] arrayStructuredViewer = null;

	private UserDBDAO userDB;
	private CTabFolder tabFolderObject;
	private Text textSearch;
	
	// rdb
	private Composite compositeBody;
	
	private TadpoleTableComposite 		tableComposite 		= null;
	private TadpoleViewerComposite 		viewComposite 		= null;

	private TadpoleTriggerComposite 	triggerComposite    = null;
	
	// oracle
	private TadpoleSynonymComposite 	synonymComposite 	= null;
	private TadpoleSequenceComposite 	sequenceComposite 	= null;
	private TadpoleDBLinkComposite 	    dblinkComposite 	= null;
	private TadpoleJobsComposite 	    jobsComposite 	    = null;
	private TadpoleJavaComposite 	    javaComposite 	    = null;
	
	private TadpoleProcedureComposite	procedureComposite 	= null;
	private TadpolePackageComposite	    packageComposite 	= null;
	private TadpoleFunctionComposite 	functionCompostite 	= null;
	
	// mongodb
	private TadpoleMongoDBCollectionComposite mongoCollectionComposite 	= null;
	private TadpoleMongoDBIndexesComposite mongoIndexComposite 			= null;
	private TadpoleMongoDBJavaScriptComposite mongoJavaScriptComposite 	= null;
	
	// agens graph
	private TadpoleGraphPathComposite agensGraphPathComposite = null;
	private TadpoleVertexComposite agensVertexComposite = null;
	private TadpoleEdgeComposite agensEdgeComposite = null;

	public ExplorerViewer() {
		super();
	}

	@Override
	public void createPartControl(Composite parent) {
		setPartName(Messages.get().ObjectExplorer);
		
		GridLayout gl_parent = new GridLayout(1, false);
		gl_parent.marginWidth = 1;
		gl_parent.verticalSpacing = 0;
		gl_parent.horizontalSpacing = 0;
		gl_parent.marginHeight = 0;
		parent.setLayout(gl_parent);
		
		Composite compositeSchema = new Composite(parent, SWT.NONE);
		compositeSchema.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
		GridLayout gl_compositeSchema = new GridLayout(2, false);
		gl_compositeSchema.horizontalSpacing = 2;
		gl_compositeSchema.verticalSpacing = 2;
		gl_compositeSchema.marginHeight = 2;
		gl_compositeSchema.marginWidth = 2;
		compositeSchema.setLayout(gl_compositeSchema);
		
		Label labelSchema = new Label(compositeSchema, SWT.NONE);
		labelSchema.setLayoutData(new GridData(SWT.NONE, SWT.NONE, false, false, 1, 1));
		labelSchema.setText(Messages.get().Schemas);
		
		comboSchema = new Combo(compositeSchema, SWT.NONE | SWT.READ_ONLY);
		comboSchema.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				changeSchema(comboSchema.getText());
			}
		});
		comboSchema.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
		
		Composite compositeSearch = new Composite(parent, SWT.NONE);
		compositeSearch.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
		GridLayout gl_compositeSearch = new GridLayout(2, false);
		gl_compositeSearch.horizontalSpacing = 2;
		gl_compositeSearch.verticalSpacing = 2;
		gl_compositeSearch.marginHeight = 2;
		gl_compositeSearch.marginWidth = 2;
		compositeSearch.setLayout(gl_compositeSearch);

		Label labelFilter = new Label(compositeSearch, SWT.NONE);
		labelFilter.setLayoutData(new GridData(SWT.NONE, SWT.NONE, false, false, 1, 1));
		labelFilter.setText(CommonMessages.get().Filter);
		
		// filter를 설정합니다.
		textSearch = new Text(compositeSearch, SWT.SEARCH | SWT.ICON_SEARCH | SWT.ICON_CANCEL);
		textSearch.addKeyListener(new KeyAdapter() {
			@Override
			public void keyPressed(KeyEvent e) {
				filterText();
			}
		});
		textSearch.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));

		compositeBody = new Composite(parent, SWT.NONE);
		compositeBody.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
		GridLayout gl_compositeBody = new GridLayout(1, false);
		gl_compositeBody.verticalSpacing = 2;
		gl_compositeBody.horizontalSpacing = 2;
		gl_compositeBody.marginHeight = 2;
		gl_compositeBody.marginWidth = 2;
		compositeBody.setLayout(gl_compositeBody);
		
		tabFolderObject = new CTabFolder(compositeBody, SWT.NONE);
		tabFolderObject.setBorderVisible(false);
		tabFolderObject.setSelectionBackground(TadpoleWidgetUtils.getTabFolderBackgroundColor(), TadpoleWidgetUtils.getTabFolderPercents());
		
		tabFolderObject.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent evt) {
				if (userDB == null) return;
				if(boolInitObjectHead) {
					CTabItem ct = (CTabItem)evt.item;
					refershSelectObject(""+ct.getData(AbstractObjectComposite.TAB_DATA_KEY));
				}
			}
		});
		tabFolderObject.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));

		// dumy table
		createTable();

		// Connection View에서 선택이벤트 받기.
		getSite().getPage().addSelectionListener(ManagerViewer.ID, managementViewerListener);

		// erd table에 선택되었을때..
		PlatformUI.getPreferenceStore().addPropertyChangeListener(new IPropertyChangeListener() {
			@Override
			public void propertyChange(PropertyChangeEvent event) {

				if (event.getProperty() == PublicTadpoleDefine.SELECT_ERD_TABLE) {
					String tableName = event.getNewValue().toString();
					if (tabFolderObject.getSelectionIndex() != 0) tabFolderObject.setSelection(0);

					tableComposite.selectTable(tableName);
				} // end if(event.getProperty()
			} //
		}); // end property change
	}
	
	/**
	 * filter text
	 */
	private void filterText() {
		String strSelectTab = ""+tabFolderObject.getItem(tabFolderObject.getSelectionIndex()).getData(AbstractObjectComposite.TAB_DATA_KEY);
		String strSearchText = textSearch.getText();
		
		if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.COLLECTIONS.name())) {
			mongoCollectionComposite.filter(strSearchText);
		
		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.TABLES.name())) {
			tableComposite.filter(strSearchText);
		
		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.SYNONYM.name())) {
			synonymComposite.filter(strSearchText);

		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.SEQUENCE.name())) {
			sequenceComposite.filter(strSearchText);

		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.LINK.name())) {
			dblinkComposite.filter(strSearchText);

		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.JOBS.name())) {
			jobsComposite.filter(strSearchText);

		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.JAVA.name())) {
			javaComposite.filter(strSearchText);

		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.VIEWS.name())) {
			viewComposite.filter(strSearchText);					
		
		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.INDEXES.name())) {
			if(userDB != null && DBGroupDefine.MONGODB_GROUP == userDB.getDBGroup()) {
				mongoIndexComposite.filter(strSearchText);
			}					
		
		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.PROCEDURES.name())) {
			procedureComposite.filter(strSearchText);
		
		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.PACKAGES.name())) {
			packageComposite.filter(strSearchText);
		
		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.FUNCTIONS.name())) {
			functionCompostite.filter(strSearchText);
		
		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.TRIGGERS.name())) {
			triggerComposite.filter(strSearchText);
		
		} else if (strSelectTab.equalsIgnoreCase(OBJECT_TYPE.JAVASCRIPT.name())) {
			mongoJavaScriptComposite.filter(strSearchText);
		}
	}
	
	/**
	 *  change schema name
	 */
	public void changeSchema(String strSchemaName) {
//		if(strSchemaName.equals(comboSchema.getText())) return;
		
		comboSchema.setText(strSchemaName);
		userDB.setSchema(strSchemaName);
		if(logger.isDebugEnabled()) logger.debug("*** Change schema name is " + strSchemaName);
		
		// 기존 스키마에 대해 조회되어 있던 내용을 초기화 한다.
		
		if(null != tableComposite) tableComposite.clearList(); 
		if(null != viewComposite) viewComposite.clearList(); 
		if(null != synonymComposite) synonymComposite.clearList();
		if(null != sequenceComposite) sequenceComposite.clearList();
		if(null != procedureComposite) procedureComposite.clearList(); 
		if(null != packageComposite) packageComposite.clearList(); 
		if(null != functionCompostite) functionCompostite.clearList(); 
		if(null != triggerComposite) triggerComposite.clearList(); 
		if(null != dblinkComposite) dblinkComposite.clearList();
		if(null != jobsComposite) jobsComposite.clearList();
		if(null != javaComposite) javaComposite.clearList();
		
		if(null != this.agensGraphPathComposite) agensGraphPathComposite.clearList();
		if(null != this.agensVertexComposite) agensVertexComposite.clearList();
		if(null != this.agensEdgeComposite) agensEdgeComposite.clearList();

		// 아젠스 그래프 디비인 경우는 첫번째 탭이 그래프 패스 이므로 그래프 패스가 선택 되도록 한다.
		if(DBDefine.AGENSGRAPH_DEFAULT == userDB.getDBDefine()) {
			//refershSelectObject(PublicTadpoleDefine.OBJECT_TYPE.GRAPHPATH.name());
			this.agensGraphPathComposite.refreshGraphPath(userDB, true, "");
		}else{
			tableComposite.refreshTable(userDB, true, "");
		}
		
	}

	/**
	 * management의 tree가 선택되었을때
	 */
	private ISelectionListener managementViewerListener = new ISelectionListener() {

		@Override
		public void selectionChanged(IWorkbenchPart part, ISelection selection) {
			if (selection instanceof IStructuredSelection) {
				IStructuredSelection is = (IStructuredSelection) selection;
				boolInitObjectHead = false;
				initObjectHead(is.getFirstElement());
				boolInitObjectHead = true;
			} // end selection			
		} // end selectionchange
	};

	/**
	 * management의 head가 선택되었을때
	 * 
	 * @param selectElement
	 */
	public void initObjectHead(Object selectElement) {
		// 기존 사용자원을 반납합니다. 
		if(textSearch.isDisposed()) return; 
			
		textSearch.setText("");
		if(null != tableComposite) tableComposite.dispose(); 
		if(null != viewComposite) viewComposite.dispose(); 
		if(null != synonymComposite) synonymComposite.dispose();
		if(null != sequenceComposite) sequenceComposite.dispose();
		if(null != procedureComposite) procedureComposite.dispose(); 
		if(null != packageComposite) packageComposite.dispose(); 
		if(null != functionCompostite) functionCompostite.dispose(); 
		if(null != triggerComposite) triggerComposite.dispose(); 
		if(null != dblinkComposite) dblinkComposite.dispose();
		if(null != jobsComposite) jobsComposite.dispose();
		if(null != javaComposite) javaComposite.dispose();
		
		if(null != this.agensGraphPathComposite) agensGraphPathComposite.dispose();
		if(null != this.agensVertexComposite) agensVertexComposite.dispose();
		if(null != this.agensEdgeComposite) agensEdgeComposite.dispose();
		
		if(null != mongoCollectionComposite) { 
			mongoCollectionComposite.dispose();
			mongoIndexComposite.dispose();
			mongoJavaScriptComposite.dispose();
		}
		
		// Initialize resources
		if (selectElement instanceof UserDBDAO || selectElement instanceof UserDBResourceDAO) {
			selectUserDB(selectElement);
		} else if(selectElement instanceof ResourcesDAO) {
			ResourcesDAO dao = (ResourcesDAO)selectElement;
			selectUserDB(dao.getUserDBDAO());
		} else if(selectElement instanceof DBOtherDAO) {
			DBOtherDAO dao = (DBOtherDAO)selectElement;
			try {
				UserDBDAO schemaUserDB = (UserDBDAO)dao.getParent().getUserDBDAO().clone();
				schemaUserDB.setSchema(dao.getName());
			
				selectUserDB(schemaUserDB);
			} catch(Exception e) {
				logger.error("cloable not support exception", e);
			}
		} else {
			userDB = null;

			// 존재하는 tadfolder를 삭제한다.
			for (CTabItem tabItem : tabFolderObject.getItems()) tabItem.dispose();
			createTable();
		}
		
	}
	
	/**
	 * initialize schema
	 */
	private void initSchema() throws Exception {
		if(userDB == null) return;
		// 디비 락이 있을 경우에 커넥션 시도를 하지 못하도록 합니다. 
		if(!TadpoleSecurityManager.getInstance().isLock(userDB)) return;
		
		/** schema list*/
		comboSchema.removeAll();
		if(userDB.getDBGroup() == DBGroupDefine.POSTGRE_GROUP) {
			try {
				
				// public schema가 선택되도록 합니다.
				// 스키마 리스트를 초기화 시킨다.
				boolean isPublicExist = false;
				for (Object object : DBSystemSchema.getSchemas(userDB)) {
					HashMap mapData = (HashMap)object;
					comboSchema.add(""+mapData.get("schema"));
					if("public".equals(mapData.get("schema"))) isPublicExist = true;
				}
				
				if(isPublicExist) comboSchema.setText("public");
				else comboSchema.select(0);
				
				userDB.setSchema(comboSchema.getText());
			} catch(Exception e) {
				logger.error("get system schemas " + e.getMessage());
				throw e;
			}
		}else if(userDB.getDBGroup() == DBGroupDefine.ORACLE_GROUP){
			
			try {
				for (Object object : DBSystemSchema.getSchemas(userDB)) {
					HashMap<String, String> mapData = (HashMap)object;
					comboSchema.add(mapData.get("SCHEMA"));
				}

				comboSchema.select(0);
				//TODO: 최초 로그인시 userDB 설정시 기본 스키마 지정해 놓는 방법.
				userDB.setSchema(comboSchema.getText());
			} catch (Exception e) {
				comboSchema.setItems( new String[]{userDB.getSchema()} );
				throw e;
			}
		}else if(userDB.getDBGroup() == DBGroupDefine.MYSQL_GROUP){
			try {
				for (Object object : DBSystemSchema.getSchemas(userDB)) {
					HashMap<String, String> mapData = (HashMap)object;
					comboSchema.add(mapData.get("SCHEMA"));
					if (StringUtils.equalsIgnoreCase(mapData.get("SCHEMA"), userDB.getDb())) {
						userDB.setSchema(mapData.get("SCHEMA"));
						comboSchema.select(comboSchema.getItemCount()-1);	
					}
				}
				this.refreshTable(false, "");
			} catch (Exception e) {
				comboSchema.setItems( new String[]{userDB.getSchema()} );
				logger.error("get system schemas " + e.getMessage());
				throw e;
			}
		}else if(userDB.getDBGroup() == DBGroupDefine.SQLITE_GROUP) {
		
			comboSchema.add(userDB.getDb());
			comboSchema.setText(userDB.getDb());
		}else{
			comboSchema.add(userDB.getDb());
			comboSchema.setText(userDB.getDb());
		}
		comboSchema.setVisibleItemCount(comboSchema.getItemCount() > 15 ? 15 : comboSchema.getItemCount());
		
		// 스키마 목록을 재상용하기 위해 기록합니다. 
		userDB.setSchemas(Arrays.asList(comboSchema.getItems()));
		
		// initialize UserDB
		InitializeDB.dbInfo(userDB);
		
		// refresh manager viewer
		refreshManagerViewUserDB();
	}
	
	/**
	 * refresh manager viewer
	 */
	private void refreshManagerViewUserDB() {
		final ManagerViewer managerView = (ManagerViewer)PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().findView(ManagerViewer.ID);
		managerView.getManagerTV().refresh(userDB, true);
	}

	/**
	 * select user databse
	 * @param selectElement
	 */
	private void selectUserDB(Object selectElement) {
		UserDBDAO selectUserDb = null;
		if (selectElement instanceof UserDBDAO) selectUserDb = (UserDBDAO)selectElement;
		else 									selectUserDb = ((UserDBResourceDAO)selectElement).getParent();
		
		// 기존 디비가 중복 선택되었으면 리프레쉬 하지 않는다.
		if (userDB != null) {
			if (userDB.getSeq() == selectUserDb.getSeq()) {
				filterText();
				userDB = selectUserDb;		
				return;
			}
		}
		// 디비 선택
		userDB = selectUserDb;

		// 존재하는 tadfolder를 삭제한다.
		for (CTabItem tabItem : tabFolderObject.getItems()) tabItem.dispose();
		
		// 디비 락이 있을 경우에 커넥션 시도를 하지 못하도록 합니다. 
		if(!TadpoleSecurityManager.getInstance().isLock(selectUserDb)) {
			userDB = null;
			createTable();
		} else {
			try { 
				initSchema();
				initObjectDetail(userDB);
			} catch(Exception e) {
				logger.error("initialize database " + e.getMessage());
				userDB = null;
				createTable();

				MessageDialog.openError(getSite().getShell(), CommonMessages.get().Error, Messages.get().doNotConnectionDB +  e.getMessage().toString());
			}
		}
	}
	
	/**
	 * 다른 디비가 선택되어 지면 초기화 되어야 할 object 목록
	 * 
	 * @param userDB Manager에서 선택된 object
	 */
	private void initObjectDetail(final UserDBDAO userDB) {
		
		// sqlite
		if (DBGroupDefine.SQLITE_GROUP == userDB.getDBGroup()) {
			createTable();
			createView();
			
			arrayStructuredViewer = new StructuredViewer[] { 
				tableComposite.getTableListViewer(), 
				tableComposite.getTableColumnViewer(),
				tableComposite.getIndexComposite().getTableViewer(),
				tableComposite.getTriggerComposite().getTableViewer(),
				viewComposite.getTableViewer()
			};
			getViewSite().setSelectionProvider(new SelectionProviderMediator(arrayStructuredViewer, tableComposite.getTableListViewer()));

		// tajo, hive, hive2
		} else if (DBGroupDefine.HIVE_GROUP == userDB.getDBGroup() || DBGroupDefine.TAJO_GROUP == userDB.getDBGroup()) {
			createTable();
			
			arrayStructuredViewer = new StructuredViewer[] { 
					tableComposite.getTableListViewer(),
					tableComposite.getTableColumnViewer()
				};
			getViewSite().setSelectionProvider(new SelectionProviderMediator(arrayStructuredViewer, tableComposite.getTableListViewer()));
				
		// mongodb
		} else if (DBGroupDefine.MONGODB_GROUP == userDB.getDBGroup()) {
			createMongoCollection();
			createMongoIndex();
			createMongoJavaScript();
			
			arrayStructuredViewer = new StructuredViewer[] { 
				mongoCollectionComposite.getCollectionListViewer(),
				mongoIndexComposite.getTableViewer(),
				mongoJavaScriptComposite.getTableViewer()
			};
			getViewSite().setSelectionProvider(new SelectionProviderMediator(arrayStructuredViewer, mongoCollectionComposite.getCollectionListViewer()));

		// oracle , tibero
		} else if (DBGroupDefine.ORACLE_GROUP == userDB.getDBGroup()) {
			createTable();
			createView();
			createSynonym();
			createSequence();
			createProcedure();
			createPackage();
			createFunction();
			createTrigger();
			createDBLink();
			if (DBDefine.ORACLE_DEFAULT == userDB.getDBDefine()) {
				createJobs();
				createJava();
				
				arrayStructuredViewer = new StructuredViewer[] { 
					tableComposite.getTableListViewer(),
					tableComposite.getTableColumnViewer(),
					tableComposite.getIndexComposite().getTableViewer(),
					tableComposite.getConstraintsComposite().getTableViewer(),
					tableComposite.getTriggerComposite().getTableViewer(),
					viewComposite.getTableViewer(), 
					synonymComposite.getTableviewer(), 
					sequenceComposite.getTableviewer(),
					procedureComposite.getTableViewer(), 
					packageComposite.getPackageTableViewer(), 
					packageComposite.getProcFuncTableViewer(),
					functionCompostite.getTableviewer(),
					triggerComposite.getTableViewer(),
					dblinkComposite.getTableviewer(),
					jobsComposite.getTableviewer(),
					javaComposite.getTableviewer()
				};
			}else{
				arrayStructuredViewer = new StructuredViewer[] { 
						tableComposite.getTableListViewer(),
						tableComposite.getTableColumnViewer(),
						tableComposite.getIndexComposite().getTableViewer(),
						tableComposite.getConstraintsComposite().getTableViewer(),
						tableComposite.getTriggerComposite().getTableViewer(),
						viewComposite.getTableViewer(), 
						synonymComposite.getTableviewer(), 
						sequenceComposite.getTableviewer(),
						procedureComposite.getTableViewer(), 
						packageComposite.getPackageTableViewer(), 
						packageComposite.getProcFuncTableViewer(),
						functionCompostite.getTableviewer(),
						triggerComposite.getTableViewer(),
						dblinkComposite.getTableviewer()
					};
			}
			getViewSite().setSelectionProvider(new SelectionProviderMediator(arrayStructuredViewer, tableComposite.getTableListViewer()));
			
		// altibase, cubrid
		} else if (DBGroupDefine.ALTIBASE_GROUP == userDB.getDBGroup() ||
				DBGroupDefine.CUBRID_GROUP == userDB.getDBGroup() ||
				DBGroupDefine.POSTGRE_GROUP == userDB.getDBGroup()
		) {
			if(DBDefine.AGENSGRAPH_DEFAULT == userDB.getDBDefine()) {
				createGraphPath();
				createVertex();
				createEdge();
				
				createTable();
				createView();
				createProcedure();
				createFunction();
				createTrigger();
			
				
				
				arrayStructuredViewer = new StructuredViewer[] { 
					agensGraphPathComposite.getTableviewer(),
					agensVertexComposite.getTableviewer(),
					agensEdgeComposite.getTableviewer(),
					tableComposite.getTableListViewer(), 
					tableComposite.getTableColumnViewer(),
					tableComposite.getIndexComposite().getTableViewer(),
					tableComposite.getTriggerComposite().getTableViewer(),
					viewComposite.getTableViewer(), 
					procedureComposite.getTableViewer(), 
					functionCompostite.getTableviewer(),
					triggerComposite.getTableViewer()
				};
			} else if(DBDefine.AMAZON_REDSHIFT_DEFAULT == userDB.getDBDefine()) {
				createTable();
				createView();
				
				arrayStructuredViewer = new StructuredViewer[] { 
						tableComposite.getTableListViewer(), 
						tableComposite.getTableColumnViewer(),
						tableComposite.getIndexComposite().getTableViewer(),
						tableComposite.getTriggerComposite().getTableViewer(),
						viewComposite.getTableViewer()
					};
			} else {
				createTable();
				createView();
				
				createProcedure();
				createFunction();
				createTrigger();
				
				arrayStructuredViewer = new StructuredViewer[] { 
					tableComposite.getTableListViewer(), 
					tableComposite.getTableColumnViewer(),
					tableComposite.getIndexComposite().getTableViewer(),
					tableComposite.getTriggerComposite().getTableViewer(),
					viewComposite.getTableViewer(), 
					procedureComposite.getTableViewer(), 
					functionCompostite.getTableviewer(),
					triggerComposite.getTableViewer()
				};
			}						
			getViewSite().setSelectionProvider(new SelectionProviderMediator(arrayStructuredViewer, tableComposite.getTableListViewer()));			
		// mysql, postgre, mssql
		} else {
			createTable();
			createView();
			createProcedure();
			createFunction();
			createTrigger();
			
			arrayStructuredViewer = new StructuredViewer[] { 
				tableComposite.getTableListViewer(), 
				tableComposite.getTableColumnViewer(),
				tableComposite.getIndexComposite().getTableViewer(),
				tableComposite.getConstraintsComposite().getTableViewer(),
				tableComposite.getTriggerComposite().getTableViewer(),
				viewComposite.getTableViewer(), 
				procedureComposite.getTableViewer(), 
				functionCompostite.getTableviewer(),
				triggerComposite.getTableViewer()
			};
			getViewSite().setSelectionProvider(new SelectionProviderMediator(arrayStructuredViewer, tableComposite.getTableListViewer()));
		}
		if(DBDefine.AGENSGRAPH_DEFAULT == userDB.getDBDefine()) {
			refershSelectObject(PublicTadpoleDefine.OBJECT_TYPE.GRAPHPATH.name());
		}else{
			refershSelectObject(PublicTadpoleDefine.OBJECT_TYPE.TABLES.name());
		}
	}
	
	/**
	 * Refresh the select tab.
	 * 
	 * @param strSelectItemText
	 */
	private void refershSelectObject(String strSelectItemText) {
		refershSelectObject(strSelectItemText, false, "");
	}
	
	/**
	 * 현재 선택된 tab을 리프레쉬합니다.
	 * 
	 * @param strSelectItemText TabItem text
	 * @param isRefresh
	 * @param strObjectName
	 */
	private void refershSelectObject(String strSelectItemText, boolean isRefresh, String strObjectName) {

		if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.TABLES.name())) {
			refreshTable(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.INDEXES.name())) {
			refreshIndexes(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.CONSTRAINTS.name())) {
			refreshConstraints(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.TRIGGERS.name())) {
			refreshTrigger(isRefresh, strObjectName);	
			refreshAllTrigger(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.VIEWS.name())) {
			refreshView(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.SYNONYM.name())) {
			refreshSynonym(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.SEQUENCE.name())) {
			refreshSequence(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.PROCEDURES.name())) {
			refreshProcedure(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.PACKAGES.name())) {
			refreshPackage(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.FUNCTIONS.name())) {
			refreshFunction(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.JAVASCRIPT.name())) {
			refreshJS(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.LINK.name())) {
			refreshDBLink(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.JOBS.name())) {
			refreshJobs(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.JAVA.name())) {
			refreshJava(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.VERTEX.name())) {
			refreshVertex(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.EDGE.name())) {
			refreshEdge(isRefresh, strObjectName);
		} else if (strSelectItemText.equalsIgnoreCase(OBJECT_TYPE.GRAPHPATH.name())) {
			refreshGraph(isRefresh, strObjectName);
		}
		filterText();
		
		// google analytic
		AnalyticCaller.track(ExplorerViewer.ID, strSelectItemText);
	}
	
	/**
	 * selected tab refresh
	 */
	private void refreshSelectTab() {
		refershSelectObject(tabFolderObject.getSelection().getText(), false, "");
	}
	
	/**
	 * mongo server side javascript define
	 */
	private void createMongoJavaScript() {
		mongoJavaScriptComposite = new TadpoleMongoDBJavaScriptComposite(getSite(), tabFolderObject, userDB);
		mongoJavaScriptComposite.initAction();
	}
	
	/**
	 * mongodb collection define
	 */
	private void createMongoCollection() {
		mongoCollectionComposite = new TadpoleMongoDBCollectionComposite(getSite(), tabFolderObject, userDB);
		mongoCollectionComposite.initAction();
		tabFolderObject.setSelection(0);
	}
	
	/**
	 * mongodb index define
	 */
	private void createMongoIndex() {
		mongoIndexComposite = new TadpoleMongoDBIndexesComposite(getSite(), tabFolderObject, userDB);
		mongoIndexComposite.initAction();
	}

	/**
	 * Function 정의
	 */
	private void createFunction() {
		functionCompostite = new TadpoleFunctionComposite(getSite(), tabFolderObject, userDB);
		functionCompostite.initAction();
	}

	/**
	 * Trigger 정의
	 */
	private void createTrigger() {
		triggerComposite = new TadpoleTriggerComposite(getSite(), tabFolderObject, userDB);
		triggerComposite.initAction();
	}

	/**
	 * Procedure 정의
	 */
	private void createProcedure() {
		procedureComposite = new TadpoleProcedureComposite(getSite(), tabFolderObject, userDB);
		procedureComposite.initAction();
	}

	/**
	 * Package 정의
	 */
	private void createPackage() {
		packageComposite = new TadpolePackageComposite(getSite(), tabFolderObject, userDB);
		packageComposite.initAction();
	}

	/**
	 * view 정의
	 */
	private void createView() {
		viewComposite = new TadpoleViewerComposite(getSite(), tabFolderObject, userDB);
		viewComposite.initAction();
	}
	
	/**
	 * Table 정의
	 */
	private void createTable() {
		tableComposite = new TadpoleTableComposite(getSite(), tabFolderObject, userDB);
		tableComposite.initAction();
		tabFolderObject.setSelection(0);
	}

	/**
	 * Synonym 정의
	 */
	private void createSynonym() {
		synonymComposite = new TadpoleSynonymComposite(getSite(), tabFolderObject, userDB);
		synonymComposite.initAction();
	}

	/**
	 * Synonym 정보를 최신으로 리프레쉬합니다.
	 */
	public void refreshSynonym(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.SYNONYM, userDB.getDefaultSchemanName(), null);
		synonymComposite.refreshSynonym(getUserDB(), boolRefresh, strObjectName);
	}

	/**
	 * Sequence 정의
	 */
	private void createSequence() {
		sequenceComposite = new TadpoleSequenceComposite(getSite(), tabFolderObject, userDB);
		sequenceComposite.initAction();
	}

	/**
	 * Database link 정의
	 */
	private void createDBLink() {
		dblinkComposite = new TadpoleDBLinkComposite(getSite(), tabFolderObject, userDB);
		dblinkComposite.initAction();
	}

	/**
	 * Database Link 정보를 최신으로 리프레쉬합니다.
	 */
	public void refreshDBLink(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.LINK, userDB.getDefaultSchemanName(), null);
		dblinkComposite.refreshDBLink(getUserDB(), boolRefresh, strObjectName);
	}

	/**
	 * Sequence 정보를 최신으로 리프레쉬합니다.
	 */
	public void refreshSequence(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.SEQUENCE, userDB.getDefaultSchemanName(), null);
		sequenceComposite.refreshSequence(getUserDB(), boolRefresh, strObjectName);
	}

	/**
	 * Job 정의
	 */
	private void createJobs() {
		jobsComposite = new TadpoleJobsComposite(getSite(), tabFolderObject, userDB);
		jobsComposite.initAction();
	}

	/**
	 * Job 정보를 최신으로 리프레쉬합니다.
	 */
	public void refreshJobs(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.JOBS, userDB.getDefaultSchemanName(), null);
		jobsComposite.refreshJobs(getUserDB(), boolRefresh, strObjectName);
	}

	/**
	 * Java 정의
	 */
	private void createJava() {
		javaComposite = new TadpoleJavaComposite(getSite(), tabFolderObject, userDB);
		javaComposite.initAction();
	}
	
	/**
	 * Graph Path
	 */
	private void createGraphPath() {
		agensGraphPathComposite = new TadpoleGraphPathComposite(getSite(), tabFolderObject, userDB, this);
		agensGraphPathComposite.initAction();
	}
	
	/**
	 * agens vertext정의 
	 */
	private void createVertex() {
		agensVertexComposite = new TadpoleVertexComposite(getSite(), tabFolderObject, userDB);
		agensVertexComposite.initAction();
	}
	
	/**
	 * agens edge
	 */
	private void createEdge() {
		agensEdgeComposite = new TadpoleEdgeComposite(getSite(), tabFolderObject, userDB);
		agensEdgeComposite.initAction();
	}

	/**
	 * Job 정보를 최신으로 리프레쉬합니다.
	 */
	public void refreshJava(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.JAVA, userDB.getDefaultSchemanName(), null);
		javaComposite.refreshJava(getUserDB(), boolRefresh, strObjectName);
	}

	/**
	 * view 정보를 최신으로 리프레쉬합니다.
	 */
	public void refreshView(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.VIEWS, userDB.getDefaultSchemanName(), null);
		viewComposite.refreshView(getUserDB(), boolRefresh, strObjectName);
	}

	/**
	 * index 정보를 최신으로 갱신 합니다.
	 */
	public void refreshIndexes(boolean boolRefresh, String strObjectName) {
		if(userDB != null && DBDefine.MONGODB_DEFAULT == userDB.getDBDefine()) {
			mongoIndexComposite.refreshIndexes(userDB, boolRefresh);
		} else {
			tableComposite.getIndexComposite().refreshIndexes(getUserDB(), boolRefresh, strObjectName);
		}
	}
	
	/**
	 * constraints 정보를 최신으로 갱신 합니다.
	 */
	public void refreshConstraints(boolean boolRefresh, String strObjectName) {
		tableComposite.getConstraintsComposite().refreshConstraints(getUserDB(), boolRefresh, strObjectName);
	}

	/**
	 * procedure 정보를 최신으로 갱신 합니다.
	 */
	public void refreshProcedure(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.PROCEDURES, userDB.getDefaultSchemanName(), null);
		procedureComposite.refreshProcedure(userDB, boolRefresh, strObjectName);
	}

	/**
	 * package 정보를 최신으로 갱신 합니다.
	 */
	public void refreshPackage(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.PACKAGES, userDB.getDefaultSchemanName(), null);
		packageComposite.refreshPackage(userDB, boolRefresh, strObjectName);
	}

	/**
	 * trigger 정보를 최신으로 갱신 합니다.
	 */
	public void refreshTrigger(boolean boolRefresh, String strObjectName) {
		tableComposite.getTriggerComposite().refreshTrigger(userDB, boolRefresh, strObjectName);
	}
	
	/**
	 * graph 정보를 최신으로 갱신 합니다.
	 * @param boolRefresh
	 * @param strObjectName
	 */
	public void refreshGraph(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.GRAPHPATH, userDB.getDefaultSchemanName(), null);
		agensGraphPathComposite.refreshGraphPath(getUserDB(), boolRefresh, strObjectName);
	}
	
	/**
	 * vertex 정보를 최신으로 갱신 합니다.
	 * @param boolRefresh
	 * @param strObjectName
	 */
	public void refreshVertex(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.VERTEX, userDB.getDefaultSchemanName(), null);
		agensVertexComposite.refreshSequence(getUserDB(), boolRefresh, strObjectName);
	}
	
	/**
	 * edge 정보를 최신으로 갱신 합니다.
	 * @param boolRefresh
	 * @param strObjectName
	 */
	public void refreshEdge(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.EDGE, userDB.getDefaultSchemanName(), null);
		agensEdgeComposite.refreshSequence(getUserDB(), boolRefresh, strObjectName);
	}

	/**
	 * 전체 trigger 정보를 최신으로 갱신 합니다.
	 */
	public void refreshAllTrigger(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.TRIGGERS, userDB.getDefaultSchemanName(), null);
		triggerComposite.refreshAllTrigger(userDB, boolRefresh, strObjectName); 
	}

	/**
	 * function 정보를 최신으로 갱신 합니다.
	 */
	public void refreshFunction(boolean boolRefresh, String strObjectName) {
		if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.FUNCTIONS, userDB.getDefaultSchemanName(), null);
		functionCompostite.refreshFunction(userDB, boolRefresh, strObjectName);
	}

	/**
	 * table 정보를 최신으로 리프레쉬합니다.
	 */
	public void refreshTable(boolean boolRefresh, String strObjectName) {
		if(userDB != null && DBDefine.MONGODB_DEFAULT == userDB.getDBDefine()) {		
			mongoCollectionComposite.refreshTable(userDB, boolRefresh);	
		} else {
			if(boolRefresh) userDB.setDBObject(OBJECT_TYPE.TABLES, userDB.getDefaultSchemanName(), null);
			tableComposite.refreshTable(userDB, boolRefresh, strObjectName);
		}
	}
	
	/**
	 * select table refresh
	 */
	public void refreshTableColumn() {
		tableComposite.refreshTableColumn();		
	}
	
	/**
	 * mongodb server side javascript define
	 */
	public void refreshJS(boolean boolRefresh, String strObjectName) {
		mongoJavaScriptComposite.refreshJavaScript(userDB, boolRefresh);
	}

	public UserDBDAO getUserDB() {
		return userDB;
	}
	
	/**
	 *  refresh object
	 * 
	 * @param chgUserDB
	 * @param reqQuery
	 */
	public void refreshCurrentTab(UserDBDAO chgUserDB, final RequestQuery reqQuery) {
		if(reqQuery.getSqlDDLType() == null) return;
		
		if(logger.isDebugEnabled()) {
			logger.debug(String.format("update object : %s : %s : ", reqQuery.getSqlDDLType().name(), reqQuery.getSql()));
		}
		
		QUERY_DDL_TYPE queryDDLType = reqQuery.getSqlDDLType();
		String strObjectName = reqQuery.getSqlObjectName();
		
		refreshCurrentTab(queryDDLType, strObjectName, chgUserDB);
		
		// refresh filter
		filterText();
	}
	
	/**
	 * 
	 * @param queryDDLType
	 * @param strObjectName
	 * @param chgUserDB
	 */
	public void refreshCurrentTab(QUERY_DDL_TYPE queryDDLType, String strObjectName, UserDBDAO chgUserDB) {
		if (this.userDB.getSeq() != chgUserDB.getSeq())	return;
		
		if(queryDDLType == QUERY_DDL_TYPE.TABLE) {
			refershSelectObject(OBJECT_TYPE.TABLES.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.INDEX) {
			refershSelectObject(OBJECT_TYPE.INDEXES.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.TRIGGER) {
			refershSelectObject(OBJECT_TYPE.TRIGGERS.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.VIEW) {
			refershSelectObject(OBJECT_TYPE.VIEWS.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.PROCEDURE) {
			refershSelectObject(OBJECT_TYPE.PROCEDURES.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.FUNCTION) {
			refershSelectObject(OBJECT_TYPE.FUNCTIONS.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.PACKAGE) {
			refershSelectObject(OBJECT_TYPE.PACKAGES.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.SYNONYM) {
			refershSelectObject(OBJECT_TYPE.SYNONYM.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.SEQUENCE) {
			refershSelectObject(OBJECT_TYPE.SEQUENCE.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.LINK ) {
			refershSelectObject(OBJECT_TYPE.LINK.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.JOBS ) {
			refershSelectObject(OBJECT_TYPE.JOBS.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.JAVA ) {
			refershSelectObject(OBJECT_TYPE.JAVA.name(), true, strObjectName);
		} else if(queryDDLType == QUERY_DDL_TYPE.TRIGGER) {
			refershSelectObject(OBJECT_TYPE.TRIGGERS.name(), true, strObjectName);
		} else {
			refreshSelectTab();
		}
	}
	
	/**
	 * mysql 일 경우 오브젝트 탐색기의 스키마를 변경한다.
	 * 
	 * @param userDB
	 * @param strSchema
	 */
	public void changeSchema(UserDBDAO userDB, String strSchema) {
		if(getUserDB() == null) return;
		
		if(getUserDB().getSeq() == userDB.getSeq()) {
			changeSchema(strSchema);
		}
	}
	
	@Override
	public void setFocus() {
	}

}