EP / schemaless / changeset / 97d34cb380f5

EP / schemaless

Schemaless Data Store.

Clone this repository (size: 166.6 KB): HTTPS / SSH

$ hg clone http://bitbucket.org/EP/schemaless

$ hg clone ssh://hg@bitbucket.org/EP/schemaless

commit 28:	97d34cb380f5
parent 27:	55b082e1077b
branch:	default

Simplify type conversion between sql and java.

Eung-ju PARK <eungju at google dot com>
18 months ago

Changed (Δ11.9 KB):

raw changeset »

src/main/java/schemaless/storage/MySqlIndexStorage.java (17 lines added, 14 lines removed)

src/main/java/schemaless/storage/MySqlQueryBuilder.java (5 lines added, 8 lines removed)

src/main/java/schemaless/storage/jdbc/CharSqlType.java (22 lines added, 0 lines removed)

src/main/java/schemaless/storage/jdbc/DateSqlType.java (21 lines added, 0 lines removed)

src/main/java/schemaless/storage/jdbc/EnumSqlType.java (23 lines added, 0 lines removed)

src/main/java/schemaless/storage/jdbc/NullAwareSqlType.java (33 lines added, 0 lines removed)

src/main/java/schemaless/storage/jdbc/ObjectSqlType.java (19 lines added, 0 lines removed)

src/main/java/schemaless/storage/jdbc/SqlType.java (11 lines added, 0 lines removed)

src/main/java/schemaless/storage/jdbc/SqlTypeRegistry.java (37 lines added, 0 lines removed)

src/main/java/schemaless/storage/jdbc/StringSqlType.java (19 lines added, 0 lines removed)

src/main/java/schemaless/storage/jdbc/UuidSqlType.java (21 lines added, 0 lines removed)

src/test/java/schemaless/JsonSerializerTest.java (13 lines added, 95 lines removed)

src/test/java/schemaless/Naturalist.java (82 lines added, 0 lines removed)

src/test/java/schemaless/Scientist.java (10 lines added, 0 lines removed)

src/test/java/schemaless/gardener/IndexGardeningTest.java (1 lines added, 1 lines removed)

src/test/java/schemaless/storage/MySql.sql (26 lines added, 0 lines removed)

src/test/java/schemaless/storage/MySqlIndexStorageTest.java (12 lines added, 8 lines removed)

src/test/java/schemaless/storage/MySqlQueryBuilderTest.java (2 lines added, 1 lines removed)

Up to file-list src/main/java/schemaless/storage/MySqlIndexStorage.java:

@@ -19,11 +19,14 @@ import schemaless.IndexDefinition;
 import schemaless.IndexRow;
 import schemaless.IndexStorage;
 import schemaless.query.Query;
 import schemaless.storage.jdbc.SqlType;
 import schemaless.storage.jdbc.SqlTypeRegistry;
 public class MySqlIndexStorage implements IndexStorage {
-	private final MySqlJdbcAdapter jdbcAdapter = new MySqlJdbcAdapter();
+	private final SqlTypeRegistry sqlTypeRegistry = new SqlTypeRegistry();
 	private final IndexDefinition definition;
 	private final DataSource dataSource;
 	private final SqlType entityIdSqlType;
 	private final String tableName;
 	private final String insertSql;
 	private final String updateSql;
@@ -35,6 +38,7 @@ public class MySqlIndexStorage implement
 		this.definition = definition;
 		this.dataSource = dataSource;
 		this.tableName = definition.entityDefinition().name() + "_index_" + definition.name();
 		this.entityIdSqlType = sqlTypeRegistry.get(UUID.class);
 		this.insertSql = insertSql();
 		this.updateSql = updateSql();
 		this.deleteSql = deleteSql();
@@ -107,14 +111,10 @@ public class MySqlIndexStorage implement
 			for (String each : definition.properties()) {
 				Class<?> type = definition.entityDefinition().getPropertyDescriptor(each).getPropertyType();
 				Object value = PropertyUtils.getProperty(entity, each);
 				if (type == UUID.class) {
 					jdbcAdapter.setParameter(statement, parameterIndex, (UUID) value);
 				} else {
 					statement.setObject(parameterIndex, value);
+				}
+				sqlTypeRegistry.get(type).set(statement, parameterIndex, value);
 				parameterIndex++;
+			}
-			jdbcAdapter.setParameter(statement, parameterIndex, id);
+			entityIdSqlType.set(statement, parameterIndex, id);
 			assertAffectedCount(1, statement.executeUpdate());
 		} catch (Exception e) {
 			throw new DataAccessException("Cannot insert the index of the entity " + id + " into the table " + tableName, e);
@@ -133,10 +133,12 @@ public class MySqlIndexStorage implement
 			statement = connection.prepareStatement(updateSql);
 			int parameterIndex = 1;
 			for (String each : definition.properties()) {
-				statement.setObject(parameterIndex, PropertyUtils.getProperty(entity, each));
+				Class<?> type = definition.entityDefinition().getPropertyDescriptor(each).getPropertyType();
 				Object value = PropertyUtils.getProperty(entity, each);
 				sqlTypeRegistry.get(type).set(statement, parameterIndex, value);
 				parameterIndex++;
+			}
-			jdbcAdapter.setParameter(statement, parameterIndex, id);
+			entityIdSqlType.set(statement, parameterIndex, id);
 			assertAffectedCount(1, statement.executeUpdate());
 		} catch (Exception e) {
 			throw new DataAccessException("Cannot update the index of the entity " + id + " on the table " + tableName, e);
@@ -152,7 +154,7 @@ public class MySqlIndexStorage implement
 		try {
 			connection = dataSource.getConnection();
 			statement = connection.prepareStatement(deleteSql);
-			jdbcAdapter.setParameter(statement, 1, id);
+			entityIdSqlType.set(statement, 1, id);
 			assertAffectedCount(1, statement.executeUpdate());
 		} catch (SQLException e) {
 			throw new DataAccessException("Cannot delete the index of the " + id + " on the table " + tableName, e);
@@ -183,13 +185,13 @@ public class MySqlIndexStorage implement
 		ResultSet rs = null;
 		try {
 			connection = dataSource.getConnection();
-			MySqlQueryBuilder queryBuilder = new MySqlQueryBuilder(tableName, definition.entityDefinition());
+			MySqlQueryBuilder queryBuilder = new MySqlQueryBuilder(tableName, definition.entityDefinition(), sqlTypeRegistry);
 			query.accept(queryBuilder);
 			statement = queryBuilder.buildStatement(connection);
 			rs = statement.executeQuery();
 			List<UUID> result = new ArrayList<UUID>();
 			while (rs.next()) {
-				result.add(jdbcAdapter.getColumnAsUuid(rs, 1));
+				result.add((UUID) entityIdSqlType.get(rs, 1, UUID.class));
+			}
 			return result;
 		} catch (SQLException e) {
@@ -208,14 +210,15 @@ public class MySqlIndexStorage implement
 		try {
 			connection = dataSource.getConnection();
 			statement = connection.prepareStatement(findSql);
-			jdbcAdapter.setParameter(statement, 1, id);
+			entityIdSqlType.set(statement, 1, id);
 			rs = statement.executeQuery();
 			IndexRow indexRow = null;
 			if (rs.next()) {
 				indexRow = new IndexRow();
 				int columnIndex = 1;
 				for (String each : definition.properties()) {
-					indexRow.put(each, rs.getObject(columnIndex));
+					Class<?> type = definition.entityDefinition().getPropertyDescriptor(each).getPropertyType();
 					indexRow.put(each, sqlTypeRegistry.get(type).get(rs, columnIndex++, type));
+				}
+			}
 			return indexRow;

Up to file-list src/main/java/schemaless/storage/MySqlQueryBuilder.java:

@@ -5,7 +5,6 @@ import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 import schemaless.EntityDefinition;
 import schemaless.query.And;
@@ -21,18 +20,20 @@ import schemaless.query.Predicate;
 import schemaless.query.Query;
 import schemaless.query.QueryVisitor;
 import schemaless.query.Sort;
 import schemaless.storage.jdbc.SqlTypeRegistry;
 import schemaless.support.JdbcHelper;
 class MySqlQueryBuilder implements QueryVisitor {
 	private MySqlJdbcAdapter jdbcAdapter = new MySqlJdbcAdapter();
 	private String tableName;
 	private EntityDefinition entityDefinition;
 	private SqlTypeRegistry sqlTypeRegistry;
 	private StringBuilder sql;
 	private List<SqlParameter> parameters;
-	public MySqlQueryBuilder(String tableName, EntityDefinition entityDefinition) {
+	public MySqlQueryBuilder(String tableName, EntityDefinition entityDefinition, SqlTypeRegistry sqlTypeRegistry) {
 		this.tableName = tableName;
 		this.entityDefinition = entityDefinition;
 		this.sqlTypeRegistry = sqlTypeRegistry;
 		this.sql = new StringBuilder();
 		parameters = new ArrayList<SqlParameter>();
+	}
@@ -131,11 +132,7 @@ class MySqlQueryBuilder implements Query
 		PreparedStatement statement = connection.prepareStatement(sql);
 		int parameterIndex = 1;
 		for (SqlParameter each : parameters) {
 			if (each.type == UUID.class) {
 				jdbcAdapter.setParameter(statement, parameterIndex++, (UUID) each.value);
 			} else {
 				statement.setObject(parameterIndex++, each.value);
+			}
+			sqlTypeRegistry.get(each.type).set(statement, parameterIndex++, each.value);
+		}
 		return statement;
+	}

Up to file-list src/main/java/schemaless/storage/jdbc/CharSqlType.java:

 package schemaless.storage.jdbc;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 public class CharSqlType extends NullAwareSqlType {
 	public CharSqlType(int sqlTypeCode) {
 		super(sqlTypeCode);
+	}
 	@Override
 	public void setNotNull(PreparedStatement statement, int index, Object value)	throws SQLException {
 		statement.setString(index, value.toString());
+	}
 	@Override
 	public Object getNullable(ResultSet resultSet, int index, Class<?> javaType) throws SQLException {
 		String value = resultSet.getString(index);
 		return value == null ? null : value.charAt(0);
+	}
+}

Up to file-list src/main/java/schemaless/storage/jdbc/DateSqlType.java:

 package schemaless.storage.jdbc;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Date;
 public class DateSqlType extends NullAwareSqlType {
 	public DateSqlType(int sqlTypeCode) {
 		super(sqlTypeCode);
+	}
 	public void setNotNull(PreparedStatement statement, int index, Object value) throws SQLException {
 		statement.setTimestamp(index, new java.sql.Timestamp(((Date) value).getTime()));
+	}
 	public Object getNullable(ResultSet resultSet, int index, Class<?> javaType) throws SQLException {
 		Date value = resultSet.getTimestamp(index);
 		return value == null ? null : new Date(value.getTime());
+	}
+}

Up to file-list src/main/java/schemaless/storage/jdbc/EnumSqlType.java:

 package schemaless.storage.jdbc;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 @SuppressWarnings("unchecked")
 public class EnumSqlType extends NullAwareSqlType {
 	public EnumSqlType(int sqlTypeCode) {
 		super(sqlTypeCode);
+	}
 	@Override
 	public void setNotNull(PreparedStatement statement, int index, Object value)	throws SQLException {
 		statement.setString(index, ((Enum) value).name());
+	}
 	@Override
 	public Object getNullable(ResultSet resultSet, int index, Class<?> javaType) throws SQLException {
 		String value = resultSet.getString(index);
 		return value == null ? null : Enum.valueOf((Class) javaType, value);
+	}
+}

Up to file-list src/main/java/schemaless/storage/jdbc/NullAwareSqlType.java:

 package schemaless.storage.jdbc;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 public abstract class NullAwareSqlType implements SqlType {
 	protected int sqlTypeCode;
 	public NullAwareSqlType(int sqlTypeCode) {
 		this.sqlTypeCode = sqlTypeCode;
+	}
 	public void set(PreparedStatement statement, int index, Object value) throws SQLException {
 		if (value == null) {
 			statement.setNull(index, sqlTypeCode);
 		} else {
 			setNotNull(statement, index, value);
+		}
+	}
 	public Object get(ResultSet resultSet, int index, Class<?> javaType) throws SQLException {
 		Object value = getNullable(resultSet, index, javaType);
 		if (resultSet.wasNull()) {
 			return null;
+		}
 		return value;
+	}
 	public abstract void setNotNull(PreparedStatement statement, int index, Object value) throws SQLException;
 	public abstract Object getNullable(ResultSet resultSet, int index, Class<?> javaType) throws SQLException;
+}

Up to file-list src/main/java/schemaless/storage/jdbc/ObjectSqlType.java:

 package schemaless.storage.jdbc;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 public class ObjectSqlType extends NullAwareSqlType {
 	public ObjectSqlType(int sqlTypeCode) {
 		super(sqlTypeCode);
+	}
 	public void setNotNull(PreparedStatement statement, int index, Object value) throws SQLException {
 		statement.setObject(index, value);
+	}
 	public Object getNullable(ResultSet resultSet, int index, Class<?> javaType) throws SQLException {
 		return resultSet.getObject(index);
+	}
+}

Up to file-list src/main/java/schemaless/storage/jdbc/SqlType.java:

 package schemaless.storage.jdbc;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 public interface SqlType {
 	void set(PreparedStatement statement, int index, Object value) throws SQLException;
 	Object get(ResultSet resultSet, int index, Class<?> javaType) throws SQLException;
+}

Up to file-list src/main/java/schemaless/storage/jdbc/SqlTypeRegistry.java:

 package schemaless.storage.jdbc;
 import java.sql.Types;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 public class SqlTypeRegistry {
 	private final SqlType defaultSqlType = new ObjectSqlType(Types.OTHER);
 	private final SqlType enumSqlType = new EnumSqlType(Types.VARCHAR);
 	private Map<Class<?>, SqlType> sqlTypes;
 	public SqlTypeRegistry() {
 		 sqlTypes = new HashMap<Class<?>, SqlType>();
 		 register(char.class, new CharSqlType(Types.CHAR));
 		 register(Character.class, new CharSqlType(Types.CHAR));
 		 register(String.class, new StringSqlType(Types.VARCHAR));
 		 register(Date.class, new DateSqlType(Types.TIMESTAMP));
 		 register(UUID.class, new UuidSqlType(Types.CHAR));
+	}
 	public void register(Class<?> javaType, SqlType sqlType) {
 		 sqlTypes.put(javaType, sqlType);
+	}
 	public SqlType get(Class<?> javaType) {
 		SqlType result = sqlTypes.get(javaType);
 		if (result != null) {
 			return result;
+		}
 		if (javaType.isEnum()) {
 			return enumSqlType;
+		}
 		return defaultSqlType;
+	}
+}

Up to file-list src/main/java/schemaless/storage/jdbc/StringSqlType.java:

 package schemaless.storage.jdbc;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 public class StringSqlType extends NullAwareSqlType {
 	public StringSqlType(int sqlTypeCode) {
 		super(sqlTypeCode);
+	}
 	public void setNotNull(PreparedStatement statement, int index, Object value) throws SQLException {
 		statement.setString(index, (String) value);
+	}
 	public Object getNullable(ResultSet resultSet, int index, Class<?> javaType) throws SQLException {
 		return resultSet.getString(index);
+	}
+}

Up to file-list src/main/java/schemaless/storage/jdbc/UuidSqlType.java:

 package schemaless.storage.jdbc;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.UUID;
 public class UuidSqlType extends NullAwareSqlType {
 	public UuidSqlType(int sqlTypeCode) {
 		super(sqlTypeCode);
+	}
 	public void setNotNull(PreparedStatement statement, int index, Object value) throws SQLException {
 		statement.setString(index, value.toString());
+	}
 	public Object getNullable(ResultSet resultSet, int index, Class<?> javaType) throws SQLException {
 		String value = resultSet.getString(index);
 		return value == null ? null : UUID.fromString(value);
+	}
+}

Up to file-list src/test/java/schemaless/JsonSerializerTest.java:

@@ -6,8 +6,6 @@ import java.lang.annotation.ElementType;
 import java.util.Date;
 import java.util.UUID;
 import org.apache.commons.lang.builder.EqualsBuilder;
 import org.apache.commons.lang.builder.ToStringBuilder;
 import org.json.JSONObject;
 import org.json.JSONStringer;
 import org.junit.Before;
@@ -17,7 +15,7 @@ public class JsonSerializerTest {
 	private JsonSerializer dut;
 	@Before public void beforeEach() {
-		dut = new JsonSerializer(TestingObject.class);
+		dut = new JsonSerializer(Naturalist.class);
+	}
 	@Test public void primitiveTypes() {
@@ -89,18 +87,18 @@ public class JsonSerializerTest {
+	}
 	@Test public void serialize() {
 		TestingObject entity = new TestingObject();
 		entity.setNull(null);
 		entity.setBoolean(true);
 		entity.setByte((byte) 1);
 		entity.setShort((short) 2);
 		entity.setInt(4);
 		entity.setLong(8L);
 		entity.setChar('a');
 		entity.setString("abc");
 		entity.setEnum(ElementType.METHOD);
 		entity.setDate(new Date(1L));
 		entity.setUuid(UUID.randomUUID());
 		Naturalist entity = new Naturalist();
 		entity.setNullType(null);
 		entity.setBooleanType(true);
 		entity.setByteType((byte) 1);
 		entity.setShortType((short) 2);
 		entity.setIntType(4);
 		entity.setLongType(8L);
 		entity.setCharType('a');
 		entity.setStringType("abc");
 		entity.setEnumType(ElementType.METHOD);
 		entity.setDateType(new Date(1L));
 		entity.setId(UUID.randomUUID());
 		String serialized = dut.serializeAsString(entity);
 		System.out.println(serialized);
@@ -109,84 +107,4 @@ public class JsonSerializerTest {
 		System.out.println(deserialized);
 		assertEquals(entity, deserialized);
+	}
 	private static class ParentObject {
 		public String getGetterOnly() {
 			return "hello";
+		}
 		public void setSetterOnly(String ignore) {
+		}
+	}
 	public static class TestingObject extends ParentObject {
 		private Object null_;
 		private boolean boolean_;
 		private byte byte_;
 		private short short_;
 		private int int_;
 		private long long_;
 		private char char_;
 		private String string;
 		private ElementType enum_;
 		private UUID uuid;
 		private Date date;
 		public Object getNull() {
 			return null_;
+		}
 		public void setNull(Object null_) {
 			this.null_ = null;
+		}
 		public boolean getBoolean() { return boolean_; }
 		public void setBoolean(boolean boolean_) { this.boolean_ = boolean_; }
 		public byte getByte() { return byte_; }
 		public void setByte(byte byte_) { this.byte_ = byte_; }
 		public short getShort() { return short_; }
 		public void setShort(short short_) { this.short_ = short_; }
 		public int getInt() {
 			return int_;
+		}
 		public void setInt(int int_) {
 			this.int_ = int_;
+		}
 		public long getLong() { return long_; }
 		public void setLong(long long_) { this.long_ = long_; }
 		public char getChar() { return char_; }
 		public void setChar(char char_) { this.char_ = char_; }
 		public String getString() { return string; }
 		public void setString(String string) { this.string = string; }
 		public ElementType getEnum() { return enum_; }
 		public void setEnum(ElementType enum_) { this.enum_ = enum_; }
 		public Date getDate() {
 			return date;
+		}
 		public void setDate(Date date) {
 			this.date = date;
+		}
 		public UUID getUuid() {
 			return uuid;
+		}
 		public void setUuid(UUID uuid) {
 			this.uuid = uuid;
+		}
 		public String toString() {
 			return ToStringBuilder.reflectionToString(this);
+		}
 		public boolean equals(Object that) {
 			return EqualsBuilder.reflectionEquals(this, that);
+		}
+	}
+}

Up to file-list src/test/java/schemaless/Naturalist.java:

 package schemaless;
 import java.lang.annotation.ElementType;
 import java.util.Date;
 import java.util.UUID;
 import org.apache.commons.lang.builder.EqualsBuilder;
 import org.apache.commons.lang.builder.ToStringBuilder;
 public class Naturalist extends Scientist {
 	private UUID id;
 	private String nullType;
 	private boolean booleanType;
 	private byte byteType;
 	private short shortType;
 	private int intType;
 	private long longType;
 	private char charType;
 	private String stringType;
 	private ElementType enumType;
 	private Date dateType;
 	public Naturalist() {
+	}
 	public static Naturalist sample() {
 		Naturalist x = new Naturalist();
 		x.id = UUID.randomUUID();
 		x.nullType = null;
 		x.booleanType = true;
 		x.byteType = 1;
 		x.shortType = 2;
 		x.intType = 4;
 		x.longType = 8;
 		x.charType = 'a';
 		x.stringType = "ABC";
 		x.enumType = ElementType.METHOD;
 		x.dateType = new Date();
 		return x;
+	}
 	public UUID getId() { return id; }
 	public void setId(UUID uuid) { this.id = uuid; }
 	public Object getNullType() { return nullType; }
 	public void setNullType(Object null_) { 	this.nullType = null; }
 	public boolean getBooleanType() { return booleanType; }
 	public void setBooleanType(boolean boolean_) { this.booleanType = boolean_; }
 	public byte getByteType() { return byteType; }
 	public void setByteType(byte byte_) { this.byteType = byte_; }
 	public short getShortType() { return shortType; }
 	public void setShortType(short short_) { this.shortType = short_; }
 	public int getIntType() { return intType; }
 	public void setIntType(int int_) {	this.intType = int_; }
 	public long getLongType() { return longType; }
 	public void setLongType(long long_) { this.longType = long_; }
 	public char getCharType() { return charType; }
 	public void setCharType(char char_) { this.charType = char_; }
 	public String getStringType() { return stringType; }
 	public void setStringType(String string) { this.stringType = string; }
 	public ElementType getEnumType() { return enumType; }
 	public void setEnumType(ElementType enum_) { this.enumType = enum_; }
 	public Date getDateType() { return dateType; }
 	public void setDateType(Date date) { this.dateType = date; }
 	public String toString() {
 		return ToStringBuilder.reflectionToString(this);
+	}
 	public boolean equals(Object that) {
 		return EqualsBuilder.reflectionEquals(this, that);
+	}
+}

Up to file-list src/test/java/schemaless/Scientist.java:

 package schemaless;
 class Scientist {
 	public String getGetterOnly() {
 		return "hello";
+	}
 	public void setSetterOnly(String ignore) {
+	}
+}

Up to file-list src/test/java/schemaless/gardener/IndexGardeningTest.java:

@@ -46,7 +46,7 @@ public class IndexGardeningTest {
 	@Test public void indexInspectionFailed() {
 		mockery.checking(new Expectations() {{
-			one(indexStorage).find(entity.getId()); will(throwException(new Exception("BLAH")));
+			one(indexStorage).find(entity.getId()); will(throwException(new RuntimeException("BLAH")));
 			one(listener).failed(entityRow);
 		}});
 		dut.inspect(entityRow);

Up to file-list src/test/java/schemaless/storage/MySql.sql:

@@ -14,3 +14,29 @@ CREATE TABLE feed_index_user_id (
     entity_id CHAR(36) NOT NULL UNIQUE,
     PRIMARY KEY (user_id, entity_id)
 ) ENGINE=InnoDB;
 DROP TABLE IF EXISTS naturalist;
 CREATE TABLE naturalist (
     added_id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
     id CHAR(36) NOT NULL,
     updated TIMESTAMP NOT NULL,
     body MEDIUMBLOB,
     UNIQUE KEY (id),
     KEY (updated)
 ) ENGINE=InnoDB;
 DROP TABLE IF EXISTS naturalist_index_all;
 CREATE TABLE naturalist_index_all (
 	null_type VARCHAR(127) NULL,
 	boolean_type BOOLEAN NOT NULL,
 	byte_type TINYINT NOT NULL,
 	short_type SMALLINT NOT NULL,
 	int_type INT NOT NULL,
 	long_type BIGINT NOT NULL,
 	char_type CHAR(1) NOT NULL,
 	string_type VARCHAR(255) NULL,
 	enum_type VARCHAR(127) NULL,
 	date_type DATETIME NULL,
     entity_id CHAR(36) NOT NULL UNIQUE,
     PRIMARY KEY (entity_id)
 ) ENGINE=InnoDB;

Up to file-list src/test/java/schemaless/storage/MySqlIndexStorageTest.java:

@@ -2,8 +2,10 @@ package schemaless.storage;
 import static org.junit.Assert.*;
 import java.lang.annotation.ElementType;
 import java.sql.SQLException;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 import java.util.UUID;
@@ -12,8 +14,8 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import schemaless.Naturalist;
 import schemaless.EntityDefinition;
 import schemaless.Feed;
 import schemaless.IndexDefinition;
 import schemaless.IndexStorage;
 import schemaless.query.Equal;
@@ -23,15 +25,16 @@ import schemaless.storage.MySqlIndexStor
 public class MySqlIndexStorageTest {
 	private BasicDataSource dataSource;
 	private IndexStorage dut;
-	private Feed entity = new Feed(UUID.randomUUID(), "someone");
+	private Naturalist entity;
 	@Before public void beforeEach() {
 		dataSource = JdbcTestHelper.dataSource();
 		EntityDefinition entityDefinition = new EntityDefinition("feed", Feed.class);
 		IndexDefinition index = new IndexDefinition(entityDefinition, "user_id", new String[] { "userId" });
 		EntityDefinition entityDefinition = new EntityDefinition("naturalist", Naturalist.class);
 		IndexDefinition index = new IndexDefinition(entityDefinition, "all", new String[] { "nullType", "booleanType", "byteType", "shortType", "intType", "longType", "charType", "stringType", "enumType", "dateType" });
 		dut = new MySqlIndexStorage(index, dataSource);
 		dut.deleteAll();
 		entity = Naturalist.sample();
+	}
 	@After public void afterEach() throws SQLException {
@@ -45,7 +48,8 @@ public class MySqlIndexStorageTest {
 	@Test public void update() {
 		dut.insert(entity);
-		dut.update(new Feed(entity.getId(), "another"));
+		entity.setEnumType(ElementType.FIELD);
 		dut.update(entity);
+	}
 	@Test public void delete() {
@@ -55,15 +59,15 @@ public class MySqlIndexStorageTest {
 	@Test public void findAll() {
 		dut.insert(entity);
-		Feed another = new Feed(UUID.randomUUID(), entity.getUserId());
+		Naturalist another = Naturalist.sample();
 		dut.insert(another);
-		List<UUID> actual = dut.findAll(new Query(new Equal("userId", "someone")));
+		List<UUID> actual = dut.findAll(new Query(new Equal("charType", entity.getCharType())));
 		assertTrue(actual.containsAll(Arrays.asList(another.getId(), entity.getId())));
+	}
 	@Test public void find() {
 		assertNull(dut.find(entity.getId()));
 		dut.insert(entity);
-		assertEquals(entity.getUserId(), dut.find(entity.getId()).get("userId"));
+		assertEquals(entity.getCharType(), dut.find(entity.getId()).get("charType"));
+	}
+}

Up to file-list src/test/java/schemaless/storage/MySqlQueryBuilderTest.java:

@@ -18,6 +18,7 @@ import schemaless.query.NotEqual;
 import schemaless.query.Or;
 import schemaless.query.Query;
 import schemaless.query.Sort;
 import schemaless.storage.jdbc.SqlTypeRegistry;
 public class MySqlQueryBuilderTest {
 	private MySqlQueryBuilder dut;
@@ -41,7 +42,7 @@ public class MySqlQueryBuilderTest {
+	}
 	@Before public void beforeEach() {
-		dut = new MySqlQueryBuilder("table_name", new EntityDefinition("table_name", TestingObject.class));
+		dut = new MySqlQueryBuilder("table_name", new EntityDefinition("table_name", TestingObject.class), new SqlTypeRegistry());
+	}
 	@Test public void equal() {