reorganize the type definition

net/examp1e/picoorm/Condition.java

@@ -7,20 +7,27 @@
 
 public class Condition<Row extends AbstractRow> {
 
-	static interface Parameter {
+	public static interface Parameter {
 		public void bindTo(PreparedStatement ps, int parameterIndex) throws SQLException;
 	}
 
+	public static abstract class OrderBy {
+		abstract String toOrderBySQL();
+	}
+
 	final TableDefinition<Row> tableDefinition;
 	String term;
 	ArrayList<Parameter> params = new ArrayList<Parameter>();
 	ArrayList<String> orderBy = new ArrayList<String>();
 	long limitOffset = 0;
 	long limitCount = -1;
 
-	Condition(TableDefinition<Row> tableDefinition, String term) {
+	public Condition(TableDefinition<Row> tableDefinition, String term, Parameter... params) {
 		this.tableDefinition = tableDefinition;
 		this.term = term;
+		for (Parameter param : params) {
+			this.params.add(param);
+		}
 	}
 
 	public Condition<Row> and(Condition<Row> x) {
@@ -35,10 +42,9 @@ public Condition<Row> or(Condition<Row> x) {
 		return this;
 	}
 
-	@SuppressWarnings("varargs")
-	public Condition<Row> orderBy(Predicate<Row>... predicates) {
-		for (Predicate<Row> predicate : predicates) {
-			orderBy.add(predicate.fieldName + (predicate.orderIsAscending() ? " ASC" : " DESC"));
+	public Condition<Row> orderBy(OrderBy... orders) {
+		for (OrderBy order : orders) {
+			orderBy.add(order.toOrderBySQL());
 		}
 		return this;
 	}

net/examp1e/picoorm/Predicate.java

@@ -1,40 +1,32 @@
 package net.examp1e.picoorm;
 
-public abstract class Predicate<Row extends AbstractRow> {
-
-	public static class OrderPredicate<Row extends AbstractRow> extends Predicate<Row> {
-		boolean isAsc = true;
-		OrderPredicate(Predicate<Row> src, boolean isAsc) {
-			super(src);
+public abstract class Predicate<Row extends AbstractRow> extends Condition.OrderBy {
+
+	public static class OrderPredicate<Row extends AbstractRow> extends Condition.OrderBy {
+		Predicate<Row> predicate;
+		boolean isAsc;
+		OrderPredicate(Predicate<Row> predicate, boolean isAsc) {
+			this.predicate = predicate;
 			this.isAsc = isAsc;
 		}
 		@Override
-		boolean orderIsAscending() {
-			return this.isAsc;
+		String toOrderBySQL() {
+			return this.predicate.fieldName + (isAsc ? " ASC" : " DESC");
 		}
 	}
 
-	final TableDefinition<Row> tableDefinition;
-	String fieldName;
-
-	public final OrderPredicate<Row> asc;
-	public final OrderPredicate<Row> desc;
+	protected TableDefinition<Row> tableDefinition;
+	protected String fieldName;
+	public final OrderPredicate<Row> asc = new OrderPredicate<Row>(this, true);
+	public final OrderPredicate<Row> desc = new OrderPredicate<Row>(this, false);
 
-	protected Predicate(TableDefinition<Row> tableDefinition, String fieldName) {
+	protected void _init(TableDefinition<Row> tableDefinition, String fieldName) {
 		this.tableDefinition = tableDefinition;
 		this.fieldName = fieldName;
-		this.asc = new OrderPredicate<Row>(this, true);
-		this.desc = new OrderPredicate<Row>(this, false);
-	}
-
-	protected Predicate(Predicate<Row> src) {
-		this.tableDefinition = src.tableDefinition;
-		this.fieldName = src.fieldName;
-		this.asc = src.asc;
-		this.desc = src.desc;
 	}
 
-	boolean orderIsAscending() {
-		return true;
+	@Override
+	String toOrderBySQL() {
+		return this.asc.toOrderBySQL();
 	}
 }

net/examp1e/picoorm/example/Main.java

@@ -30,7 +30,7 @@ public static void main(String[] args) {
 			Member.name.is("yappo").update(conn, new Member().setName("seiitaishogun"));
 
 			// SELECT FROM member WHERE id<?
-			for (Member m: Member.id.lessThan(1000).limit(1).search(conn)) {
+			for (Member m: Member.id.lessThan(1000L).limit(1).search(conn)) {
 				System.out.println(Long.toString(m.getId()) + ":" + m.getName());
 			}
 

net/examp1e/picoorm/example/Member.java

@@ -4,8 +4,8 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
-
 import net.examp1e.picoorm.*;
+import net.examp1e.picoorm.types.*;
 
 // this class definition should be automatically generated from the DDL
 public class Member extends AbstractRow {
@@ -18,17 +18,15 @@ public String getTableName() {
 		}
 		public ArrayList<String> getColumnNames(Member row) {
 			ArrayList<String> names = new ArrayList<String>();
-			if (row == null || row._id_isset)
+			if (row == null || row._id.isSet())
 				names.add("id");
-			if (row == null || row._name_isset)
+			if (row == null || row._name.isSet())
 				names.add("name");
 			return names;
 		}
 		public int bind(Member row, PreparedStatement ps, int index) throws SQLException {
-			if (row._id_isset)
-				setLong(ps, index++, row._id_value);
-			if (row._name_isset)
-				setString(ps, index++, row._name_value);
+			index = row._id.bindTo(ps, index);
+			index = row._name.bindTo(ps, index);
 			return index;
 		}
 		public Member deserialize(ResultSet rs) throws SQLException {
@@ -42,29 +40,25 @@ protected TableDefinition<Member> _getTableDefinition() {
 	}
 
 	// for query
-	public final static LongPredicate<Member> id = new LongPredicate<Member>(TABLE_DEFINITION, "id");
-	public final static StringPredicate<Member> name = new StringPredicate<Member>(TABLE_DEFINITION, "name");
+	public final static LongType.Predicate<Member> id = new LongType.Predicate<Member>().init(TABLE_DEFINITION, "id");
+	public final static StringType.Predicate<Member> name = new StringType.Predicate<Member>().init(TABLE_DEFINITION, "name");
 
 	// for insert,update
-	Long _id_value;
-	boolean _id_isset;
-	String _name_value;
-	boolean _name_isset;
+	LongType _id = new LongType().init(0L);
+	StringType _name = new StringType().init("");
 	public Member setId(long id) {
-		_id_value = id;
-		_id_isset = true;
+		_id.set(id);
 		return this;
 	}
-	public Long getId() {
-		return _id_value;
+	public long getId() {
+		return _id.get();
 	}
 	public Member setName(String name) {
-		_name_value = name;
-		_name_isset = true;
+		_name.set(name);
 		return this;
 	}
 	public String getName() {
-		return _name_value;
+		return _name.get();
 	}
 
 }

net/examp1e/picoorm/types/AbstractType.java

@@ -0,0 +1,73 @@
+package net.examp1e.picoorm.types;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+import net.examp1e.picoorm.*;
+
+public abstract class AbstractType<ThisType, ValueType> {
+
+	public static interface Binder<T> {
+		void bind(PreparedStatement ps, int parameterIndex, T value) throws SQLException;
+	}
+
+	ValueType value;
+	boolean isSet;
+
+	public boolean isSet() {
+		return isSet;
+	}
+
+	public ValueType get() {
+		return value;
+	}
+
+	public void set(ValueType value) {
+		this.value = value;
+		this.isSet = true;
+	}
+
+	@SuppressWarnings("unchecked")
+	public ThisType init(ValueType defaultValue) {
+		this.value = defaultValue;
+		return (ThisType)this;
+	}
+
+	public int bindTo(PreparedStatement ps, int parameterIndex) throws SQLException {
+		if (isSet())
+			getBinder().bind(ps, parameterIndex, value);
+		return parameterIndex;
+	}
+
+	protected abstract Binder<ValueType> getBinder();
+
+	static abstract class Parameter<ValueType> implements Condition.Parameter {
+		ValueType value;
+		Parameter(ValueType value) {
+			this.value = value;
+		}
+		public void bindTo(PreparedStatement ps, int parameterIndex) throws SQLException {
+			getBinder().bind(ps, parameterIndex, value);
+		}
+		protected abstract Binder<ValueType> getBinder();
+	}
+
+	public static abstract class Predicate<ThisType, Row extends AbstractRow, ValueType> extends net.examp1e.picoorm.Predicate<Row> {
+		@SuppressWarnings("unchecked")
+		public ThisType init(TableDefinition<Row> tableDefinition, String fieldName) {
+			_init(tableDefinition, fieldName);
+			return (ThisType)this;
+		}
+		public Condition<Row> is(ValueType x) {
+			return _buildBinaryOp("=", x);
+		}
+		public Condition<Row> lessThan(ValueType x) {
+			return _buildBinaryOp("<", x);
+		}
+		private Condition<Row> _buildBinaryOp(String op, ValueType value) {
+			return new Condition<Row>(this.tableDefinition, this.fieldName + op + "?", createParameter(value));
+		}
+		protected abstract Parameter<ValueType> createParameter(ValueType x);
+	}
+
+}

net/examp1e/picoorm/types/LongType.java

@@ -0,0 +1,37 @@
+package net.examp1e.picoorm.types;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Types;
+
+import net.examp1e.picoorm.*;
+
+public class LongType extends AbstractType<LongType, Long> {
+
+	final static Binder<Long> BINDER = new Binder<Long>() {
+		@Override
+		public void bind(PreparedStatement ps, int parameterIndex, Long value) throws SQLException {
+			if (value != null)
+				ps.setLong(parameterIndex, value);
+			else
+				ps.setNull(parameterIndex, Types.BIGINT);
+		}
+	};
+
+	@Override
+	protected Binder<Long> getBinder() {
+		return BINDER;
+	}
+
+	public static class Predicate<Row extends AbstractRow> extends AbstractType.Predicate<Predicate<Row>, Row, Long> {
+		@Override
+		protected Parameter<Long> createParameter(Long value) {
+			return new Parameter<Long>(value) {
+				protected Binder<Long> getBinder() {
+					return BINDER;
+				}
+			};
+		}
+	}
+
+}

net/examp1e/picoorm/types/StringType.java

@@ -0,0 +1,37 @@
+package net.examp1e.picoorm.types;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Types;
+
+import net.examp1e.picoorm.*;
+
+public class StringType extends AbstractType<StringType, String> {
+
+	final static Binder<String> BINDER = new Binder<String>() {
+		@Override
+		public void bind(PreparedStatement ps, int parameterIndex, String value) throws SQLException {
+			if (value != null)
+				ps.setString(parameterIndex, value);
+			else
+				ps.setNull(parameterIndex, Types.VARCHAR);
+		}
+	};
+
+	@Override
+	protected Binder<String> getBinder() {
+		return BINDER;
+	}
+
+	public static class Predicate<Row extends AbstractRow> extends AbstractType.Predicate<Predicate<Row>, Row, String> {
+		@Override
+		protected Parameter<String> createParameter(String value) {
+			return new Parameter<String>(value) {
+				protected Binder<String> getBinder() {
+					return BINDER;
+				}
+			};
+		}
+	}
+
+}