Update of /cvsroot/metamorphosis/ruper2/src/java/core/org/krysalis/ruper2/query
In directory sc8-pr-cvs1:/tmp/cvs-serv30481/src/java/core/org/krysalis/ruper2/query
Added Files:
ResourceQuery.java DefaultQueryEngine.java
ResourceResultHelper.java ResourceSpecifierRequest.java
ResourceRequest.java ResourceResult.java
Log Message:
Avoid clash with existing Ruper...
--- NEW FILE: ResourceQuery.java ---
/*
* Created on Aug 23, 2003
*
*/
package org.krysalis.ruper2.query;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import org.krysalis.ruper2.repository.RepositorySet;
import org.krysalis.ruper2.repository.RepositorySetSortContext;
import org.krysalis.ruper2.resource.ResourceGroup;
import org.krysalis.ruper2.util.select.Selector;
import org.krysalis.version.util.debug.DebugUtils;
import org.krysalis.version.util.debug.Dumpable;
/**
* @author arb_jack
* @author anou_mana
*
* A ResourceQuery is (primarily) an internal class derived from
* simpler user ResourceRequest objects.
*
* A ResourceQuery is effectively an SQL statement like this:
*
* <pre>
*
* SELECT * FROM {REPOSITORIES:group}
* WHERE ((name='junit' AND version>=1.0))
* GROUP BY name, version
* ORDER BY name, version, type
*
* </pre>
*
* The REPOSITORIES are a list of repositories, imaging them as tables.
* The "group" is which group on those repositories (if it exists).
* The * means resources, imagine resources as rows in the tables
* The GROUP BY is a bit of a stretch (it groups results this way)
* The ORDER BY is self explanatory.
*
*/
public class ResourceQuery implements Dumpable {
private List m_groups = null;
//repository
private RepositorySet m_repositories = null;
private RepositorySetSortContext m_repositorySetSortContext = null;
private Selector m_where = null;
private Comparator m_orderBy = null;
private Comparator m_groupBy = null;
//
// :TODO: Nice if we could make queries referenceable
// to allow re-use (especially for the more generic)
//
public ResourceQuery(
ResourceGroup group,
RepositorySet repositories,
Selector where,
Comparator groupBy,
Comparator orderBy) {
m_groups = new ArrayList();
m_groups.add(group);
m_repositories = repositories;
m_where = where;
m_groupBy = groupBy;
m_orderBy = orderBy;
}
public ResourceQuery(
ResourceGroup group,
Selector where,
Comparator groupBy,
Comparator orderBy) {
m_groups = new ArrayList();
m_groups.add(group);
m_where = where;
m_groupBy = groupBy;
m_orderBy = orderBy;
}
public ResourceQuery(ResourceGroup group) {
m_groups = new ArrayList();
m_groups.add(group);
}
//
// :TODO: Nice if we could make queries referenceable
// to allow re-use (especially for the more generic)
//
public ResourceQuery(ResourceQuery other) {
m_groups = other.m_groups;
m_repositories = other.m_repositories;
m_where = other.m_where;
m_groupBy = other.m_groupBy;
m_orderBy = other.m_orderBy;
}
//
// Same query, different repositories
//
public ResourceQuery(ResourceQuery other, RepositorySet repositories) {
this(other);
m_repositories = repositories;
}
/**
* @return
*/
public Comparator getGroupBy() {
return m_groupBy;
}
/**
* @return
*/
public Comparator getOrderBy() {
return m_orderBy;
}
/**
* @return
*/
public RepositorySet getRepositorySet() {
return m_repositories;
}
/**
* @return
*/
public Selector getWhere() {
return m_where;
}
/**
* @param comparator
*/
public void setGroupBy(Comparator comparator) {
m_groupBy = comparator;
}
/**
* @param comparator
*/
public void setOrderBy(Comparator comparator) {
m_orderBy = comparator;
}
/**
* @param set
*/
public void setRepositorySet(RepositorySet set) {
m_repositories = set;
}
/**
* @param selector
*/
public void setWhere(Selector selector) {
m_where = selector;
}
/**
* @return
*/
public List getGroups() {
return m_groups;
}
/**
* @param list
*/
public void setGroups(List list) {
m_groups = list;
}
public void dump(PrintWriter out, int depth, boolean verbose) {
String indent = DebugUtils.getIndent(depth);
DebugUtils.dump(out, depth + 1, "Resource Groups: ", verbose, m_groups);
DebugUtils.printSeparator(out, depth + 1);
DebugUtils.dump(
out,
depth + 1,
"Repositories: ",
verbose,
m_repositories);
DebugUtils.printSeparator(out, depth + 1);
DebugUtils.dump(out, depth + 1, "Where: ", verbose, m_where);
DebugUtils.printSeparator(out, depth + 1);
DebugUtils.dump(out, depth + 1, "Group By: ", verbose, m_groupBy);
DebugUtils.printSeparator(out, depth + 1);
DebugUtils.dump(out, depth + 1, "Order By: ", verbose, m_orderBy);
}
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append("SELECT * FROM ");
if (null != m_repositories) {
buffer.append(m_repositories.getIdentifier());
}
else {
buffer.append("Default Repositories");
}
if (null != m_groups) {
buffer.append(":");
buffer.append(m_groups);
}
buffer.append(" WHERE ");
buffer.append(m_where);
if (null != m_groupBy) {
buffer.append(" GROUP_BY ");
buffer.append(m_groupBy);
}
if (null != m_orderBy) {
buffer.append(" ORDER_BY ");
buffer.append(m_orderBy);
}
//:TODO:Anou's stuff?
return buffer.toString();
}
/**
* @return
*/
public RepositorySet getRepositories() {
return m_repositories;
}
/**
* @return
*/
public RepositorySetSortContext getRepositorySetSortContext() {
return m_repositorySetSortContext;
}
/**
* @param set
*/
public void setRepositories(RepositorySet set) {
m_repositories = set;
}
/**
* @param context
*/
public void setRepositorySetSortContext(RepositorySetSortContext context) {
m_repositorySetSortContext = context;
}
}
--- NEW FILE: DefaultQueryEngine.java ---
/*
* Created on Sep 8, 2003
*/
package org.krysalis.ruper2.query;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
import org.krysalis.ruper2.RuperException;
import org.krysalis.ruper2.log.Logger;
import org.krysalis.ruper2.repository.RepositoryWrapper;
import org.krysalis.ruper2.resource.Resource;
import org.krysalis.ruper2.resource.ResourceGroup;
import org.krysalis.ruper2.resource.compare.StandardResourceComparisons;
import org.krysalis.ruper2.util.select.Selector;
import org.krysalis.ruper2.util.text.MessageConstants;
import org.krysalis.ruper2.util.text.Messages;
import org.krysalis.version.util.debug.DebugUtils;
/**
* @author arb_jack
*/
public class DefaultQueryEngine {
public ResourceResult query(List wrappers, ResourceQuery query)
throws RuperException {
if (Logger.getLog().isDebug()) {
DebugUtils.printSeparator();
DebugUtils.dump(query);
}
//
// A result object, and the results (unpackaged) list
//
ResourceResult result = new ResourceResult();
List results = new ArrayList();
// Extract query components
List resourceGroups = query.getGroups();
Selector whereClause = query.getWhere();
Comparator groupBy = query.getGroupBy();
Comparator orderBy = query.getOrderBy();
//:TODO: Total Hack, just to allow something...
// Rework w/ correct configurable components
for (Iterator i = wrappers.iterator(); i.hasNext();) {
RepositoryWrapper repo = (RepositoryWrapper) i.next();
try {
Logger.getLog().debug(
Messages.getString(
MessageConstants.SEARCH_REPOSITORY,
repo));
for (Iterator ii = resourceGroups.iterator(); ii.hasNext();) {
ResourceGroup resourceGroup = (ResourceGroup) ii.next();
Logger.getLog().debug(
Messages.getString(
MessageConstants.RESOURCE_GROUP,
resourceGroup));
// Look...
List resources =
repo.listResources(resourceGroup, whereClause);
if (resources.isEmpty()) {
Logger.getLog().warn(
Messages.getString(
MessageConstants.NO_RESOURCES_FOUND_IN,
query,
repo,
resourceGroup));
}
else {
//
// Do the query
//
results.addAll(resources);
}
}
}
catch (Exception e) {
String message =
Messages.getString(MessageConstants.LIST_FAILED);
Logger.getLog().warn(message, e);
result.getNotes().warning(message, e);
}
}
//
// Package the results..
//
if (results.isEmpty())
Logger.getLog().warn(
Messages.getString(MessageConstants.NO_RESOURCES_FOUND));
else {
if (Logger.getLog().isDebug()) {
DebugUtils.printSeparator();
DebugUtils.dump("All Results", results);
}
groupBy(result, results, groupBy);
if (Logger.getLog().isDebug()) {
DebugUtils.printSeparator();
DebugUtils.dump("Grouped Results", result);
}
//
// Order the various groups
//
if (null == orderBy)
orderBy =
StandardResourceComparisons
.getNameTypeVersionComparatorSet();
orderBy(result, orderBy);
if (Logger.getLog().isDebug()) {
DebugUtils.printSeparator();
DebugUtils.dump("Final (Grouped/Ordered) Results", result);
}
}
return result;
}
//
//
// Group into lists by comparator equality adn order the same,
// each group lists be same comparator.
//
//
private void groupBy(
ResourceResult result,
List allResults,
Comparator groupBy) {
if (null != groupBy) {
SortedSet set = new TreeSet(groupBy);
set.addAll(allResults);
Resource currentResource = null;
List currentList = null;
for (Iterator i = allResults.iterator(); i.hasNext();) {
Resource resource = (Resource) i.next();
// Do we have a new group?
if ((null == currentList)
|| (null == currentResource)
|| (groupBy.compare(resource, currentResource) != 0)) {
currentList = new ArrayList();
// Add group to results
result.add(currentList);
}
// Stash this resource
currentList.add(resource);
// For comparing group changes..
currentResource = resource;
}
}
else {
// A single list (one group)...
result.add(allResults);
}
}
//
// Sort each sub-list by the order comparator
//
private void orderBy(ResourceResult result, Comparator orderBy) {
if (null != orderBy)
for (Iterator i = result.iterator(); i.hasNext();) {
List currentList = (List) i.next();
Collections.sort(currentList, orderBy);
}
}
}
--- NEW FILE: ResourceResultHelper.java ---
/*
* Created on Aug 23, 2003
*/
package org.krysalis.ruper2.query;
import java.util.Comparator;
import java.util.List;
import org.krysalis.ruper2.resource.Resource;
/**
* @author arb_jack
*
* A ResourceResultHelper.
*
*/
public class ResourceResultHelper {
public static boolean noResult(ResourceResult result) {
return (
(null == result)
|| result.isEmpty()
|| (null == getResourceList(result))
|| getResourceList(result).isEmpty());
}
public static List getResourceList(ResourceResult result) {
List list = null;
if (!result.isEmpty())
list = (List) result.get(0);
return list;
}
// Two results sets compare based off the comparison of their last
// entry (ascending sort)(of their first list)
public static int compareTo(
ResourceResult result1,
ResourceResult result2,
Comparator comp) {
int comparison = 0;
List list1 = ResourceResultHelper.getResourceList(result1);
List list2 = ResourceResultHelper.getResourceList(result2);
if (null != list1) {
if (null != list2) {
if (!list1.isEmpty()) {
if (!list2.isEmpty()) {
//:TODO: Hmm ... sort w/ comp?
Resource resource1 = (Resource) list1.get(list1.size()-1);
Resource resource2 = (Resource) list2.get(list2.size()-1);
comparison = comp.compare(resource1, resource2);
}
else
comparison = 1;
}
else if (!list2.isEmpty())
comparison = -1;
}
else
comparison = 1;
}
else if (null != list2)
comparison = -1;
return comparison;
}
}
--- NEW FILE: ResourceSpecifierRequest.java ---
/*
* Created on Aug 23, 2003
*
*/
package org.krysalis.ruper2.query;
import java.util.Comparator;
import org.krysalis.ruper2.repository.RepositorySet;
import org.krysalis.ruper2.resource.ResourceSpecifier;
import org.krysalis.ruper2.resource.compare.StandardResourceComparisons;
import org.krysalis.ruper2.resource.select.StandardSelections;
import org.krysalis.ruper2.util.select.Selector;
/**
* @author anou_mana
*
*/
public class ResourceSpecifierRequest implements ResourceRequest {
//
// :TODO: Nice if we could make requests referenceable
// to allow re-use (especially for the more generic)
//
private ResourceSpecifier m_specifier = null;
private RepositorySet m_repos = null;
public ResourceSpecifierRequest(
RepositorySet repos,
ResourceSpecifier specifier) {
m_specifier = specifier;
m_repos = repos;
}
public ResourceSpecifierRequest(ResourceSpecifier specifier) {
m_specifier = specifier;
}
public ResourceQuery getQuery() {
Selector where = StandardSelections.getNamedTypedVersion(m_specifier);
Comparator orderBy = StandardResourceComparisons.getNameTypeVersionComparatorSet();
//Comparator groupBy = StandardResourceComparisons.getNameVersion();
Comparator groupBy = StandardResourceComparisons.getNameVersionComparatorSet();
return new ResourceQuery(
m_specifier.getGroup(),
m_repos,
where,
groupBy,
orderBy);
}
/**
* @return
*/
public RepositorySet getRepos() {
return m_repos;
}
/**
* @return
*/
public ResourceSpecifier getSpecifier() {
return m_specifier;
}
/**
* @param set
*/
public void setRepos(RepositorySet set) {
m_repos = set;
}
/**
* @param specifier
*/
public void setSpecifier(ResourceSpecifier specifier) {
m_specifier = specifier;
}
}
--- NEW FILE: ResourceRequest.java ---
/*
* Created on Aug 23, 2003
*
*/
package org.krysalis.ruper2.query;
/**
* @author anou_mana -- a user level request
*
*/
public interface ResourceRequest {
ResourceQuery getQuery();
}
--- NEW FILE: ResourceResult.java ---
/*
* Created on Aug 23, 2003
*/
package org.krysalis.ruper2.query;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collection;
import org.krysalis.version.util.debug.DebugUtils;
import org.krysalis.version.util.debug.Dumpable;
import org.krysalis.version.util.note.AnnotationScratchpad;
/**
* @author arb_jack
*
* A ResourceResult is a list of lists of resources.
*
*/
public class ResourceResult extends ArrayList implements Dumpable {
public boolean m_successful = true;
public AnnotationScratchpad m_notes = null;
/**
*
*/
public ResourceResult() {
super();
classInit();
}
/**
* @param arg0
*/
public ResourceResult(int arg0) {
super(arg0);
classInit();
}
/**
* @param arg0
*/
public ResourceResult(Collection arg0) {
super(arg0);
classInit();
}
private void classInit() {
m_notes = new AnnotationScratchpad();
}
/**
* @return
*/
public AnnotationScratchpad getNotes() {
return m_notes;
}
/**
* @return
*/
public boolean isSuccessful() {
return m_successful;
}
/**
* @param scratchpad
*/
public void setNotes(AnnotationScratchpad scratchpad) {
m_notes = scratchpad;
}
/**
* @param b
*/
public void setSuccessful(boolean b) {
m_successful = b;
}
public void dump(PrintWriter out, int depth, boolean verbose) {
String indent = DebugUtils.getIndent(depth);
out.println("Successful:" + m_successful);
DebugUtils.printSeparator(out,depth+1);
DebugUtils.dumpList(out, depth + 1, "Resources: ", verbose, this);
if ( (null != m_notes) && m_notes.hasAnnotations())
{
DebugUtils.printSeparator(out,depth+1);
m_notes.dump(out,depth+1,verbose);
}
}
}
-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf
lmpx.com only provides a reader for public news (NNTP) servers. It is not
affiliated with the servers or forums shown here and is not responsible for
the content of articles, which is written by their respective authors.