Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright: (c) 2004-2011 Mayo Foundation for Medical Education and 
   * Research (MFMER). All rights reserved. MAYO, MAYO CLINIC, and the
   * triple-shield Mayo logo are trademarks and service marks of MFMER.
   *
   * Except as contained in the copyright notice above, or as used to identify 
   * MFMER as the author of this software, the trade names, trademarks, service
   * marks, or product names of the copyright holder shall not be used in
   * advertising, promotion or otherwise in connection with this software without
  * prior written authorization of the copyright holder.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.twinkql.template;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 import  org.springframework.beans.factory.InitializingBean;
 import  org.springframework.beans.factory.annotation.Autowired;
 import  org.springframework.stereotype.Component;
 import  org.springframework.util.Assert;
 import  org.springframework.util.CollectionUtils;
 
 
The TwinkqlTemplate is the main user entry point into Twinkql. Use this to execute SPARQL Queries, add dynamic parameters, etc.

Author(s):
Kevin Peterson
 
 @Component
 public class TwinkqlTemplate implements InitializingBean {
 	
 	protected final Log log = LogFactory.getLog(getClass().getName());
 	
 	private static Pattern VAR_PATTERN = Pattern.compile("#\\{[^\\}]+\\}");
 
 	@Autowired
 
 	@Autowired
 
 	private Map<QnameSelectselectMap = new HashMap<QnameSelect>();
 
Instantiates a new twinkql template.
 
 	public TwinkqlTemplate(){
 		super();
 	}

Instantiates a new twinkql template.

Parameters:
twinkqlContext the twinkql context
resultBindingProcessor the result binding processor
	public TwinkqlTemplate(TwinkqlContext twinkqlContextResultBindingProcessor resultBindingProcessor) {
		this. = twinkqlContext;
		this. = resultBindingProcessor;
		this.init();
	}
	/* (non-Javadoc)
	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
	 */
	public void afterPropertiesSet() throws Exception {
		this.init();
	}
	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
	 */
Inits the.
	protected void init() {
		Assert.notNull(this.,
				"The property 'twinkqlContext' must be set!");
		this.initCaches();
	}

Inits the prefixes.

Parameters:
config the config
	public void initPrefixes(TwinkqlConfig config) {
		if (config == null) {
			return;
		}
		if (config.getTwinkqlConfigItem() != null) {
			for (TwinkqlConfigItem item : config.getTwinkqlConfigItem()) {
				if (item.getNamespace() != null) {
				}
			}
		}
	}

Builds the prefix.

Parameters:
def the def
Returns:
the string
		String uri = def.getUri();
		String prefix = def.getPrefix();
		return "PREFIX " + prefix + ": <" + uri + ">";
	}

Reinit caches.
	public void reinitCaches(){
		this.initCaches();
	}

Inits the caches.
	protected void initCaches() {
		for (SparqlMap map : this..getSparqlMaps()) {
			if (map.getSparqlMapItem() != null) {
				for (SparqlMapItem item : map.getSparqlMapItem()) {
					if (item.getSparqlMapChoice() != null) {
						for (SparqlMapChoiceItem choice : item
							Select select = choice.getSelect();
							if (select != null) {
								this..put(new Qname(
										map.getNamespace(), select.getId()),
										select);
							}
						}
					}
				}
			}
		}
	}

Query for string.

Parameters:
namespace the namespace
selectId the select id
parameters the parameters
Returns:
the string
	public String getSelectQueryString(String namespaceString selectId,
			Map<StringObjectparameters) {
		Select select = this..get(new Qname(namespaceselectId));
		if (select == null) {
			throw new SelectNotFoundException(namespaceselectId);
		}
		String queryString = this.doGetSparqlQueryString(selectparameters);
			.debug("\n" + queryString);
		}
		return queryString;
	}
	//TODO: This method searches for prefixes in the query
	//This would most likely be more efficient with a regex of
	//of some kind.
Adds the in known prefixes.

Parameters:
query the query
Returns:
the string
	protected String addInKnownPrefixes(String query) {
		for (NamespaceDefinition namespace : this.) {
			if(query.contains(namespace.getPrefix() + ":")){
				sb.append(this.buildPrefix(namespace));
				sb.append("\n");
			}
		}
		sb.append(query);
		return sb.toString();
	}

Does test pass.

Parameters:
param the param
testType the test type
Returns:
true, if successful
	protected boolean doesTestPass(Object paramTestType testType){
		switch(testType) {
			case  :{
				return param == null;
			}
			case  :{
				return param != null;
			}
			default : {
				throw new IllegalStateException();
			}
		}
	}

Do get sparql query string.

Parameters:
select the select
parameters the parameters
Returns:
the string
			Select select,
			Map<StringObjectparameters) {
		String query = select.getContent();
		for (SelectItem selectItem : select.getSelectItem()) {
			if (selectItem.getIsNotNull() != null) {
				IsNotNull isNotNull = selectItem.getIsNotNull();
				String param = isNotNull.getProperty();
				String id = isNotNull.getId();
				if(parameters.get(param) != null){
					query = this.replaceMarker(idqueryisNotNull.getContent());
else {
					query = this.replaceMarker(idquery"");
				}
			}
			if (selectItem.getTest() != null) {
				Test test = selectItem.getTest();
				String param = test.getProperty();
				String id = test.getId();
				TestType testType = test.getTestType();
				if(this.doesTestPass(parameters.get(param), testType)){
					query = this.replaceMarker(idquerytest.getContent());
else {
					query = this.replaceMarker(idquery"");
				}
			}
			if (selectItem.getIterator() != null) {
				Iterator itr = selectItem.getIterator();
				String id = itr.getId();
				String paramProp = itr.getProperty();
				String collectionPath = itr.getCollection();
				Object iterableParam = parameters.get(paramProp);
				// return fast if empty collection
				if (iterableParam == null) {
					query = this.replaceMarker(idquery"");
					continue;
				}
				Collection<?> collection;
				if (collectionPath.equals(".")) {
					collection = (Collection<?>) iterableParam;
else {
					collection = (Collection<?>) BeanUtil.getProperty(
							iterableParamcollectionPath);
				}
				// return fast if emtpy collection
				if (CollectionUtils.isEmpty(collection)) {
					query = this.replaceMarker(idquery"");
					continue;
				}
				StringBuilder totalContent = new StringBuilder();
				totalContent.append(itr.getOpen());
				int counter = 0;
				for (Object item : collection) {
					String content = itr.getContent();
					List<Stringvariables = this.getVariables(content);
					for (String variable : variables) {
						String value = (String) BeanUtil
										item,
						content = StringUtils.replace(contentvariablevalue);
					}
					totalContent.append(content);
					if (++counter < collection.size()) {
						totalContent.append(itr.getSeparator());
					}
				}
				totalContent.append(itr.getClose());
				query = this.replaceMarker(idquerytotalContent.toString());
			}
		}
		if (!CollectionUtils.isEmpty(parameters)) {
			List<StringpreSetParams = this.getVariables(query);
			for (String presetParam : preSetParams) {
				String strippedVariable = this
						.stripVariableWrapping(presetParam);
				String key = StringUtils.substringBefore(strippedVariable".");
				Object varObject = parameters.get(key);
				if(varObject == null){
					throw new MappingException("Parameter: " + presetParam + " was defined in the Mapping but no substitution value was found.");
				}
				String path = StringUtils.substringAfter(strippedVariable".");
				String value;
				if (StringUtils.isNotBlank(path)) {
					value = (String) BeanUtil.getSimpleProperty(varObject,
							pathtrue);
else {
					value = varObject.toString();
				}
				query = query.replace(presetParamvalue);
			}
		}
		query = this.addInKnownPrefixes(query);
		return query;
	}

Replace marker.

Parameters:
id the id
query the query
replacement the replacement
Returns:
the string
	private String replaceMarker(String idString queryString replacement) {
		return StringUtils.replaceOnce(queryidreplacement);
	}

Strip variable wrapping.

Parameters:
variable the variable
Returns:
the string
	private String stripVariableWrapping(String variable) {
		variable = StringUtils.removeStart(variable"#{");
		variable = StringUtils.removeEnd(variable"}");
		return variable;
	}

Strip variable wrapping for iterator.

Parameters:
variable the variable
Returns:
the string
		variable = StringUtils.removeStart(
				this.stripVariableWrapping(variable), "item.");
		return variable;
	}

Gets the variables.

Parameters:
text the text
Returns:
the variables
	private List<StringgetVariables(String text) {
		List<StringreturnList = new ArrayList<String>();
		Matcher matcher = .matcher(text);
		while (matcher.find()) {
			returnList.add(matcher.group());
		}
		return returnList;
	}

Execute a query, expecting a List of results to be returned.

Parameters:
<T> the result type
namespace the namespace
selectId the select id
parameters the parameters to use for mapping placeholders
requiredType the required type
Returns:
the results
	public <T> List<T> selectForList(
			String namespace
			String selectId,
			final Map<StringObjectparameters
			Class<T> requiredType) {
		List<T> result = this.doBind(namespaceselectIdparameters);
		//return the empty list instead of null
		if(result == null){
			result = new ArrayList<T>();
		}
		return result;
	}

Execute a query, expecting a List of results to be returned. If more than one unique result is found, a TooManyResultsException Exception is thrown.

Parameters:
<T> the generic type
namespace the namespace
selectId the select id
parameters the parameters to use for mapping placeholders
requiredType the required type
Returns:
the result
	public <T> T selectForObject(
			String namespace
			String selectId,
			final Map<StringObjectparameters
			Class<T> requiredType) {
		List<T> result = this.doBind(namespaceselectIdparameters);
		if(result != null && result.size() > 1){
		}
		if(CollectionUtils.isEmpty(result)){
			return null;
		}
		return result.get(0);
	}


Do bind.

Parameters:
<T> the generic type
namespace the namespace
selectId the select id
parameters the parameters
doBind the do bind
Returns:
the t
	@SuppressWarnings("unchecked")
	protected <T> List<T> doBind(String namespaceString selectId,
			Map<StringObjectparameters) {
		Select select = this..get(new Qname(namespaceselectId));
		String queryString = this.getSelectQueryString(namespaceselectId,
				parameters);
		QueryExecution queryExecution = this.
				.getQueryExecution(queryString);
		ResultSet resultSet = queryExecution.execSelect();
		if(! resultSet.hasNext()){
			return null;
else {
			Qname resultQname = Qname.toQname(select.getResultMap(), namespace);
					resultSet
					//parameters,
					resultQname);
		}
	}

Gets the twinkql context.

Returns:
the twinkql context
	}

Sets the twinkql context.

Parameters:
twinkqlContext the new twinkql context
	public void setTwinkqlContext(TwinkqlContext twinkqlContext) {
		this. = twinkqlContext;
	}

Gets the result binding processor.

Returns:
the result binding processor
	}

Sets the result binding processor.

Parameters:
resultBindingProcessor the new result binding processor
			ResultBindingProcessor resultBindingProcessor) {
		this. = resultBindingProcessor;
	}
New to GrepCode? Check out our FAQ X