com.j256.ormlite.field.SqlType Java Examples

@Test
public void testRawArgsColumnSqlType() throws Exception {
	Dao<Foo, Integer> dao = createDao(Foo.class, true);
	Foo foo = new Foo();
	int val = 63465365;
	foo.val = val;
	assertEquals(1, dao.create(foo));

	QueryBuilder<Foo, Integer> qb = dao.queryBuilder();
	qb.where().raw(Foo.ID_COLUMN_NAME + " = ? and " + val + " = ?", new SelectArg(SqlType.STRING, foo.id),
			new SelectArg(SqlType.INTEGER, val));
	List<Foo> results = qb.query();
	assertNotNull(results);
	assertEquals(1, results.size());
	assertEquals(val, results.get(0).val);
}
 

@Override
protected void configureGeneratedIdSequence(StringBuilder sb, FieldType fieldType, List<String> statementsBefore,
		List<String> additionalArgs, List<String> queriesAfter) {
	// needs to match dropColumnArg()
	StringBuilder seqSb = new StringBuilder(128);
	seqSb.append("CREATE SEQUENCE ");
	appendEscapedEntityName(seqSb, fieldType.getGeneratedIdSequence());
	if (fieldType.getSqlType() == SqlType.LONG) {
		seqSb.append(" AS BIGINT");
	} else {
		// integer is the default
	}
	// with hsqldb (as opposed to all else) the sequences start at 0, grumble
	seqSb.append(" START WITH 1");
	statementsBefore.add(seqSb.toString());
	sb.append("GENERATED BY DEFAULT AS IDENTITY ");
	configureId(sb, fieldType, statementsBefore, additionalArgs, queriesAfter);
}
 

/**
 * Returns the SqlType value associated with the typeVal argument. Can be slow-er.
 */
public static SqlType getSqlTypeForTypeVal(int typeVal) {
	// iterate through to save on the extra HashMap since only for errors
	for (Map.Entry<SqlType, int[]> entry : typeToValMap.entrySet()) {
		for (int val : entry.getValue()) {
			if (val == typeVal) {
				return entry.getKey();
			}
		}
	}
	return SqlType.UNKNOWN;
}
 

@Test
public void testSqlTypeValueConst() {
	int val = 12;
	SqlType type = SqlType.INTEGER;
	ThreadLocalSelectArg arg = new ThreadLocalSelectArg(type, val);
	assertTrue(arg.isValueSet());
	assertEquals(val, arg.getValue());
	assertEquals(type, arg.getSqlType());
}
 

@Override
public void setObject(int parameterIndex, Object obj, SqlType sqlType) throws SQLException {
	if (obj == null) {
		preparedStatement.setNull(parameterIndex + 1, sqlTypeToJdbcInt(sqlType));
	} else {
		preparedStatement.setObject(parameterIndex + 1, obj, sqlTypeToJdbcInt(sqlType));
	}
}
 

@Override
protected void configureGeneratedId(String tableName, StringBuilder sb, FieldType fieldType,
		List<String> statementsBefore, List<String> statementsAfter, List<String> additionalArgs,
		List<String> queriesAfter) {
	/*
	 * Even though the documentation talks about INTEGER, it is 64-bit with a maximum value of 9223372036854775807.
	 * See http://www.sqlite.org/faq.html#q1 and http://www.sqlite.org/autoinc.html
	 */
	if (fieldType.getSqlType() != SqlType.INTEGER && fieldType.getSqlType() != SqlType.LONG) {
		throw new IllegalArgumentException(
				"Sqlite requires that auto-increment generated-id be integer or long type");
	}
	sb.append("PRIMARY KEY AUTOINCREMENT ");
	// no additional call to configureId here
}
 

@Test
public void testGetFieldConverterSerializable() {
	DerbyEmbeddedDatabaseType type = new DerbyEmbeddedDatabaseType();
	FieldConverter converter = type.getFieldConverter(DataType.SERIALIZABLE.getDataPersister(), null);
	assertEquals(SqlType.BLOB, converter.getSqlType());
	assertTrue(converter.isStreamType());
}
 

public static int sqlTypeToJdbcInt(SqlType sqlType) {
	switch (sqlType) {
		case STRING:
			return Types.VARCHAR;
		case LONG_STRING:
			return Types.LONGVARCHAR;
		case DATE:
			return Types.TIMESTAMP;
		case BOOLEAN:
			return Types.BOOLEAN;
		case CHAR:
			return Types.CHAR;
		case BYTE:
			return Types.TINYINT;
		case BYTE_ARRAY:
			return Types.VARBINARY;
		case SHORT:
			return Types.SMALLINT;
		case INTEGER:
			return Types.INTEGER;
		case LONG:
			// Types.DECIMAL, Types.NUMERIC
			return Types.BIGINT;
		case FLOAT:
			return Types.FLOAT;
		case DOUBLE:
			return Types.DOUBLE;
		case SERIALIZABLE:
			return Types.VARBINARY;
		case BLOB:
			return Types.BLOB;
		case BIG_DECIMAL:
			return Types.NUMERIC;
		default:
			throw new IllegalArgumentException("No JDBC mapping for unknown SqlType " + sqlType);
	}
}
 

private SerializableType() {
	/*
	 * NOTE: Serializable class should _not_ be in the list because _everything_ is serializable and we want to
	 * force folks to use DataType.SERIALIZABLE -- especially for forwards compatibility.
	 */
	super(SqlType.SERIALIZABLE);
}
 

private ShortType() {
	super(SqlType.SHORT, new Class<?>[] { short.class });
}
 

private ByteType() {
	super(SqlType.BYTE, new Class<?>[] { byte.class });
}
 

/**
 * Here for others to subclass.
 */
protected ShortType(SqlType sqlType, Class<?>[] classes) {
	super(sqlType, classes);
}
 

private EnumIntegerType() {
	super(SqlType.INTEGER);
}
 

/**
 * Here for others to subclass.
 */
protected EnumStringType(SqlType sqlType, Class<?>[] classes) {
	super(sqlType, classes);
}
 

/**
 * Here for others to subclass.
 */
protected ByteType(SqlType sqlType, Class<?>[] classes) {
	super(sqlType, classes);
}
 

protected BaseEnumType(SqlType sqlType) {
	super(sqlType);
}
 

@Test
public void testCoverage() {
	new LongStringType(SqlType.LONG_STRING, new Class[0]);
}
 

protected BooleanType(SqlType sqlType) {
	super(sqlType);
}
 

protected BaseDateType(SqlType sqlType) {
	super(sqlType);
}
 

private DateStringType() {
	super(SqlType.STRING);
}
 

@Test
public void testCoverage() {
	new BooleanType(SqlType.BOOLEAN, new Class[0]);
}
 

/**
 * Here for others to subclass.
 */
protected DoubleType(SqlType sqlType, Class<?>[] classes) {
	super(sqlType, classes);
}
 

private DoubleType() {
	super(SqlType.DOUBLE, new Class<?>[] { double.class });
}
 

protected LongObjectType(SqlType sqlType, Class<?>[] classes) {
	super(sqlType, classes);
}
 

private LongObjectType() {
	super(SqlType.LONG, new Class<?>[] { Long.class });
}
 

@Test
public void testCoverage() {
	new SqlDateType(SqlType.DATE, new Class[0]);
}
 

protected ShortObjectType(SqlType sqlType, Class<?>[] classes) {
	super(sqlType, classes);
}
 

/**
 * Here for others to subclass.
 */
protected FloatType(SqlType sqlType, Class<?>[] classes) {
	super(sqlType, classes);
}
 

@Test
public void testCoverage() {
	new CharType(SqlType.CHAR, new Class[0]);
}
 

protected BigIntegerType() {
	super(SqlType.STRING, new Class<?>[] { BigInteger.class });
}