CodeSOD: Integral to a Database Read

One of the key points of confusion for people unfamiliar with Java is the distinction between true object types, like Integer, and “primitive” types, like int. This is made worse by the collection types, like ArrayList, which needs to hold a true object type, but can’t hold a primitive. A generic ArrayList<Integer> is valid, but ArrayList<int> won’t compile. Fortunately for everyone, Java automatically “boxes” types- at least since Java 5, way back in 2004- so integerList.add(5) and int n = integerList.get(0) will both work just fine.

Somebody should have told that to Alice‘s co-worker, who spends a lot of code to do some type gymnastics that they shouldn’t have:

<span class="hljs-keyword">try</span> {
		ps = conn.prepareStatement(SQL_GET_LOT_WORKUP_STATUSES);
		ps.setLong(<span class="hljs-number">1</span>, _lotId);

		rs = ps.executeQuery();

		<span class="hljs-keyword">while</span> (rs.next()) {
				result.add(<span class="hljs-keyword">new</span> <span class="hljs-title class_">Integer</span>(rs.getInt(<span class="hljs-number">1</span>)));
		}
}
<span class="hljs-keyword">finally</span> {
		CloseUtil.close(ps,rs);
}

<span class="hljs-comment">// instatiate a the array</span>
_workupStatuses = <span class="hljs-keyword">new</span> <span class="hljs-title class_">int</span>[result.size()];

<span class="hljs-comment">// convert the integers to ints</span>
<span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> h=<span class="hljs-number">0</span>; h<result.size(); h++) {
		_workupStatuses[h] = ((Integer)result.get(h)).intValue();
}

This runs a query against the database, and then iterates across the result to populate a List type with integers, and right away we’re getting into confused territory. rs.getInt returns an int primitive, which they manually box with new Integer, and stuff into the List. And look, I wouldn’t really call that a WTF, but it’s what they do next that leaves me scratching my head.

They initialize a private member, _workupStatuses to a new array of ints. Then they copy every integer from the result collection into the array, first by casting the get return value to Integer, then by pulling off the intValue.

In the end, this whole dance happens because Java ResultSet types open cursors on the database side and thus don’t have the capacity to tell you how many rows they returned. You need to iterate across each record until it runs out of results. That’s why they populate an intermediate list. Then they can check the size and create an array, but that itself is a big why. I’m not going to say that using arrays in Java is an instant anti-pattern, but it’s always something to be suspicious of, especially when you’re holding result sets. It’s probably a premature optimization: the key performance distance is on insertions where an ArrayList may need to resize and copy its internal backing store.

My suspicion, however, is that this code falls into the category of “C programmer forced to do Java”. They’re comfortable with an array of integers, which is covers 90% of the data types you use in C but a dynamic, complicated data structure is horrifying to them. So they use it when they absolutely have to, and then throw it away as quickly as they can to get back to what they’re familiar with.

Source: Read More