core/plugins/org.eclipse.dltk.core.index.sql/src/org/eclipse/dltk/internal/core/index/sql/SqlSearchEngine.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *     Zend Technologies
  *******************************************************************************/
 package org.eclipse.dltk.internal.core.index.sql;

 import java.sql.Connection;
 import java.sql.SQLException;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.dltk.core.DLTKCore;
 import org.eclipse.dltk.core.IDLTKLanguageToolkit;
 import org.eclipse.dltk.core.IDLTKLanguageToolkitExtension;
 import org.eclipse.dltk.core.IProjectFragment;
 import org.eclipse.dltk.core.IScriptFolder;
 import org.eclipse.dltk.core.ISourceModule;
 import org.eclipse.dltk.core.ScriptModelUtil;
 import org.eclipse.dltk.core.index.sql.Container;
 import org.eclipse.dltk.core.index.sql.DbFactory;
 import org.eclipse.dltk.core.index.sql.Element;
 import org.eclipse.dltk.core.index.sql.File;
 import org.eclipse.dltk.core.index.sql.IElementHandler;
 import org.eclipse.dltk.core.index.sql.SqlIndex;
 import org.eclipse.dltk.core.index2.search.ISearchEngineExtension;
 import org.eclipse.dltk.core.index2.search.ISearchRequestor;
 import org.eclipse.dltk.core.search.IDLTKSearchScope;
 import org.eclipse.dltk.internal.core.ArchiveFolder;
 import org.eclipse.dltk.internal.core.BuiltinScriptFolder;
 import org.eclipse.dltk.internal.core.ExternalScriptFolder;
 import org.eclipse.dltk.internal.core.ProjectFragment;
 import org.eclipse.dltk.internal.core.search.DLTKSearchScope;
 import org.eclipse.dltk.internal.core.search.DLTKWorkspaceScope;

 /**
  * Search engine implementation for SQL-based index.
  *
  * @author michael
  * @since 2.0
  */
 public class SqlSearchEngine implements ISearchEngineExtension {

 	public void search(int elementType, String qualifier, String elementName,
 			int trueFlags, int falseFlags, int limit, SearchFor searchFor,
 			MatchRule matchRule, IDLTKSearchScope scope,
 			ISearchRequestor requestor, IProgressMonitor monitor) {
 		search(elementType, qualifier, elementName, null, trueFlags,
 				falseFlags, limit, searchFor, matchRule, scope, requestor,
 				monitor);
 	}

 	public void search(int elementType, String qualifier, String elementName,
 			String parent, int trueFlags, int falseFlags, int limit,
 			SearchFor searchFor, MatchRule matchRule, IDLTKSearchScope scope,
 			final ISearchRequestor requestor, IProgressMonitor monitor) {

 		try {
 			DbFactory dbFactory = DbFactory.getInstance();
 			if (dbFactory == null) {
 				return;
 			}
 			Connection connection = dbFactory.createConnection();
 			if (connection == null) {
 				return;
 			}
 			try {
 				String natureId = scope.getLanguageToolkit().getNatureId();
 				ElementHandler elementHandler = new ElementHandler(connection,
 						scope, requestor);

 				// Calculate filtering by container:
 				int[] containersId = null;
 				int[] filesId = null;
 				if (!(scope instanceof DLTKWorkspaceScope)) {
 					// Calculate container IDs:
 					IPath[] containerPaths = scope.enclosingProjectsAndZips();
 					List<Integer> containerIdsList = new LinkedList<Integer>();
 					for (IPath containerPath : containerPaths) {
 						Container container = dbFactory.getContainerDao()
 								.selectByPath(connection,
 										containerPath.toString());
 						if (container != null) {
 							containerIdsList.add(container.getId());
 						}
 					}
 					if (containerIdsList.size() > 0) {
 						containersId = new int[containerIdsList.size()];
 						for (int i = 0; i < containerIdsList.size(); ++i) {
 							containersId[i] = containerIdsList.get(i);
 						}
 					}

 					// Calculate file IDs:
 					if (scope instanceof DLTKSearchScope) {
 						List<Integer> fileIdsList = new LinkedList<Integer>();
 						String[] relativePaths = ((DLTKSearchScope) scope)
 								.getRelativePaths();
 						String[] fileExtensions = ScriptModelUtil
 								.getFileExtensions(scope.getLanguageToolkit());

 						// XXX - need a better way do differentiate between file
 						// and container scopes
 						for (String relativePath : relativePaths) {
 							if (relativePath.length() > 0) {
 								if (fileExtensions != null) {
 									boolean isScriptFile = false;
 									for (String ext : fileExtensions) {
 										if (relativePath.endsWith("." + ext)) {
 											isScriptFile = true;
 											break;
 										}
 									}
 									if (!isScriptFile) {
 										break;
 									}
 								}
 								for (Integer containerId : containerIdsList) {
 									File file = dbFactory.getFileDao().select(
 											connection, relativePath,
 											containerId);
 									if (file != null) {
 										fileIdsList.add(file.getId());
 									}
 								}
 							}
 						}
 						if (fileIdsList.size() > 0) {
 							filesId = new int[fileIdsList.size()];
 							for (int i = 0; i < fileIdsList.size(); ++i) {
 								filesId[i] = fileIdsList.get(i);
 							}
 						}
 					}
 				}

 				boolean searchForDecls = searchFor == SearchFor.DECLARATIONS
 						|| searchFor == SearchFor.ALL_OCCURENCES;
 				boolean searchForRefs = searchFor == SearchFor.REFERENCES
 						|| searchFor == SearchFor.ALL_OCCURENCES;

 				if (searchForDecls) {
 					dbFactory.getElementDao().search(connection, elementName,
 							matchRule, elementType, trueFlags, falseFlags,
 							qualifier, parent, filesId, containersId, natureId,
 							limit, false, elementHandler, monitor);
 				}
 				if (searchForRefs) {
 					dbFactory.getElementDao().search(connection, elementName,
 							matchRule, elementType, trueFlags, falseFlags,
 							qualifier, parent, filesId, containersId, natureId,
 							limit, true, elementHandler, monitor);
 				}
 			} finally {
 				connection.close();
 			}
 		} catch (SQLException e) {
 			SqlIndex.error("An exception has thrown while performing a search",
 					e);
 		}
 	}

 	private static class FilePathHandler {

 		final IPath folderPath;
 		final String fileName;

 		public FilePathHandler(String filePath) {
 			int i = filePath.lastIndexOf('/');
 			if (i == -1) {
 				i = filePath.lastIndexOf('\\');
 			}
 			if (i != -1) {
 				this.folderPath = new Path(filePath.substring(0, i));
 				this.fileName = filePath.substring(i + 1);
 			} else {
 				this.folderPath = Path.EMPTY;
 				this.fileName = filePath;
 			}
 		}

 	}

 	class ElementHandler implements IElementHandler, ISearchRequestor {

 		private Map<Integer, File> fileCache = new HashMap<Integer, File>();
 		private Map<Integer, Container> containerCache = new HashMap<Integer, Container>();
 		private Map<String, IProjectFragment> projectFragmentCache = new HashMap<String, IProjectFragment>();
 		private Map<String, ISourceModule> sourceModuleCache = new HashMap<String, ISourceModule>();
 		private Connection connection;
 		private ISearchRequestor searchRequestor;
 		private IDLTKSearchScope scope;

 		public ElementHandler(Connection connection, IDLTKSearchScope scope,
 				ISearchRequestor searchRequestor) {

 			this.connection = connection;
 			this.scope = scope;
 			this.searchRequestor = searchRequestor;
 		}

 		public void handle(Element element) {
 			try {
 				DbFactory dbFactory = DbFactory.getInstance();

 				int fileId = element.getFileId();
 				File file = fileCache.get(fileId);
 				if (file == null) {
 					file = dbFactory.getFileDao()
 							.selectById(connection, fileId);
 					if (file == null) {
 						return;
 					}
 					fileCache.put(fileId, file);
 				}

 				int containerId = file.getContainerId();
 				Container container = containerCache.get(containerId);
 				if (container == null) {
 					container = dbFactory.getContainerDao().selectById(
 							connection, containerId);
 					if (container == null) {
 						return;
 					}
 					containerCache.put(containerId, container);
 				}

 				String containerPath = container.getPath();
 				IDLTKLanguageToolkit toolkit = ((DLTKSearchScope) scope)
 						.getLanguageToolkit();
 				if (toolkit instanceof IDLTKLanguageToolkitExtension
 						&& ((IDLTKLanguageToolkitExtension) toolkit)
 								.isArchiveFileName(containerPath)) {
 					containerPath = containerPath
 							+ IDLTKSearchScope.FILE_ENTRY_SEPARATOR;
 				}
 				if (containerPath.length() != 0
 						&& containerPath.charAt(containerPath.length() - 1) != IPath.SEPARATOR) {
 					containerPath = containerPath + IPath.SEPARATOR;
 				}

 				String filePath = file.getPath();
 				final String resourcePath = containerPath + filePath;

 				IProjectFragment projectFragment = projectFragmentCache
 						.get(containerPath);

 				if (projectFragment == null) {
 					projectFragment = ((DLTKSearchScope) scope)
 							.projectFragment(resourcePath);
 					if (projectFragment == null) {
 						projectFragment = ((DLTKSearchScope) scope)
 								.projectFragment(containerPath);
 					}
 					projectFragmentCache.put(containerPath, projectFragment);
 				}
 				if (projectFragment == null) {
 					return;
 				}

 				if (!scope.encloses(resourcePath)) {
 					return;
 				}

 				ISourceModule sourceModule = sourceModuleCache
 						.get(resourcePath);
 				if (sourceModule == null) {
 					if (projectFragment.isArchive()) {
 						FilePathHandler filePathHandler = new FilePathHandler(
 								filePath);
 						IScriptFolder scriptFolder = new ArchiveFolder(
 								(ProjectFragment) projectFragment,
 								filePathHandler.folderPath);
 						sourceModule = scriptFolder
 								.getSourceModule(filePathHandler.fileName);
 					} else if (projectFragment.isExternal()) {
 						FilePathHandler filePathHandler = new FilePathHandler(
 								filePath);
 						IScriptFolder scriptFolder = new ExternalScriptFolder(
 								(ProjectFragment) projectFragment,
 								filePathHandler.folderPath);
 						sourceModule = scriptFolder
 								.getSourceModule(filePathHandler.fileName);
 					} else if (projectFragment.isBuiltin()) {
 						FilePathHandler filePathHandler = new FilePathHandler(
 								filePath);
 						IScriptFolder scriptFolder = new BuiltinScriptFolder(
 								(ProjectFragment) projectFragment,
 								filePathHandler.folderPath);
 						sourceModule = scriptFolder
 								.getSourceModule(filePathHandler.fileName);
 					} else {
 						IProject project = projectFragment.getScriptProject()
 								.getProject();
 						sourceModule = DLTKCore.createSourceModuleFrom(
 								project.getFile(filePath));
 					}
 					sourceModuleCache.put(resourcePath, sourceModule);
 				}

 				match(element.getType(), element.getFlags(),
 						element.getOffset(), element.getLength(),
 						element.getNameOffset(), element.getNameLength(),
 						element.getName(), element.getMetadata(),
 						element.getDoc(), element.getQualifier(),
 						element.getParent(), sourceModule,
 						element.isReference());

 			} catch (SQLException e) {
 				SqlIndex.error(
 						"An exception is thrown while searching elements", e);
 			}
 		}

 		public void match(int elementType, int flags, int offset, int length,
 				int nameOffset, int nameLength, String elementName,
 				String metadata, String doc, String qualifier, String parent,
 				ISourceModule sourceModule, boolean isReference) {

 			searchRequestor.match(elementType, flags, offset, length,
 					nameOffset, nameLength, elementName, metadata, doc,
 					qualifier, parent, sourceModule, isReference);
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	* Zend Technologies
	*******************************************************************************/
	package org.eclipse.dltk.internal.core.index.sql;

	import java.sql.Connection;
	import java.sql.SQLException;
	import java.util.HashMap;
	import java.util.LinkedList;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.dltk.core.DLTKCore;
	import org.eclipse.dltk.core.IDLTKLanguageToolkit;
	import org.eclipse.dltk.core.IDLTKLanguageToolkitExtension;
	import org.eclipse.dltk.core.IProjectFragment;
	import org.eclipse.dltk.core.IScriptFolder;
	import org.eclipse.dltk.core.ISourceModule;
	import org.eclipse.dltk.core.ScriptModelUtil;
	import org.eclipse.dltk.core.index.sql.Container;
	import org.eclipse.dltk.core.index.sql.DbFactory;
	import org.eclipse.dltk.core.index.sql.Element;
	import org.eclipse.dltk.core.index.sql.File;
	import org.eclipse.dltk.core.index.sql.IElementHandler;
	import org.eclipse.dltk.core.index.sql.SqlIndex;
	import org.eclipse.dltk.core.index2.search.ISearchEngineExtension;
	import org.eclipse.dltk.core.index2.search.ISearchRequestor;
	import org.eclipse.dltk.core.search.IDLTKSearchScope;
	import org.eclipse.dltk.internal.core.ArchiveFolder;
	import org.eclipse.dltk.internal.core.BuiltinScriptFolder;
	import org.eclipse.dltk.internal.core.ExternalScriptFolder;
	import org.eclipse.dltk.internal.core.ProjectFragment;
	import org.eclipse.dltk.internal.core.search.DLTKSearchScope;
	import org.eclipse.dltk.internal.core.search.DLTKWorkspaceScope;

	/**
	* Search engine implementation for SQL-based index.
	*
	* @author michael
	* @since 2.0
	*/
	public class SqlSearchEngine implements ISearchEngineExtension {

	public void search(int elementType, String qualifier, String elementName,
	int trueFlags, int falseFlags, int limit, SearchFor searchFor,
	MatchRule matchRule, IDLTKSearchScope scope,
	ISearchRequestor requestor, IProgressMonitor monitor) {
	search(elementType, qualifier, elementName, null, trueFlags,
	falseFlags, limit, searchFor, matchRule, scope, requestor,
	monitor);
	}

	public void search(int elementType, String qualifier, String elementName,
	String parent, int trueFlags, int falseFlags, int limit,
	SearchFor searchFor, MatchRule matchRule, IDLTKSearchScope scope,
	final ISearchRequestor requestor, IProgressMonitor monitor) {

	try {
	DbFactory dbFactory = DbFactory.getInstance();
	if (dbFactory == null) {
	return;
	}
	Connection connection = dbFactory.createConnection();
	if (connection == null) {
	return;
	}
	try {
	String natureId = scope.getLanguageToolkit().getNatureId();
	ElementHandler elementHandler = new ElementHandler(connection,
	scope, requestor);

	// Calculate filtering by container:
	int[] containersId = null;
	int[] filesId = null;
	if (!(scope instanceof DLTKWorkspaceScope)) {
	// Calculate container IDs:
	IPath[] containerPaths = scope.enclosingProjectsAndZips();
	List<Integer> containerIdsList = new LinkedList<Integer>();
	for (IPath containerPath : containerPaths) {
	Container container = dbFactory.getContainerDao()
	.selectByPath(connection,
	containerPath.toString());
	if (container != null) {
	containerIdsList.add(container.getId());
	}
	}
	if (containerIdsList.size() > 0) {
	containersId = new int[containerIdsList.size()];
	for (int i = 0; i < containerIdsList.size(); ++i) {
	containersId[i] = containerIdsList.get(i);
	}
	}

	// Calculate file IDs:
	if (scope instanceof DLTKSearchScope) {
	List<Integer> fileIdsList = new LinkedList<Integer>();
	String[] relativePaths = ((DLTKSearchScope) scope)
	.getRelativePaths();
	String[] fileExtensions = ScriptModelUtil
	.getFileExtensions(scope.getLanguageToolkit());

	// XXX - need a better way do differentiate between file
	// and container scopes
	for (String relativePath : relativePaths) {
	if (relativePath.length() > 0) {
	if (fileExtensions != null) {
	boolean isScriptFile = false;
	for (String ext : fileExtensions) {
	if (relativePath.endsWith("." + ext)) {
	isScriptFile = true;
	break;
	}
	}
	if (!isScriptFile) {
	break;
	}
	}
	for (Integer containerId : containerIdsList) {
	File file = dbFactory.getFileDao().select(
	connection, relativePath,
	containerId);
	if (file != null) {
	fileIdsList.add(file.getId());
	}
	}
	}
	}
	if (fileIdsList.size() > 0) {
	filesId = new int[fileIdsList.size()];
	for (int i = 0; i < fileIdsList.size(); ++i) {
	filesId[i] = fileIdsList.get(i);
	}
	}
	}
	}

	boolean searchForDecls = searchFor == SearchFor.DECLARATIONS
	\|\| searchFor == SearchFor.ALL_OCCURENCES;
	boolean searchForRefs = searchFor == SearchFor.REFERENCES
	\|\| searchFor == SearchFor.ALL_OCCURENCES;

	if (searchForDecls) {
	dbFactory.getElementDao().search(connection, elementName,
	matchRule, elementType, trueFlags, falseFlags,
	qualifier, parent, filesId, containersId, natureId,
	limit, false, elementHandler, monitor);
	}
	if (searchForRefs) {
	dbFactory.getElementDao().search(connection, elementName,
	matchRule, elementType, trueFlags, falseFlags,
	qualifier, parent, filesId, containersId, natureId,
	limit, true, elementHandler, monitor);
	}
	} finally {
	connection.close();
	}
	} catch (SQLException e) {
	SqlIndex.error("An exception has thrown while performing a search",
	e);
	}
	}

	private static class FilePathHandler {

	final IPath folderPath;
	final String fileName;

	public FilePathHandler(String filePath) {
	int i = filePath.lastIndexOf('/');
	if (i == -1) {
	i = filePath.lastIndexOf('\\');
	}
	if (i != -1) {
	this.folderPath = new Path(filePath.substring(0, i));
	this.fileName = filePath.substring(i + 1);
	} else {
	this.folderPath = Path.EMPTY;
	this.fileName = filePath;
	}
	}

	}

	class ElementHandler implements IElementHandler, ISearchRequestor {

	private Map<Integer, File> fileCache = new HashMap<Integer, File>();
	private Map<Integer, Container> containerCache = new HashMap<Integer, Container>();
	private Map<String, IProjectFragment> projectFragmentCache = new HashMap<String, IProjectFragment>();
	private Map<String, ISourceModule> sourceModuleCache = new HashMap<String, ISourceModule>();
	private Connection connection;
	private ISearchRequestor searchRequestor;
	private IDLTKSearchScope scope;

	public ElementHandler(Connection connection, IDLTKSearchScope scope,
	ISearchRequestor searchRequestor) {

	this.connection = connection;
	this.scope = scope;
	this.searchRequestor = searchRequestor;
	}

	public void handle(Element element) {
	try {
	DbFactory dbFactory = DbFactory.getInstance();

	int fileId = element.getFileId();
	File file = fileCache.get(fileId);
	if (file == null) {
	file = dbFactory.getFileDao()
	.selectById(connection, fileId);
	if (file == null) {
	return;
	}
	fileCache.put(fileId, file);
	}

	int containerId = file.getContainerId();
	Container container = containerCache.get(containerId);
	if (container == null) {
	container = dbFactory.getContainerDao().selectById(
	connection, containerId);
	if (container == null) {
	return;
	}
	containerCache.put(containerId, container);
	}

	String containerPath = container.getPath();
	IDLTKLanguageToolkit toolkit = ((DLTKSearchScope) scope)
	.getLanguageToolkit();
	if (toolkit instanceof IDLTKLanguageToolkitExtension
	&& ((IDLTKLanguageToolkitExtension) toolkit)
	.isArchiveFileName(containerPath)) {
	containerPath = containerPath
	+ IDLTKSearchScope.FILE_ENTRY_SEPARATOR;
	}
	if (containerPath.length() != 0
	&& containerPath.charAt(containerPath.length() - 1) != IPath.SEPARATOR) {
	containerPath = containerPath + IPath.SEPARATOR;
	}

	String filePath = file.getPath();
	final String resourcePath = containerPath + filePath;

	IProjectFragment projectFragment = projectFragmentCache
	.get(containerPath);

	if (projectFragment == null) {
	projectFragment = ((DLTKSearchScope) scope)
	.projectFragment(resourcePath);
	if (projectFragment == null) {
	projectFragment = ((DLTKSearchScope) scope)
	.projectFragment(containerPath);
	}
	projectFragmentCache.put(containerPath, projectFragment);
	}
	if (projectFragment == null) {
	return;
	}

	if (!scope.encloses(resourcePath)) {
	return;
	}

	ISourceModule sourceModule = sourceModuleCache
	.get(resourcePath);
	if (sourceModule == null) {
	if (projectFragment.isArchive()) {
	FilePathHandler filePathHandler = new FilePathHandler(
	filePath);
	IScriptFolder scriptFolder = new ArchiveFolder(
	(ProjectFragment) projectFragment,
	filePathHandler.folderPath);
	sourceModule = scriptFolder
	.getSourceModule(filePathHandler.fileName);
	} else if (projectFragment.isExternal()) {
	FilePathHandler filePathHandler = new FilePathHandler(
	filePath);
	IScriptFolder scriptFolder = new ExternalScriptFolder(
	(ProjectFragment) projectFragment,
	filePathHandler.folderPath);
	sourceModule = scriptFolder
	.getSourceModule(filePathHandler.fileName);
	} else if (projectFragment.isBuiltin()) {
	FilePathHandler filePathHandler = new FilePathHandler(
	filePath);
	IScriptFolder scriptFolder = new BuiltinScriptFolder(
	(ProjectFragment) projectFragment,
	filePathHandler.folderPath);
	sourceModule = scriptFolder
	.getSourceModule(filePathHandler.fileName);
	} else {
	IProject project = projectFragment.getScriptProject()
	.getProject();
	sourceModule = DLTKCore.createSourceModuleFrom(
	project.getFile(filePath));
	}
	sourceModuleCache.put(resourcePath, sourceModule);
	}

	match(element.getType(), element.getFlags(),
	element.getOffset(), element.getLength(),
	element.getNameOffset(), element.getNameLength(),
	element.getName(), element.getMetadata(),
	element.getDoc(), element.getQualifier(),
	element.getParent(), sourceModule,
	element.isReference());

	} catch (SQLException e) {
	SqlIndex.error(
	"An exception is thrown while searching elements", e);
	}
	}

	public void match(int elementType, int flags, int offset, int length,
	int nameOffset, int nameLength, String elementName,
	String metadata, String doc, String qualifier, String parent,
	ISourceModule sourceModule, boolean isReference) {

	searchRequestor.match(elementType, flags, offset, length,
	nameOffset, nameLength, elementName, metadata, doc,
	qualifier, parent, sourceModule, isReference);
	}
	}
	}