Using the loan pattern in Java

	In Java you often deal with a lot of boilerplate code. A typical example is
	opening an inputstream, using the inputstream and next closing it. But this
	simple use case takes writing quite a bit of code.Some of this boilerplate
	can be factored out by using the loan pattern, where the bank connects a
	producer and consumer and takes care of the heavy lifting. This code can be
	further generalized using generics but for illustrating purposes it serves
	as a nice example.
	**************************************************
	Consumer Interface *
	**************************************************
	public interface InputStreamConsumer {
	void consume(InputStream in) throws Exception;
	}
	**************************************************
	Producer Interface *
	**************************************************
	public interface InputStreamProducer {
	InputStream produce() throws Exception;
	}
	**************************************************
	Lender which connects producer and consumer *
	**************************************************
	public class InputStreamLender {
	public static void lend(InputStreamProducer producer, InputStreamConsumer consumer)
	throws Exception {
	InputStream in = null;
	try {
	in = producer.produce();
	consumer.consume(in);
	} finally {
	if (in != null) {
	in.close();
	}
	}
	}
	}
	**************************************************
	Util class providing implementation for *
	a InputstreamProvider *
	**************************************************
	public class InputStreamUtils {
	public static InputStreamProducer fromClassPath(final String path) {
	return new InputStreamProducer() {
	@Override
	public InputStream produce() throws Exception {
	return InputStreamUtils.class.getClassLoader().getResourceAsStream(path);
	}
	};
	}
	}
	**************************************************
	Small test class testing we get indeed an *
	inputstream to work with *
	**************************************************
	public class InputStreamLenderTest {
	@Test
	public void testInputStreamLender() throws Exception {
	InputStreamLender.lend(
	InputStreamUtils.fromClassPath("test.properties"),
	new InputStreamConsumer() {
	@Override
	public void consume(InputStream in) throws Exception {
	Assert.assertNotNull(in);
	}
	});
	}
	}
	**************************************************
	A class using our newly developed loan pattern *
	**************************************************
	public class PropertyLoader {
	public static Properties loadFromClassPath(String path) throws Exception{
	final Properties props = new Properties();
	InputStreamLender.lend(
	InputStreamUtils.fromClassPath(path),
	new InputStreamConsumer() {
	@Override
	public void consume(InputStream in) throws Exception {
	props.load(in);
	}
	});
	return props;
	}
	}
	**************************************************

view raw gistfile1.java hosted with ❤ by GitHub

XQuery3.0: Mimicking a FLWOR expression with higher-order functions

	xquery version "3.0";
	declare function local:flwor(
	$ctxt as item(),
	$find as function(item()) as item()*,
	$predicate as function(item()) as xs:boolean,
	$orderBy as function(item()) as item()) as item()* {
	for $result in $find($ctxt)
	where $predicate($result)
	order by $orderBy($result)
	return $result
	};
	declare function local:isMale($person as element(person)) as xs:boolean {
	$person/@gender = 'male'
	};
	declare function local:getPersons($persons as element(persons)) as element(person)* {
	$persons/person
	};
	let $persons :=
	<persons>
	<person gender="male">
	<country>Belgium</country>
	<name>John</name>
	<age>10</age>
	</person>
	<person gender="male">
	<country>Netherlands</country>
	<name>Robby</name>
	<age>20</age>
	</person>
	<person gender="female">
	<country>Belgium</country>
	<name>Linda</name>
	<age>80</age>
	</person>
	<person gender="male">
	<country>Belgium</country>
	<name>Davy</name>
	<age>40</age>
	</person>
	<person gender="female">
	<country>Netherlands</country>
	<name>Alice</name>
	<age>30</age>
	</person>
	<person gender="male">
	<country>Netherlands</country>
	<name>Albert</name>
	<age>36</age>
	</person>
	</persons>
	let $getPersons := local:getPersons#1
	let $isMale := local:isMale#1
	return local:flwor(
	$persons,
	$getPersons,
	$isMale,
	function($person as element(person)) as item() { $person/name}
	)
	(:
	****************************************************************
	XQuery output: We expect a sequence of all males ordered by name
	****************************************************************
	<person gender="male">
	<country>Netherlands</country>
	<name>Albert</name>
	<age>36</age>
	</person>
	<person gender="male">
	<country>Belgium</country>
	<name>Davy</name>
	<age>40</age>
	</person>
	<person gender="male">
	<country>Belgium</country>
	<name>John</name>
	<age>10</age>
	</person>
	<person gender="male">
	<country>Netherlands</country>
	<name>Robby</name>
	<age>20</age>
	</person>
	:)

view raw gistfile1.xquery hosted with ❤ by GitHub

XQuery3.0: Higher-Order functions (Functional composition)

	xquery version "3.0";
	declare function local:compose($f1 as function(item()) as item(), $f2 as function(item()) as item())
	as function(item()) as item() {
	function($item) as item() {
	$f2($f1($item))
	}
	};
	(: 5 * x - 2 :)
	let $linearFunction :=
	local:compose(
	function($number) {$number * 5},
	function($number) {$number - 2})
	(: 3 * x^2 - 4 :)
	let $quadraticFunction :=
	local:compose(
	function($number) {$number * $number * 3},
	function($number) {$number - 4})
	return
	<result>
	<test1>{$linearFunction(5)} should equal 5 * 5 - 2 = 23</test1>
	<test2>{$quadraticFunction(4)} should equal 3 * 4^2 - 4 = 44</test2>
	</result>
	(:
	**********************************************
	XQuery output:
	**********************************************
	<result>
	<test1>23 should equal 5 * 5 - 2 = 23</test1>
	<test2>44 should equal 3 * 4^2 - 4 = 44</test2>
	</result>
	:)

view raw gistfile1.xquery hosted with ❤ by GitHub

XQuery3.0: Higher-Order functions (Filtering)

	(:
	Below I show 2 different ways of using the filter function. Both do exactly the same but one uses
	an inline function expression while the other uses a named function reference
	:)
	(:
	*********************************************************************
	Example of using filter with inline function expression
	*********************************************************************
	:)
	return fn:filter(function($person) { $person/@gender = 'female'}, $persons/person)
	(:
	*********************************************************************
	Example of using filter with named function reference (predicate)
	*********************************************************************
	:)
	declare function local:isFemale($person as element(person)) as xs:boolean {
	$person/@gender = 'female'
	};
	let $isFemale := local:isFemale#1
	return fn:filter($isFemale, $persons/person)
	(:
	**********************************************
	XQuery output:
	**********************************************
	<person gender="female">
	<country>Belgium</country>
	<name>Person C</name>
	<age>80</age>
	</person>
	<person gender="female">
	<country>Netherlands</country>
	<name>Person E</name>
	<age>30</age>
	</person>
	:)

view raw gistfile1.xquery hosted with ❤ by GitHub

XQuery3.0: Partial function example

	xquery version "3.0";
	declare function local:increase($nums as xs:integer*, $by as xs:integer) as xs:integer* {
	$nums ! (. + $by)
	};
	let $numbers := (2,3,6,8,12,14)
	let $increaseByThree := local:increase(?, 3)
	let $increaseByFour := local:increase(?, 4)
	return
	<result>
	<test1>{$increaseByThree($numbers)}</test1>
	<test2>{$increaseByFour($numbers)}</test2>
	</result>
	(:
	**********************************************
	XQuery output:
	**********************************************
	<result>
	<test1>5 6 9 11 15 17</test1>
	<test2>6 7 10 12 16 18</test2>
	</result>
	:)

view raw gistfile1.txt hosted with ❤ by GitHub

XQuery3.0: Using simple map operator

	let $persons :=
	<persons>
	<person gender="male" country="Belgium">
	<name>Person A</name>
	<age>10</age>
	</person>
	<person gender="male" country="Netherlands">
	<name>Person B</name>
	<age>20</age>
	</person>
	<person gender="female" country="Belgium">
	<name>Person C</name>
	<age>80</age>
	</person>
	</persons>
	return
	<result>
	{
	for $person in $persons/person
	return
	<person>{$person ! (@gender, data(@country), '-', translate(name, 'Person ', ''))}</person>
	}
	</result>
	(:
	**********************************************
	XQuery output:
	**********************************************
	<result>
	<person gender="male">Belgium - A</person>
	<person gender="male">Netherlands - B</person>
	<person gender="female">Belgium - C</person>
	</result>
	:)

view raw gistfile1.xquery hosted with ❤ by GitHub

XQuery3.0 Group by example

	return
	<groups>
	{
	for $person in $persons/person
	group by
	$country := $person/country,
	$gender := $person/@gender
	return
	<group country="{$country}" gender="{$gender}">
	<averageAge>{avg($person/age)}</averageAge>
	</group>
	}
	</groups>
	(:
	**********************************************
	Logical result
	**********************************************
	Belgium Netherlands
	Male Female Male Female
	---------------------------------------------
	A 10 C 80 B 20 E 30
	D 40 F 36
	---- ---- ---- -----
	25 80 28 30
	**********************************************
	XQuery output:
	**********************************************
	<groups>
	<group country="Belgium" gender="male">
	<averageAge>25</averageAge>
	</group>
	<group country="Belgium" gender="female">
	<averageAge>80</averageAge>
	</group>
	<group country="Netherlands" gender="male">
	<averageAge>28</averageAge>
	</group>
	<group country="Netherlands" gender="female">
	<averageAge>30</averageAge>
	</group>
	</groups>
	:)

view raw gistfile1.xquery hosted with ❤ by GitHub

Normalizing Unicode

	import java.text.Normalizer
	/**
	* Problem: Characters with accents or other adornments can be encoded in several different ways in Unicode
	* However, from a user point of view if they logically mean the same, text search should make no distinction
	* between the different notations. So it's important to store text in normalized unicode form. Code below shows
	* how to check if text is normalized and how you can normalize it.
	**/
	object NormalizationTest {
	def main(args: Array[String]) {
	val text = "16-bit transceiver with direction pin, 30 Ω series termination resistors;"
	println(text)
	println(Normalizer.isNormalized(text, Normalizer.Form.NFC))
	val normalizedText = Normalizer.normalize(text, Normalizer.Form.NFC)
	println(normalizedText)
	println(Normalizer.isNormalized(normalizedText, Normalizer.Form.NFC))
	}
	}
	/**
	* Output printed to console:
	* -------------------------------
	*
	* 16-bit transceiver with direction pin, 30 Ω series termination resistors;
	* false
	* 16-bit transceiver with direction pin, 30 Ω series termination resistors;
	* true
	*/

view raw gistfile1.scala hosted with ❤ by GitHub

Finding duplicate values with XQuery

As I'm always interested in benchmarks and optimized solutions I compared 3 strategies of finding duplicate values in a big sequence. This test will use 5000 randomly generated numbers and compare performance.
The first thing I needed to do was creating a sequence of 5000 randomly generated numbers. Scala comes to the rescue

Loading ....

This generates a file with following content. Remark: in reality that sequence contains 5000 numbers.

let $values := (1012,5345,2891,3833,2854, 2236)

Now I ran the following XQueries on Zorba to get a feeling about how fast they are.

XQuery 1: (takes about 5 seconds for 5000 numbers)

let $values := (1012,5345,2891,3833,2854, 2236)
let $distinctvalues := distinct-values($values)
let $nonunique := for $value in $distinctvalues return if (count(index-of($values, $value)) > 1) then $value else ()
return $nonunique

XQuery 2: (takes about 5 seconds for 5000 numbers)

let $values := (1012,5345,2891,3833,2854, 2236)
return $values[index-of($values, .)[2]]

XQuery 3: (takes about 1 seconds for 5000 numbers)

let $values := (1012,5345,2891,3833,2854, 2236)

return distinct-values(for $value in $values
  return if (count($values[. eq $value]) > 1)
         then $value
         else ())

Of course I got intrigued how Sedna would perform. I only tried XQuery1 (3 to 4 seconds) and XQuery3 (around 13 seconds) on my local machine, which only shows that you cannot always take the same approach while trying to optimize.