From 1ee319a7e4bea883da99ab7c2068a740e2cdf985 Mon Sep 17 00:00:00 2001 From: James Moger Date: Mon, 8 Aug 2011 08:35:24 -0400 Subject: [PATCH] Partial primitives support: insert, update, and select but NOT where. --- src/com/iciql/ModelUtils.java | 9 +++ src/com/iciql/util/Utils.java | 33 +++++---- tests/com/iciql/test/PrimitivesTest.java | 59 +++++++++++++++ .../iciql/test/models/PrimitivesModel.java | 72 +++++++++++++++++++ 4 files changed, 158 insertions(+), 15 deletions(-) create mode 100644 tests/com/iciql/test/PrimitivesTest.java create mode 100644 tests/com/iciql/test/models/PrimitivesModel.java diff --git a/src/com/iciql/ModelUtils.java b/src/com/iciql/ModelUtils.java index 9cbd295..4f53d3b 100644 --- a/src/com/iciql/ModelUtils.java +++ b/src/com/iciql/ModelUtils.java @@ -58,6 +58,15 @@ class ModelUtils { m.put(java.sql.Date.class, "DATE"); m.put(java.sql.Time.class, "TIME"); m.put(byte[].class, "BLOB"); + + // map primitives + m.put(boolean.class, m.get(Boolean.class)); + m.put(byte.class, m.get(Byte.class)); + m.put(short.class, m.get(Short.class)); + m.put(int.class, m.get(Integer.class)); + m.put(long.class, m.get(Long.class)); + m.put(float.class, m.get(Float.class)); + m.put(double.class, m.get(Double.class)); } /** diff --git a/src/com/iciql/util/Utils.java b/src/com/iciql/util/Utils.java index b8e2d60..d99f33b 100644 --- a/src/com/iciql/util/Utils.java +++ b/src/com/iciql/util/Utils.java @@ -125,21 +125,21 @@ public class Utils { @SuppressWarnings({ "unchecked", "rawtypes" }) public static T newObject(Class clazz) { // must create new instances - if (clazz == Integer.class) { + if (clazz == int.class || clazz == Integer.class) { return (T) new Integer((int) COUNTER.getAndIncrement()); } else if (clazz == String.class) { return (T) ("" + COUNTER.getAndIncrement()); - } else if (clazz == Long.class) { + } else if (clazz == long.class || clazz == Long.class) { return (T) new Long(COUNTER.getAndIncrement()); - } else if (clazz == Short.class) { + } else if (clazz == short.class || clazz == Short.class) { return (T) new Short((short) COUNTER.getAndIncrement()); - } else if (clazz == Byte.class) { + } else if (clazz == byte.class || clazz == Byte.class) { return (T) new Byte((byte) COUNTER.getAndIncrement()); - } else if (clazz == Float.class) { + } else if (clazz == float.class || clazz == Float.class) { return (T) new Float(COUNTER.getAndIncrement()); - } else if (clazz == Double.class) { + } else if (clazz == double.class || clazz == Double.class) { return (T) new Double(COUNTER.getAndIncrement()); - } else if (clazz == Boolean.class) { + } else if (clazz == boolean.class || clazz == Boolean.class) { return (T) new Boolean(false); } else if (clazz == BigDecimal.class) { return (T) new BigDecimal(COUNTER.getAndIncrement()); @@ -227,7 +227,7 @@ public class Utils { } // convert from number to boolean - if (Boolean.class.isAssignableFrom(targetType)) { + if (Boolean.class.isAssignableFrom(targetType) || boolean.class.isAssignableFrom(targetType)) { if (Number.class.isAssignableFrom(currentType)) { Number n = (Number) o; return n.intValue() > 0; @@ -236,26 +236,29 @@ public class Utils { // convert from boolean to number if (Boolean.class.isAssignableFrom(currentType)) { + Boolean b = (Boolean) o; if (Number.class.isAssignableFrom(targetType)) { - Boolean b = (Boolean) o; return b ? 1 : 0; } + if (boolean.class.isAssignableFrom(targetType)) { + return b.booleanValue(); + } } // convert from number to number if (Number.class.isAssignableFrom(currentType)) { Number n = (Number) o; - if (targetType == Byte.class) { + if (targetType == byte.class || targetType == Byte.class) { return n.byteValue(); - } else if (targetType == Short.class) { + } else if (targetType == short.class || targetType == Short.class) { return n.shortValue(); - } else if (targetType == Integer.class) { + } else if (targetType == int.class || targetType == Integer.class) { return n.intValue(); - } else if (targetType == Long.class) { + } else if (targetType == long.class || targetType == Long.class) { return n.longValue(); - } else if (targetType == Double.class) { + } else if (targetType == double.class || targetType == Double.class) { return n.doubleValue(); - } else if (targetType == Float.class) { + } else if (targetType == float.class || targetType == Float.class) { return n.floatValue(); } } diff --git a/tests/com/iciql/test/PrimitivesTest.java b/tests/com/iciql/test/PrimitivesTest.java new file mode 100644 index 0000000..aee2479 --- /dev/null +++ b/tests/com/iciql/test/PrimitivesTest.java @@ -0,0 +1,59 @@ +/* + * Copyright 2011 James Moger. + * + * 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 com.iciql.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.iciql.Db; +import com.iciql.test.models.PrimitivesModel; + +/** + * Tests primitives with autoboxing within the framework. + */ +public class PrimitivesTest { + + @Test + public void testPrimitives() { + Db db = Db.open("jdbc:h2:mem:", "sa", "sa"); + + // insert random model + PrimitivesModel model = new PrimitivesModel(); + db.insert(model); + + PrimitivesModel p = new PrimitivesModel(); + + // retrieve model and compare + PrimitivesModel retrievedModel = db.from(p).selectFirst(); + assertTrue(model.equivalentTo(retrievedModel)); + + // retrieve with conditions and compare +// StatementLogger.activateConsoleLogger(); +// retrievedModel = db.from(p).where(p.myLong).is(model.myLong).and(p.myInteger).is(model.myInteger) +// .selectFirst(); +// assertTrue(model.equivalentTo(retrievedModel)); +// +// // update myInteger and compare +// db.from(p).set(p.myInteger).to(10).where(p.myLong).is(model.myLong).update(); +// retrievedModel = db.from(p).selectFirst(); + +// assertEquals(10, retrievedModel.myInteger); + + db.close(); + } +} diff --git a/tests/com/iciql/test/models/PrimitivesModel.java b/tests/com/iciql/test/models/PrimitivesModel.java new file mode 100644 index 0000000..2d1a7da --- /dev/null +++ b/tests/com/iciql/test/models/PrimitivesModel.java @@ -0,0 +1,72 @@ +/* + * Copyright 2011 James Moger. + * + * 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 com.iciql.test.models; + +import java.util.Random; + +import com.iciql.Iciql.IQColumn; +import com.iciql.Iciql.IQTable; + +/** + * Primitive types model. + */ +@IQTable(name = "PrimitivesTest") +public class PrimitivesModel { + + @IQColumn(primaryKey = true) + public long myLong; + + @IQColumn + public int myInteger; + + @IQColumn + public short myShort; + + @IQColumn + public byte myByte; + + @IQColumn + public boolean myBoolean; + + @IQColumn + public double myDouble; + + @IQColumn + public float myFloat; + + public PrimitivesModel() { + Random rand = new Random(); + myLong = rand.nextLong(); + myInteger = rand.nextInt(); + myShort = (short) rand.nextInt(Short.MAX_VALUE); + myByte = (byte) rand.nextInt(Byte.MAX_VALUE); + myBoolean = rand.nextInt(1) == 1; + myDouble = rand.nextDouble(); + myFloat = rand.nextFloat(); + } + + public boolean equivalentTo(PrimitivesModel p) { + boolean same = true; + same &= myLong == p.myLong; + same &= myInteger == p.myInteger; + same &= myShort == p.myShort; + same &= myByte == p.myByte; + same &= myBoolean == p.myBoolean; + same &= myDouble == p.myDouble; + same &= myFloat == p.myFloat; + return same; + } +} -- 2.39.5