@Test
public void testPlainSQLResultQuery() throws Exception {
// [#1749] TODO Firebird renders CAST(? as VARCHAR(...)) bind values with sizes
// pre-calculated. Hence the param needs to have some min length...
String sql = create().select(param("p", "abc").as("p")).getSQL(false);
ResultQuery<Record> q = create().resultQuery(sql, "10");
Result<Record> fetch1 = q.fetch();
assertEquals(1, fetch1.size());
assertEquals(1, fetch1.fieldsRow().size());
assertEquals("p", fetch1.field(0).getName());
assertEquals("p", fetch1.field("p").getName());
assertEquals("10", fetch1.getValue(0, 0));
assertEquals("10", fetch1.getValue(0, "p"));
assertEquals("10", fetch1.getValue(0, fetch1.field("p")));
List<?> fetch2 = q.fetch("p");
assertEquals(1, fetch2.size());
assertEquals("10", fetch2.get(0));
List<Long> fetch3 = q.fetch(0, Long.class);
assertEquals(1, fetch3.size());
assertEquals(10L, (long) fetch3.get(0));
Record fetch4 = q.fetchAny();
assertEquals(1, fetch4.fieldsRow().size());
assertEquals("p", fetch4.field(0).getName());
assertEquals("p", fetch4.field("p").getName());
assertEquals("10", fetch4.getValue(0));
assertEquals("10", fetch4.getValue("p"));
assertEquals("10", fetch4.getValue(fetch4.field("p")));
// [#1722] Check the actual returned type of arrays, also
Object[] fetch5 = q.fetchArray("p");
assertEquals(1, fetch5.length);
assertEquals("10", fetch5[0]);
assertTrue(fetch5 instanceof String[]);
Object[] fetch6 = q.fetchArray(0);
assertEquals(1, fetch6.length);
assertEquals("10", fetch6[0]);
assertTrue(fetch6 instanceof String[]);
Long[] fetch7 = q.fetchArray(0, Long.class);
assertEquals(1, fetch7.length);
assertEquals(10L, (long) fetch7[0]);
List<TestPlainSQLResultQuery> fetch8 = q.fetchInto(TestPlainSQLResultQuery.class);
assertEquals(1, fetch8.size());
assertEquals(10, fetch8.get(0).p);
final Integer[] count = new Integer[] { 0 };
q.fetchInto(new RecordHandler<Record>() {
@Override
public void next(Record record) {
assertEquals(1, record.fieldsRow().size());
assertEquals("10", record.getValue(0));
count[0] += 1;
}
});
assertEquals(1, (int) count[0]);
FutureResult<Record> fetch9 = q.fetchLater();
Thread.sleep(50);
assertTrue(fetch9.isDone());
assertEquals(1, fetch9.get().size());
assertEquals("10", fetch9.get().getValue(0, 0));
Cursor<Record> fetch10 = q.fetchLazy();
assertFalse(fetch10.isClosed());
assertTrue(fetch10.hasNext());
assertEquals(1, fetch10.fieldsRow().size());
assertEquals("p", fetch10.field(0).getName());
assertEquals("10", fetch10.fetchOne().getValue(0));
assertFalse(fetch10.isClosed());
assertFalse(fetch10.hasNext());
assertTrue(fetch10.isClosed());
assertEquals(fetch1.get(0), q.fetchOne());
}
@Override
public int compareTo(Record that) {
// Note: keep this implementation in-sync with AbstractStore.equals()!
if (that == null) {
throw new NullPointerException();
}
if (size() != that.size()) {
throw new ClassCastException(
String.format(
"Trying to compare incomparable records (wrong degree):\n%s\n%s", this, that));
}
Class<?>[] thisTypes = this.fieldsRow().types();
Class<?>[] thatTypes = that.fieldsRow().types();
if (!asList(thisTypes).equals(asList(thatTypes))) {
throw new ClassCastException(
String.format(
"Trying to compare incomparable records (type mismatch):\n%s\n%s", this, that));
}
for (int i = 0; i < size(); i++) {
final Object thisValue = getValue(i);
final Object thatValue = that.getValue(i);
// [#1850] Only return -1/+1 early. In all other cases,
// continue checking the remaining fields
if (thisValue == null && thatValue == null) {
continue;
}
// Order column values in a SQL NULLS LAST manner
else if (thisValue == null) {
return 1;
} else if (thatValue == null) {
return -1;
}
// [#985] Compare arrays too.
else if (thisValue.getClass().isArray() && thatValue.getClass().isArray()) {
// Might be byte[]
if (thisValue.getClass() == byte[].class) {
int compare = compare((byte[]) thisValue, (byte[]) thatValue);
if (compare != 0) {
return compare;
}
}
// Other primitive types are not expected
else if (!thisValue.getClass().getComponentType().isPrimitive()) {
int compare = compare((Object[]) thisValue, (Object[]) thatValue);
if (compare != 0) {
return compare;
}
} else {
throw new ClassCastException(
String.format("Unsupported data type in natural ordering: %s", thisValue.getClass()));
}
} else {
int compare = ((Comparable) thisValue).compareTo(thatValue);
if (compare != 0) {
return compare;
}
}
}
// If we got through the above loop, the two records are equal
return 0;
}