src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
BaseSqliteDatabaseType extends BaseDatabaseType { @Override public FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType) { switch (dataPersister.getSqlType()) { case BOOLEAN : return booleanConverter; case BIG_DECIMAL : return BigDecimalStringType.getSingleton(); default : return super.getFieldConverter(dataPersister, fieldType); } } @Override boolean isVarcharFieldWidthSupported(); @Override boolean isCreateTableReturnsZero(); @Override boolean isCreateIfNotExistsSupported(); @Override FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType); @Override void appendInsertNoColumns(StringBuilder sb); }
|
@Test public void testGetFieldConverter() throws Exception { OurSqliteDatabaseType dbType = new OurSqliteDatabaseType(); assertEquals(Byte.valueOf((byte) 1), dbType.getFieldConverter(DataType.BOOLEAN.getDataPersister(), null) .parseDefaultString(null, "true")); }
@Test public void testDefaultFieldConverter() { OurSqliteDatabaseType dbType = new OurSqliteDatabaseType(); assertSame(DataType.STRING.getDataPersister(), dbType.getFieldConverter(DataType.STRING.getDataPersister(), null)); }
|
DatabaseFieldConfig { public static DatabaseFieldConfig fromField(DatabaseType databaseType, String tableName, Field field) throws SQLException { DatabaseField databaseField = field.getAnnotation(DatabaseField.class); if (databaseField != null) { if (databaseField.persisted()) { return fromDatabaseField(databaseType, tableName, field, databaseField); } else { return null; } } ForeignCollectionField foreignCollection = field.getAnnotation(ForeignCollectionField.class); if (foreignCollection != null) { return fromForeignCollection(databaseType, field, foreignCollection); } if (javaxPersistenceConfigurer == null) { return null; } else { return javaxPersistenceConfigurer.createFieldConfig(databaseType, field); } } DatabaseFieldConfig(); DatabaseFieldConfig(String fieldName); DatabaseFieldConfig(String fieldName, String columnName, DataType dataType, String defaultValue, int width,
boolean canBeNull, boolean id, boolean generatedId, String generatedIdSequence, boolean foreign,
DatabaseTableConfig<?> foreignTableConfig, boolean useGetSet, Enum<?> unknownEnumValue,
boolean throwIfNull, String format, boolean unique, String indexName, String uniqueIndexName,
boolean autoRefresh, int maxForeignAutoRefreshLevel, int maxForeignCollectionLevel); String getFieldName(); void setFieldName(String fieldName); String getColumnName(); void setColumnName(String columnName); DataType getDataType(); void setDataType(DataType dataType); DataPersister getDataPersister(); void setDataPersister(DataPersister dataPersister); String getDefaultValue(); void setDefaultValue(String defaultValue); int getWidth(); void setWidth(int width); boolean isCanBeNull(); void setCanBeNull(boolean canBeNull); boolean isId(); void setId(boolean id); boolean isGeneratedId(); void setGeneratedId(boolean generatedId); String getGeneratedIdSequence(); void setGeneratedIdSequence(String generatedIdSequence); boolean isForeign(); void setForeign(boolean foreign); DatabaseTableConfig<?> getForeignTableConfig(); void setForeignTableConfig(DatabaseTableConfig<?> foreignTableConfig); boolean isUseGetSet(); void setUseGetSet(boolean useGetSet); Enum<?> getUnknownEnumValue(); void setUnknownEnumValue(Enum<?> unknownEnumValue); boolean isThrowIfNull(); void setThrowIfNull(boolean throwIfNull); boolean isPersisted(); void setPersisted(boolean persisted); String getFormat(); void setFormat(String format); boolean isUnique(); void setUnique(boolean unique); boolean isUniqueCombo(); void setUniqueCombo(boolean uniqueCombo); boolean isIndex(); void setIndex(boolean index); String getIndexName(String tableName); void setIndexName(String indexName); boolean isUniqueIndex(); void setUniqueIndex(boolean uniqueIndex); String getUniqueIndexName(String tableName); void setUniqueIndexName(String uniqueIndexName); void setForeignAutoRefresh(boolean foreignAutoRefresh); boolean isForeignAutoRefresh(); int getMaxForeignAutoRefreshLevel(); void setMaxForeignAutoRefreshLevel(int maxForeignLevel); boolean isForeignCollection(); void setForeignCollection(boolean foreignCollection); boolean isForeignCollectionEager(); void setForeignCollectionEager(boolean foreignCollectionEager); int getForeignCollectionMaxEagerLevel(); void setForeignCollectionMaxEagerLevel(int foreignCollectionMaxEagerLevel); String getForeignCollectionColumnName(); void setForeignCollectionColumnName(String foreignCollectionColumn); String getForeignCollectionOrderColumnName(); void setForeignCollectionOrderColumnName(String foreignCollectionOrderColumn); boolean isForeignCollectionOrderAscending(); void setForeignCollectionOrderAscending(boolean foreignCollectionOrderAscending); String getForeignCollectionForeignFieldName(); void setForeignCollectionForeignFieldName(String foreignCollectionForeignFieldName); Class<? extends DataPersister> getPersisterClass(); void setPersisterClass(Class<? extends DataPersister> persisterClass); boolean isAllowGeneratedIdInsert(); void setAllowGeneratedIdInsert(boolean allowGeneratedIdInsert); String getColumnDefinition(); void setColumnDefinition(String columnDefinition); boolean isForeignAutoCreate(); void setForeignAutoCreate(boolean foreignAutoCreate); boolean isVersion(); void setVersion(boolean version); String getForeignColumnName(); void setForeignColumnName(String foreignColumnName); boolean isReadOnly(); void setReadOnly(boolean readOnly); static DatabaseFieldConfig fromField(DatabaseType databaseType, String tableName, Field field); static Method findGetMethod(Field field, boolean throwExceptions); static Method findSetMethod(Field field, boolean throwExceptions); static DatabaseFieldConfig fromDatabaseField(DatabaseType databaseType, String tableName, Field field,
DatabaseField databaseField); void postProcess(); static Enum<?> findMatchingEnumVal(Field field, String unknownEnumName); static final Class<? extends DataPersister> DEFAULT_PERSISTER_CLASS; static final DataType DEFAULT_DATA_TYPE; static final boolean DEFAULT_CAN_BE_NULL; static final boolean DEFAULT_FOREIGN_COLLECTION_ORDER_ASCENDING; static final int NO_MAX_FOREIGN_AUTO_REFRESH_LEVEL_SPECIFIED; }
|
@Test(expected = IllegalArgumentException.class) public void testUnknownEnumVal() throws Exception { Field[] fields = BadUnknownVal.class.getDeclaredFields(); assertTrue(fields.length >= 1); DatabaseFieldConfig.fromField(databaseType, "foo", fields[0]); }
@Test public void testNotPersisted() throws Exception { DatabaseFieldConfig fieldConfig = DatabaseFieldConfig.fromField(databaseType, "foo", NotPersisted.class.getDeclaredField("field")); assertNull(fieldConfig); }
|
FieldType { public FieldType(ConnectionSource connectionSource, String tableName, Field field, DatabaseFieldConfig fieldConfig, Class<?> parentClass) throws SQLException { this.connectionSource = connectionSource; this.tableName = tableName; DatabaseType databaseType = connectionSource.getDatabaseType(); this.field = field; this.parentClass = parentClass; fieldConfig.postProcess(); Class<?> clazz = field.getType(); DataPersister dataPersister; if (fieldConfig.getDataPersister() == null) { Class<? extends DataPersister> persisterClass = fieldConfig.getPersisterClass(); if (persisterClass == null || persisterClass == VoidType.class) { dataPersister = DataPersisterManager.lookupForField(field); } else { Method method; try { method = persisterClass.getDeclaredMethod("getSingleton"); } catch (Exception e) { throw SqlExceptionUtil .create("Could not find getSingleton static method on class " + persisterClass, e); } Object result; try { result = method.invoke(null); } catch (InvocationTargetException e) { throw SqlExceptionUtil.create("Could not run getSingleton method on class " + persisterClass, e.getTargetException()); } catch (Exception e) { throw SqlExceptionUtil.create("Could not run getSingleton method on class " + persisterClass, e); } if (result == null) { throw new SQLException( "Static getSingleton method should not return null on class " + persisterClass); } try { dataPersister = (DataPersister) result; } catch (Exception e) { throw SqlExceptionUtil .create("Could not cast result of static getSingleton method to DataPersister from class " + persisterClass, e); } } } else { dataPersister = fieldConfig.getDataPersister(); if (!dataPersister.isValidForField(field)) { StringBuilder sb = new StringBuilder(); sb.append("Field class ").append(clazz.getName()); sb.append(" for field ").append(this); sb.append(" is not valid for type ").append(dataPersister); Class<?> primaryClass = dataPersister.getPrimaryClass(); if (primaryClass != null) { sb.append(", maybe should be " + primaryClass); } throw new IllegalArgumentException(sb.toString()); } } String foreignColumnName = fieldConfig.getForeignColumnName(); String defaultFieldName = field.getName(); if (fieldConfig.isForeign() || fieldConfig.isForeignAutoRefresh() || foreignColumnName != null) { if (dataPersister != null && dataPersister.isPrimitive()) { throw new IllegalArgumentException( "Field " + this + " is a primitive class " + clazz + " but marked as foreign"); } if (foreignColumnName == null) { defaultFieldName = defaultFieldName + FOREIGN_ID_FIELD_SUFFIX; } else { defaultFieldName = defaultFieldName + "_" + foreignColumnName; } if (ForeignCollection.class.isAssignableFrom(clazz)) { throw new SQLException("Field '" + field.getName() + "' in class " + clazz + "' should use the @" + ForeignCollectionField.class.getSimpleName() + " annotation not foreign=true"); } } else if (fieldConfig.isForeignCollection()) { if (clazz != Collection.class && !ForeignCollection.class.isAssignableFrom(clazz)) { throw new SQLException("Field class for '" + field.getName() + "' must be of class " + ForeignCollection.class.getSimpleName() + " or Collection."); } Type type = field.getGenericType(); if (!(type instanceof ParameterizedType)) { throw new SQLException("Field class for '" + field.getName() + "' must be a parameterized Collection."); } Type[] genericArguments = ((ParameterizedType) type).getActualTypeArguments(); if (genericArguments.length == 0) { throw new SQLException("Field class for '" + field.getName() + "' must be a parameterized Collection with at least 1 type."); } } else if (dataPersister == null && (!fieldConfig.isForeignCollection())) { if (byte[].class.isAssignableFrom(clazz)) { throw new SQLException("ORMLite does not know how to store " + clazz + " for field '" + field.getName() + "'. byte[] fields must specify dataType=DataType.BYTE_ARRAY or SERIALIZABLE"); } else if (Serializable.class.isAssignableFrom(clazz)) { throw new SQLException("ORMLite does not know how to store " + clazz + " for field '" + field.getName() + "'. Use another class, custom persister, or to serialize it use " + "dataType=DataType.SERIALIZABLE"); } else { throw new IllegalArgumentException("ORMLite does not know how to store " + clazz + " for field " + field.getName() + ". Use another class or a custom persister."); } } if (fieldConfig.getColumnName() == null) { this.columnName = defaultFieldName; } else { this.columnName = fieldConfig.getColumnName(); } this.fieldConfig = fieldConfig; if (fieldConfig.isId()) { if (fieldConfig.isGeneratedId() || fieldConfig.getGeneratedIdSequence() != null) { throw new IllegalArgumentException( "Must specify one of id, generatedId, and generatedIdSequence with " + field.getName()); } this.isId = true; this.isGeneratedId = false; this.generatedIdSequence = null; } else if (fieldConfig.isGeneratedId()) { if (fieldConfig.getGeneratedIdSequence() != null) { throw new IllegalArgumentException( "Must specify one of id, generatedId, and generatedIdSequence with " + field.getName()); } this.isId = true; this.isGeneratedId = true; if (databaseType.isIdSequenceNeeded()) { this.generatedIdSequence = databaseType.generateIdSequenceName(tableName, this); } else { this.generatedIdSequence = null; } } else if (fieldConfig.getGeneratedIdSequence() != null) { this.isId = true; this.isGeneratedId = true; String seqName = fieldConfig.getGeneratedIdSequence(); if (databaseType.isEntityNamesMustBeUpCase()) { seqName = databaseType.upCaseEntityName(seqName); } this.generatedIdSequence = seqName; } else { this.isId = false; this.isGeneratedId = false; this.generatedIdSequence = null; } if (this.isId && (fieldConfig.isForeign() || fieldConfig.isForeignAutoRefresh())) { throw new IllegalArgumentException("Id field " + field.getName() + " cannot also be a foreign object"); } if (fieldConfig.isUseGetSet()) { this.fieldGetMethod = DatabaseFieldConfig.findGetMethod(field, true); this.fieldSetMethod = DatabaseFieldConfig.findSetMethod(field, true); } else { if (!field.isAccessible()) { try { this.field.setAccessible(true); } catch (SecurityException e) { throw new IllegalArgumentException("Could not open access to field " + field.getName() + ". You may have to set useGetSet=true to fix."); } } this.fieldGetMethod = null; this.fieldSetMethod = null; } if (fieldConfig.isAllowGeneratedIdInsert() && !fieldConfig.isGeneratedId()) { throw new IllegalArgumentException( "Field " + field.getName() + " must be a generated-id if allowGeneratedIdInsert = true"); } if (fieldConfig.isForeignAutoRefresh() && !fieldConfig.isForeign()) { throw new IllegalArgumentException( "Field " + field.getName() + " must have foreign = true if foreignAutoRefresh = true"); } if (fieldConfig.isForeignAutoCreate() && !fieldConfig.isForeign()) { throw new IllegalArgumentException( "Field " + field.getName() + " must have foreign = true if foreignAutoCreate = true"); } if (fieldConfig.getForeignColumnName() != null && !fieldConfig.isForeign()) { throw new IllegalArgumentException( "Field " + field.getName() + " must have foreign = true if foreignColumnName is set"); } if (fieldConfig.isVersion() && (dataPersister == null || !dataPersister.isValidForVersion())) { throw new IllegalArgumentException( "Field " + field.getName() + " is not a valid type to be a version field"); } assignDataType(databaseType, dataPersister); } FieldType(ConnectionSource connectionSource, String tableName, Field field, DatabaseFieldConfig fieldConfig,
Class<?> parentClass); void configDaoInformation(ConnectionSource connectionSource, Class<?> parentClass); Field getField(); String getTableName(); String getFieldName(); Class<?> getType(); Type getGenericType(); String getColumnName(); DataPersister getDataPersister(); Object getDataTypeConfigObj(); SqlType getSqlType(); Object getDefaultValue(); int getWidth(); boolean isCanBeNull(); boolean isId(); boolean isGeneratedId(); boolean isGeneratedIdSequence(); String getGeneratedIdSequence(); boolean isForeign(); void assignField(Object data, Object val, boolean parentObject, ObjectCache objectCache); Object assignIdValue(Object data, Number val, ObjectCache objectCache); FV extractRawJavaFieldValue(Object object); Object extractJavaFieldValue(Object object); Object extractJavaFieldToSqlArgValue(Object object); Object convertJavaFieldToSqlArgValue(Object fieldVal); Object convertStringToJavaField(String value, int columnPos); Object moveToNextValue(Object val); FieldType getForeignIdField(); FieldType getForeignRefField(); boolean isEscapedValue(); Enum<?> getUnknownEnumVal(); String getFormat(); boolean isUnique(); boolean isUniqueCombo(); String getIndexName(); String getUniqueIndexName(); boolean isEscapedDefaultValue(); boolean isComparable(); boolean isArgumentHolderRequired(); boolean isForeignCollection(); BaseForeignCollection<FT, FID> buildForeignCollection(Object parent, FID id); T resultToJava(DatabaseResults results, Map<String, Integer> columnPositions); boolean isSelfGeneratedId(); boolean isAllowGeneratedIdInsert(); String getColumnDefinition(); boolean isForeignAutoCreate(); boolean isVersion(); Object generateId(); boolean isReadOnly(); FV getFieldValueIfNotDefault(Object object); boolean isObjectsFieldValueDefault(Object object); Object getJavaDefaultValueDefault(); int createWithForeignDao(T foreignData); static FieldType createFieldType(ConnectionSource connectionSource, String tableName, Field field,
Class<?> parentClass); @Override boolean equals(Object arg); @Override int hashCode(); @Override String toString(); static final String FOREIGN_ID_FIELD_SUFFIX; }
|
@Test public void testFieldType() throws Exception { Field[] fields = LocalFoo.class.getDeclaredFields(); assertTrue(fields.length >= 4); Field nameField = fields[0]; Field rankField = fields[1]; Field serialField = fields[2]; Field intLongField = fields[3]; FieldType fieldType = FieldType.createFieldType(connectionSource, LocalFoo.class.getSimpleName(), nameField, LocalFoo.class); assertEquals(nameField.getName(), fieldType.getFieldName()); assertEquals(nameField.getName(), fieldType.getColumnName()); assertEquals(DataType.STRING.getDataPersister(), fieldType.getDataPersister()); assertEquals(0, fieldType.getWidth()); assertTrue(fieldType.toString().contains("Foo")); assertTrue(fieldType.toString().contains(nameField.getName())); fieldType = FieldType.createFieldType(connectionSource, LocalFoo.class.getSimpleName(), rankField, LocalFoo.class); assertEquals(RANK_DB_COLUMN_NAME, fieldType.getColumnName()); assertEquals(DataType.STRING.getDataPersister(), fieldType.getDataPersister()); assertEquals(RANK_WIDTH, fieldType.getWidth()); fieldType = FieldType.createFieldType(connectionSource, LocalFoo.class.getSimpleName(), serialField, LocalFoo.class); assertEquals(serialField.getName(), fieldType.getColumnName()); assertEquals(DataType.INTEGER_OBJ.getDataPersister(), fieldType.getDataPersister()); assertEquals(Integer.parseInt(SERIAL_DEFAULT_VALUE), fieldType.getDefaultValue()); String tableName = LocalFoo.class.getSimpleName(); fieldType = FieldType.createFieldType(connectionSource, tableName, intLongField, LocalFoo.class); assertEquals(intLongField.getName(), fieldType.getColumnName()); assertFalse(fieldType.isGeneratedId()); assertEquals(DataType.LONG.getDataPersister(), fieldType.getDataPersister()); }
|
FieldType { public static FieldType createFieldType(ConnectionSource connectionSource, String tableName, Field field, Class<?> parentClass) throws SQLException { DatabaseType databaseType = connectionSource.getDatabaseType(); DatabaseFieldConfig fieldConfig = DatabaseFieldConfig.fromField(databaseType, tableName, field); if (fieldConfig == null) { return null; } else { return new FieldType(connectionSource, tableName, field, fieldConfig, parentClass); } } FieldType(ConnectionSource connectionSource, String tableName, Field field, DatabaseFieldConfig fieldConfig,
Class<?> parentClass); void configDaoInformation(ConnectionSource connectionSource, Class<?> parentClass); Field getField(); String getTableName(); String getFieldName(); Class<?> getType(); Type getGenericType(); String getColumnName(); DataPersister getDataPersister(); Object getDataTypeConfigObj(); SqlType getSqlType(); Object getDefaultValue(); int getWidth(); boolean isCanBeNull(); boolean isId(); boolean isGeneratedId(); boolean isGeneratedIdSequence(); String getGeneratedIdSequence(); boolean isForeign(); void assignField(Object data, Object val, boolean parentObject, ObjectCache objectCache); Object assignIdValue(Object data, Number val, ObjectCache objectCache); FV extractRawJavaFieldValue(Object object); Object extractJavaFieldValue(Object object); Object extractJavaFieldToSqlArgValue(Object object); Object convertJavaFieldToSqlArgValue(Object fieldVal); Object convertStringToJavaField(String value, int columnPos); Object moveToNextValue(Object val); FieldType getForeignIdField(); FieldType getForeignRefField(); boolean isEscapedValue(); Enum<?> getUnknownEnumVal(); String getFormat(); boolean isUnique(); boolean isUniqueCombo(); String getIndexName(); String getUniqueIndexName(); boolean isEscapedDefaultValue(); boolean isComparable(); boolean isArgumentHolderRequired(); boolean isForeignCollection(); BaseForeignCollection<FT, FID> buildForeignCollection(Object parent, FID id); T resultToJava(DatabaseResults results, Map<String, Integer> columnPositions); boolean isSelfGeneratedId(); boolean isAllowGeneratedIdInsert(); String getColumnDefinition(); boolean isForeignAutoCreate(); boolean isVersion(); Object generateId(); boolean isReadOnly(); FV getFieldValueIfNotDefault(Object object); boolean isObjectsFieldValueDefault(Object object); Object getJavaDefaultValueDefault(); int createWithForeignDao(T foreignData); static FieldType createFieldType(ConnectionSource connectionSource, String tableName, Field field,
Class<?> parentClass); @Override boolean equals(Object arg); @Override int hashCode(); @Override String toString(); static final String FOREIGN_ID_FIELD_SUFFIX; }
|
@Test(expected = IllegalArgumentException.class) public void testUnknownFieldType() throws Exception { Field[] fields = UnknownFieldType.class.getDeclaredFields(); assertTrue(fields.length >= 1); FieldType.createFieldType(connectionSource, UnknownFieldType.class.getSimpleName(), fields[0], UnknownFieldType.class); }
@Test(expected = IllegalArgumentException.class) public void testIdAndGeneratedId() throws Exception { Field[] fields = IdAndGeneratedId.class.getDeclaredFields(); assertTrue(fields.length >= 1); FieldType.createFieldType(connectionSource, IdAndGeneratedId.class.getSimpleName(), fields[0], IdAndGeneratedId.class); }
@Test(expected = IllegalArgumentException.class) public void testGeneratedIdAndSequence() throws Exception { Field[] fields = GeneratedIdAndSequence.class.getDeclaredFields(); assertTrue(fields.length >= 1); FieldType.createFieldType(connectionSource, GeneratedIdAndSequence.class.getSimpleName(), fields[0], GeneratedIdAndSequence.class); }
@Test(expected = IllegalArgumentException.class) public void testGeneratedIdCantBeGenerated() throws Exception { Field[] fields = GeneratedIdCantBeGenerated.class.getDeclaredFields(); assertTrue(fields.length >= 1); FieldType.createFieldType(connectionSource, GeneratedIdCantBeGenerated.class.getSimpleName(), fields[0], GeneratedIdCantBeGenerated.class); }
@Test(expected = IllegalArgumentException.class) public void testPrimitiveForeign() throws Exception { Field[] fields = ForeignPrimitive.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field idField = fields[0]; FieldType.createFieldType(connectionSource, ForeignPrimitive.class.getSimpleName(), idField, ForeignPrimitive.class); }
@Test(expected = IllegalArgumentException.class) public void testForeignAlsoId() throws Exception { Field[] fields = ForeignAlsoId.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field fooField = fields[0]; FieldType.createFieldType(connectionSource, ForeignAlsoId.class.getSimpleName(), fooField, ForeignAlsoId.class); }
@Test(expected = IllegalArgumentException.class) public void testObjectFieldNotForeign() throws Exception { Field[] fields = ObjectFieldNotForeign.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field fooField = fields[0]; FieldType.createFieldType(connectionSource, ObjectFieldNotForeign.class.getSimpleName(), fooField, ObjectFieldNotForeign.class); }
@Test(expected = IllegalArgumentException.class) public void testGetSetNoGet() throws Exception { Field[] fields = GetSetNoGet.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field idField = fields[0]; FieldType.createFieldType(connectionSource, GetSetNoGet.class.getSimpleName(), idField, GetSetNoGet.class); }
@Test(expected = IllegalArgumentException.class) public void testGetSetGetWrongType() throws Exception { Field[] fields = GetSetGetWrongType.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field idField = fields[0]; FieldType.createFieldType(connectionSource, GetSetGetWrongType.class.getSimpleName(), idField, GetSetGetWrongType.class); }
@Test(expected = IllegalArgumentException.class) public void testGetSetNoSet() throws Exception { Field[] fields = GetSetNoSet.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field idField = fields[0]; FieldType.createFieldType(connectionSource, GetSetNoSet.class.getSimpleName(), idField, GetSetNoSet.class); }
@Test(expected = IllegalArgumentException.class) public void testGetSetSetWrongType() throws Exception { Field[] fields = GetSetSetWrongType.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field idField = fields[0]; FieldType.createFieldType(connectionSource, GetSetSetWrongType.class.getSimpleName(), idField, GetSetSetWrongType.class); }
@Test(expected = IllegalArgumentException.class) public void testGetSetSetReturnNotVoid() throws Exception { Field[] fields = GetSetReturnNotVoid.class.getDeclaredFields(); assertNotNull(fields); assertTrue(fields.length >= 1); Field idField = fields[0]; FieldType.createFieldType(connectionSource, GetSetReturnNotVoid.class.getSimpleName(), idField, GetSetReturnNotVoid.class); }
@Test public void testGetSet() throws Exception { Field[] fields = GetSet.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field idField = fields[0]; FieldType.createFieldType(connectionSource, GetSet.class.getSimpleName(), idField, GetSet.class); }
@Test public void testCreateFieldTypeNull() throws Exception { Field[] fields = NoAnnotation.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field idField = fields[0]; assertNull(FieldType.createFieldType(connectionSource, NoAnnotation.class.getSimpleName(), idField, NoAnnotation.class)); }
@Test(expected = SQLException.class) public void testGeneratedIdDefaultValue() throws Exception { Field[] fields = GeneratedIdDefault.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field idField = fields[0]; FieldType.createFieldType(connectionSource, GeneratedIdDefault.class.getSimpleName(), idField, GeneratedIdDefault.class); }
@Test(expected = SQLException.class) public void testThrowIfNullNotPrimitive() throws Exception { Field[] fields = ThrowIfNullNonPrimitive.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field field = fields[0]; FieldType.createFieldType(connectionSource, ThrowIfNullNonPrimitive.class.getSimpleName(), field, ThrowIfNullNonPrimitive.class); }
@Test(expected = SQLException.class) public void testBadDateDefaultValue() throws Exception { Field[] fields = DateDefaultBad.class.getDeclaredFields(); assertTrue(fields.length >= 1); Field field = fields[0]; FieldType.createFieldType(connectionSource, DateDefaultBad.class.getSimpleName(), field, DateDefaultBad.class); }
@Test(expected = IllegalArgumentException.class) public void testInvalidEnumField() throws Exception { Field field = InvalidEnumType.class.getDeclaredField("stuff"); FieldType.createFieldType(connectionSource, InvalidEnumType.class.getSimpleName(), field, InvalidEnumType.class); }
@Test public void testRecursiveForeign() throws Exception { Field field = Recursive.class.getDeclaredField("foreign"); FieldType.createFieldType(connectionSource, Recursive.class.getSimpleName(), field, Recursive.class); }
@Test(expected = SQLException.class) public void testSerializableNoDataType() throws Exception { Field field = SerializableNoDataType.class.getDeclaredField("serial"); FieldType.createFieldType(connectionSource, SerializableNoDataType.class.getSimpleName(), field, SerializableNoDataType.class); }
@Test(expected = SQLException.class) public void testByteArrayNoDataType() throws Exception { Field field = ByteArrayNoDataType.class.getDeclaredField("bytes"); FieldType.createFieldType(connectionSource, ByteArrayNoDataType.class.getSimpleName(), field, ByteArrayNoDataType.class); }
@Test(expected = SQLException.class) public void testForeignCollectionNoGeneric() throws Exception { Field field = ForeignCollectionNoGeneric.class.getDeclaredField("foreignStuff"); FieldType.createFieldType(connectionSource, ForeignCollectionNoGeneric.class.getSimpleName(), field, ForeignCollectionNoGeneric.class); }
@Test(expected = SQLException.class) public void testImproperId() throws Exception { Field field = ImproperIdType.class.getDeclaredField("id"); FieldType.createFieldType(connectionSource, ImproperIdType.class.getSimpleName(), field, ImproperIdType.class); }
@Test(expected = IllegalArgumentException.class) public void testAllowGeneratedIdInsertPrimitive() throws Exception { Field field = AllowGeneratedIdNotGeneratedId.class.getDeclaredField("stuff"); FieldType.createFieldType(connectionSource, AllowGeneratedIdNotGeneratedId.class.getSimpleName(), field, AllowGeneratedIdNotGeneratedId.class); }
@Test(expected = IllegalArgumentException.class) public void testVersionFieldWrongType() throws Exception { Field field = VersionFieldWrongType.class.getDeclaredField("version"); FieldType.createFieldType(connectionSource, AllowGeneratedIdNotGeneratedId.class.getSimpleName(), field, AllowGeneratedIdNotGeneratedId.class); }
|
FieldType { @Override public boolean equals(Object arg) { if (arg == null || arg.getClass() != this.getClass()) { return false; } FieldType other = (FieldType) arg; return field.equals(other.field) && (parentClass == null ? other.parentClass == null : parentClass.equals(other.parentClass)); } FieldType(ConnectionSource connectionSource, String tableName, Field field, DatabaseFieldConfig fieldConfig,
Class<?> parentClass); void configDaoInformation(ConnectionSource connectionSource, Class<?> parentClass); Field getField(); String getTableName(); String getFieldName(); Class<?> getType(); Type getGenericType(); String getColumnName(); DataPersister getDataPersister(); Object getDataTypeConfigObj(); SqlType getSqlType(); Object getDefaultValue(); int getWidth(); boolean isCanBeNull(); boolean isId(); boolean isGeneratedId(); boolean isGeneratedIdSequence(); String getGeneratedIdSequence(); boolean isForeign(); void assignField(Object data, Object val, boolean parentObject, ObjectCache objectCache); Object assignIdValue(Object data, Number val, ObjectCache objectCache); FV extractRawJavaFieldValue(Object object); Object extractJavaFieldValue(Object object); Object extractJavaFieldToSqlArgValue(Object object); Object convertJavaFieldToSqlArgValue(Object fieldVal); Object convertStringToJavaField(String value, int columnPos); Object moveToNextValue(Object val); FieldType getForeignIdField(); FieldType getForeignRefField(); boolean isEscapedValue(); Enum<?> getUnknownEnumVal(); String getFormat(); boolean isUnique(); boolean isUniqueCombo(); String getIndexName(); String getUniqueIndexName(); boolean isEscapedDefaultValue(); boolean isComparable(); boolean isArgumentHolderRequired(); boolean isForeignCollection(); BaseForeignCollection<FT, FID> buildForeignCollection(Object parent, FID id); T resultToJava(DatabaseResults results, Map<String, Integer> columnPositions); boolean isSelfGeneratedId(); boolean isAllowGeneratedIdInsert(); String getColumnDefinition(); boolean isForeignAutoCreate(); boolean isVersion(); Object generateId(); boolean isReadOnly(); FV getFieldValueIfNotDefault(Object object); boolean isObjectsFieldValueDefault(Object object); Object getJavaDefaultValueDefault(); int createWithForeignDao(T foreignData); static FieldType createFieldType(ConnectionSource connectionSource, String tableName, Field field,
Class<?> parentClass); @Override boolean equals(Object arg); @Override int hashCode(); @Override String toString(); static final String FOREIGN_ID_FIELD_SUFFIX; }
|
@Test public void testEquals() throws Exception { Field field1 = DefaultTypes.class.getDeclaredField("booleanField"); FieldType fieldType1 = FieldType.createFieldType(connectionSource, DefaultTypes.class.getSimpleName(), field1, DefaultTypes.class); FieldType fieldType2 = FieldType.createFieldType(connectionSource, DefaultTypes.class.getSimpleName(), field1, DefaultTypes.class); Field field2 = DefaultTypes.class.getDeclaredField("byteField"); FieldType fieldType3 = FieldType.createFieldType(connectionSource, DefaultTypes.class.getSimpleName(), field2, DefaultTypes.class); FieldType fieldType4 = FieldType.createFieldType(connectionSource, DefaultTypes.class.getSimpleName(), field2, DefaultTypes.class); assertTrue(fieldType1.equals(fieldType1)); assertTrue(fieldType2.equals(fieldType2)); assertTrue(fieldType1.equals(fieldType2)); assertTrue(fieldType2.equals(fieldType1)); assertEquals(fieldType1.hashCode(), fieldType2.hashCode()); assertFalse(fieldType1.equals(null)); assertFalse(fieldType1.equals(fieldType3)); assertFalse(fieldType1.equals(fieldType4)); assertFalse(fieldType3.equals(fieldType1)); assertFalse(fieldType4.equals(fieldType1)); assertTrue(fieldType3.equals(fieldType3)); assertTrue(fieldType4.equals(fieldType4)); assertTrue(fieldType3.equals(fieldType4)); assertTrue(fieldType4.equals(fieldType3)); assertEquals(fieldType3.hashCode(), fieldType4.hashCode()); }
|
DatabaseFieldConfigLoader { public static DatabaseFieldConfig fromReader(BufferedReader reader) throws SQLException { DatabaseFieldConfig config = new DatabaseFieldConfig(); boolean anything = false; while (true) { String line; try { line = reader.readLine(); } catch (IOException e) { throw SqlExceptionUtil.create("Could not read DatabaseFieldConfig from stream", e); } if (line == null) { break; } if (line.equals(CONFIG_FILE_END_MARKER)) { break; } if (line.length() == 0 || line.startsWith("#") || line.equals(CONFIG_FILE_START_MARKER)) { continue; } String[] parts = line.split("=", -2); if (parts.length != 2) { throw new SQLException("DatabaseFieldConfig reading from stream cannot parse line: " + line); } readField(config, parts[0], parts[1]); anything = true; } if (anything) { return config; } else { return null; } } static DatabaseFieldConfig fromReader(BufferedReader reader); static void write(BufferedWriter writer, DatabaseFieldConfig config, String tableName); static void writeConfig(BufferedWriter writer, DatabaseFieldConfig config, String tableName); }
|
@Test public void testEmptyFile() throws Exception { String value = ""; assertNull(DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value)))); }
@Test(expected = SQLException.class) public void testBadLine() throws Exception { String value = "not a good line"; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
@Test public void testBlankLine() throws Exception { String value = LINE_SEP; assertNull(DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value)))); }
@Test public void testComment() throws Exception { String value = "# some comment" + LINE_SEP; assertNull(DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value)))); }
@Test(expected = IllegalArgumentException.class) public void testBadPersisterClass() throws Exception { String value = "persisterClass=unknown class name" + LINE_SEP; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
@Test(expected = IllegalArgumentException.class) public void testBadEnumValue() throws Exception { String value = "unknownEnumValue=notvalidclass" + LINE_SEP; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
@Test(expected = IllegalArgumentException.class) public void testBadEnumClass() throws Exception { String value = "unknownEnumValue=notvalidclass#somevalue" + LINE_SEP; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
@Test(expected = IllegalArgumentException.class) public void testBadEnumClassNotAnEnum() throws Exception { String value = "unknownEnumValue=java.lang.Object#somevalue" + LINE_SEP; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
@Test(expected = IllegalArgumentException.class) public void testBadEnumClassInvalidEnumValue() throws Exception { String value = "unknownEnumValue=" + OurEnum.class.getName() + "#notvalid" + LINE_SEP; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
|
DateLongType extends BaseDateType { @Override public Object parseDefaultString(FieldType fieldType, String defaultStr) throws SQLException { try { return Long.parseLong(defaultStr); } catch (NumberFormatException e) { throw SqlExceptionUtil.create("Problems with field " + fieldType + " parsing default date-long value: " + defaultStr, e); } } private DateLongType(); protected DateLongType(SqlType sqlType, Class<?>[] classes); static DateLongType getSingleton(); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override Object javaToSqlArg(FieldType fieldType, Object obj); @Override boolean isEscapedValue(); @Override Class<?> getPrimaryClass(); }
|
@Test(expected = SQLException.class) public void testDateLongParseInvalid() throws Exception { FieldType fieldType = FieldType.createFieldType(connectionSource, TABLE_NAME, LocalDateLong.class.getDeclaredField(DATE_COLUMN), LocalDateLong.class); DataType.DATE_LONG.getDataPersister().parseDefaultString(fieldType, "not valid long number"); }
|
SerializableType extends BaseDataType { @Override public Object parseDefaultString(FieldType fieldType, String defaultStr) throws SQLException { throw new SQLException("Default values for serializable types are not supported"); } private SerializableType(); protected SerializableType(SqlType sqlType, Class<?>[] classes); static SerializableType getSingleton(); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override Object javaToSqlArg(FieldType fieldType, Object obj); @Override boolean isValidForField(Field field); @Override boolean isStreamType(); @Override boolean isComparable(); @Override boolean isAppropriateId(); @Override boolean isArgumentHolderRequired(); @Override Object resultStringToJava(FieldType fieldType, String stringValue, int columnPos); @Override Class<?> getPrimaryClass(); }
|
@Test(expected = SQLException.class) public void testSerializableParseDefault() throws Exception { DataType.SERIALIZABLE.getDataPersister().parseDefaultString(null, null); }
|
DateTimeType extends BaseDataType { @Override public Object javaToSqlArg(FieldType fieldType, Object javaObject) throws SQLException { return extractMillis(javaObject); } private DateTimeType(); protected DateTimeType(SqlType sqlType, Class<?>[] classes); static DateTimeType getSingleton(); @Override String[] getAssociatedClassNames(); @Override Object javaToSqlArg(FieldType fieldType, Object javaObject); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override boolean isEscapedValue(); @Override boolean isAppropriateId(); @Override Class<?> getPrimaryClass(); @Override boolean isValidForVersion(); @Override Object moveToNextValue(Object currentValue); }
|
@Test(expected = SQLException.class) public void testJavaToSqlArg() throws Exception { DateTimeType.getSingleton().javaToSqlArg(null, new Object()); }
|
DateTimeType extends BaseDataType { @Override public Object parseDefaultString(FieldType fieldType, String defaultStr) throws SQLException { try { return Long.parseLong(defaultStr); } catch (NumberFormatException e) { throw SqlExceptionUtil.create("Problems with field " + fieldType + " parsing default DateTime value: " + defaultStr, e); } } private DateTimeType(); protected DateTimeType(SqlType sqlType, Class<?>[] classes); static DateTimeType getSingleton(); @Override String[] getAssociatedClassNames(); @Override Object javaToSqlArg(FieldType fieldType, Object javaObject); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override boolean isEscapedValue(); @Override boolean isAppropriateId(); @Override Class<?> getPrimaryClass(); @Override boolean isValidForVersion(); @Override Object moveToNextValue(Object currentValue); }
|
@Test public void testParseDefaultString() throws SQLException { Long value = 423424234234L; assertEquals(value, DateTimeType.getSingleton().parseDefaultString(null, value.toString())); }
|
DateTimeType extends BaseDataType { @Override public Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos) throws SQLException { return results.getLong(columnPos); } private DateTimeType(); protected DateTimeType(SqlType sqlType, Class<?>[] classes); static DateTimeType getSingleton(); @Override String[] getAssociatedClassNames(); @Override Object javaToSqlArg(FieldType fieldType, Object javaObject); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override boolean isEscapedValue(); @Override boolean isAppropriateId(); @Override Class<?> getPrimaryClass(); @Override boolean isValidForVersion(); @Override Object moveToNextValue(Object currentValue); }
|
@Test(expected = SQLException.class) public void testResultToSqlArg() throws Exception { DatabaseResults results = createMock(DatabaseResults.class); int col = 21; long value = 2094234324L; expect(results.getLong(col)).andReturn(value); replay(results); DateTimeType.getSingleton().resultToJava(null, results, col); }
|
DateType extends BaseDateType { @Override public Object parseDefaultString(FieldType fieldType, String defaultStr) throws SQLException { DateStringFormatConfig dateFormatConfig = convertDateStringConfig(fieldType, getDefaultDateFormatConfig()); try { return new Timestamp(parseDateString(dateFormatConfig, defaultStr).getTime()); } catch (ParseException e) { throw SqlExceptionUtil.create("Problems parsing default date string '" + defaultStr + "' using '" + dateFormatConfig + '\'', e); } } private DateType(); protected DateType(SqlType sqlType, Class<?>[] classes); static DateType getSingleton(); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override Object javaToSqlArg(FieldType fieldType, Object javaObject); @Override boolean isArgumentHolderRequired(); }
|
@Test(expected = SQLException.class) public void testDateParseInvalid() throws Exception { FieldType fieldType = FieldType.createFieldType(connectionSource, TABLE_NAME, LocalDate.class.getDeclaredField(DATE_COLUMN), LocalDate.class); DataType.DATE.getDataPersister().parseDefaultString(fieldType, "not valid date string"); }
|
BaseDaoImpl implements Dao<T, ID> { public void initialize() throws SQLException { if (initialized) { return; } if (connectionSource == null) { throw new IllegalStateException("connectionSource was never set on " + getClass().getSimpleName()); } databaseType = connectionSource.getDatabaseType(); if (databaseType == null) { throw new IllegalStateException("connectionSource is getting a null DatabaseType in " + getClass().getSimpleName()); } if (tableConfig == null) { tableInfo = new TableInfo<T, ID>(connectionSource, this, dataClass); } else { tableConfig.extractFieldTypes(connectionSource); tableInfo = new TableInfo<T, ID>(databaseType, this, tableConfig); } statementExecutor = new StatementExecutor<T, ID>(databaseType, tableInfo, this); List<BaseDaoImpl<?, ?>> daoConfigList = daoConfigLevelLocal.get(); daoConfigList.add(this); if (daoConfigList.size() > 1) { return; } try { for (int i = 0; i < daoConfigList.size(); i++) { BaseDaoImpl<?, ?> dao = daoConfigList.get(i); DaoManager.registerDao(connectionSource, dao); try { for (FieldType fieldType : dao.getTableInfo().getFieldTypes()) { fieldType.configDaoInformation(connectionSource, dao.getDataClass()); } } catch (SQLException e) { DaoManager.unregisterDao(connectionSource, dao); throw e; } dao.initialized = true; } } finally { daoConfigList.clear(); daoConfigLevelLocal.remove(); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testDoubleInitialize() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(connectionSource, Foo.class) { }; dao.initialize(); dao.initialize(); }
@Test(expected = IllegalStateException.class) public void testInitNoConnectionSource() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(Foo.class) { }; dao.initialize(); }
@Test(expected = IllegalStateException.class) public void testNoDatabaseType() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(Foo.class) { }; dao.initialize(); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public int create(T data) throws SQLException { checkForInitialized(); if (data == null) { return 0; } if (data instanceof BaseDaoEnabled) { @SuppressWarnings("unchecked") BaseDaoEnabled<T, ID> daoEnabled = (BaseDaoEnabled<T, ID>) data; daoEnabled.setDao(this); } DatabaseConnection connection = connectionSource.getReadWriteConnection(tableInfo.getTableName()); try { return statementExecutor.create(connection, data, objectCache); } finally { connectionSource.releaseConnection(connection); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testCreate() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo = new Foo(); int equal = 21313; foo.equal = equal; assertEquals(1, dao.create(foo)); Foo result = dao.queryForId(foo.id); assertNotNull(result); assertEquals(equal, result.equal); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public int update(T data) throws SQLException { checkForInitialized(); if (data == null) { return 0; } if (data instanceof BaseDaoEnabled) { @SuppressWarnings("unchecked") BaseDaoEnabled<T, ID> daoEnabled = (BaseDaoEnabled<T, ID>) data; daoEnabled.setDao(this); } DatabaseConnection connection = connectionSource.getReadWriteConnection(tableInfo.getTableName()); try { return statementExecutor.update(connection, data, objectCache); } finally { connectionSource.releaseConnection(connection); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testUpdate() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo = new Foo(); assertEquals(1, dao.create(foo)); foo.equal = 1; assertEquals(1, dao.update(foo)); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public int updateId(T data, ID newId) throws SQLException { checkForInitialized(); if (data == null) { return 0; } else { DatabaseConnection connection = connectionSource.getReadWriteConnection(tableInfo.getTableName()); try { return statementExecutor.updateId(connection, data, newId, objectCache); } finally { connectionSource.releaseConnection(connection); } } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testUpdateId() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo = new Foo(); assertEquals(1, dao.create(foo)); int id = foo.id; assertNotNull(dao.queryForId(id)); assertNull(dao.queryForId(id + 1)); assertEquals(1, dao.updateId(foo, id + 1)); assertNull(dao.queryForId(id)); assertNotNull(dao.queryForId(id + 1)); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public int delete(T data) throws SQLException { checkForInitialized(); if (data == null) { return 0; } else { DatabaseConnection connection = connectionSource.getReadWriteConnection(tableInfo.getTableName()); try { return statementExecutor.delete(connection, data, objectCache); } finally { connectionSource.releaseConnection(connection); } } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testDelete() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo = new Foo(); assertEquals(1, dao.create(foo)); assertNotNull(dao.queryForId(foo.id)); assertEquals(1, dao.delete(foo)); assertNull(dao.queryForId(foo.id)); assertEquals(0, dao.queryForAll().size()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public int deleteById(ID id) throws SQLException { checkForInitialized(); if (id == null) { return 0; } else { DatabaseConnection connection = connectionSource.getReadWriteConnection(tableInfo.getTableName()); try { return statementExecutor.deleteById(connection, id, objectCache); } finally { connectionSource.releaseConnection(connection); } } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testDeleteById() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo = new Foo(); assertEquals(1, dao.create(foo)); assertNotNull(dao.queryForId(foo.id)); assertEquals(1, dao.deleteById(foo.id)); assertNull(dao.queryForId(foo.id)); assertEquals(0, dao.queryForAll().size()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public int deleteIds(Collection<ID> ids) throws SQLException { checkForInitialized(); if (ids == null || ids.isEmpty()) { return 0; } else { DatabaseConnection connection = connectionSource.getReadWriteConnection(tableInfo.getTableName()); try { return statementExecutor.deleteIds(connection, ids, objectCache); } finally { connectionSource.releaseConnection(connection); } } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testDeleteIds() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); assertEquals(1, dao.create(foo2)); assertNotNull(dao.queryForId(foo1.id)); assertNotNull(dao.queryForId(foo2.id)); List<Integer> ids = new ArrayList<Integer>(); ids.add(foo1.id); ids.add(foo2.id); assertEquals(2, dao.deleteIds(ids)); assertEquals(0, dao.queryForAll().size()); assertNull(dao.queryForId(foo1.id)); assertNull(dao.queryForId(foo2.id)); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public int refresh(T data) throws SQLException { checkForInitialized(); if (data == null) { return 0; } if (data instanceof BaseDaoEnabled) { @SuppressWarnings("unchecked") BaseDaoEnabled<T, ID> daoEnabled = (BaseDaoEnabled<T, ID>) data; daoEnabled.setDao(this); } DatabaseConnection connection = connectionSource.getReadOnlyConnection(tableInfo.getTableName()); try { return statementExecutor.refresh(connection, data, objectCache); } finally { connectionSource.releaseConnection(connection); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testRefresh() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo = new Foo(); int equal1 = 11312331; foo.equal = equal1; assertEquals(1, dao.create(foo)); int equal2 = 312312; assertNotNull(dao.queryForId(foo.id)); UpdateBuilder<Foo, Integer> updateBuilder = dao.updateBuilder(); updateBuilder.updateColumnValue(Foo.EQUAL_COLUMN_NAME, equal2); updateBuilder.where().eq(Foo.ID_COLUMN_NAME, foo.id); assertEquals(1, dao.update(updateBuilder.prepare())); assertEquals(equal1, foo.equal); assertEquals(1, dao.refresh(foo)); assertEquals(equal2, foo.equal); }
|
BindingParameter { public String getFullName() { return Strings.getFullName(parameterName, propertyPath); } BindingParameter(String parameterName, String propertyPath, JdbcType jdbcType); static BindingParameter create(String parameterName, String propertyPath, JdbcType jdbcType); BindingParameter rightShift(); String getParameterName(); String getPropertyPath(); JdbcType getJdbcType(); String getFullName(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }
|
@Test public void testGetFullName() throws Exception { BindingParameter bp = BindingParameter.create("a", "b", null); assertThat(bp.getFullName(), equalTo(":a.b")); bp = BindingParameter.create("a", "", null); assertThat(bp.getFullName(), equalTo(":a")); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public T queryForId(ID id) throws SQLException { checkForInitialized(); DatabaseConnection connection = connectionSource.getReadOnlyConnection(tableInfo.getTableName()); try { return statementExecutor.queryForId(connection, id, objectCache); } finally { connectionSource.releaseConnection(connection); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test(expected = IllegalStateException.class) public void testQueryForIdNoInit() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(Foo.class) { }; dao.queryForId(1); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public T queryForFirst(PreparedQuery<T> preparedQuery) throws SQLException { checkForInitialized(); DatabaseConnection connection = connectionSource.getReadOnlyConnection(tableInfo.getTableName()); try { return statementExecutor.queryForFirst(connection, preparedQuery, objectCache); } finally { connectionSource.releaseConnection(connection); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testQueryForFirst() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); assertEquals(1, dao.create(foo2)); assertNotNull(dao.queryForId(foo1.id)); assertNotNull(dao.queryForId(foo2.id)); assertEquals(2, dao.queryForAll().size()); Foo foo3 = dao.queryForFirst(dao.queryBuilder().prepare()); assertNotNull(foo2); assertEquals(foo1.id, foo3.id); }
@Test(expected = IllegalStateException.class) public void testQueryForFirstNoInit() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(Foo.class) { }; dao.queryForFirst(null); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public QueryBuilder<T, ID> queryBuilder() { checkForInitialized(); return new QueryBuilder<T, ID>(databaseType, tableInfo, this); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test(expected = IllegalStateException.class) public void testStatementBuilderNoInit() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(Foo.class) { }; dao.queryBuilder(); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public List<T> query(PreparedQuery<T> preparedQuery) throws SQLException { checkForInitialized(); return statementExecutor.query(connectionSource, preparedQuery, objectCache); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test(expected = IllegalStateException.class) public void testQueryForPreparedNoInit() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(Foo.class) { }; dao.query((PreparedQuery<Foo>) null); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public String objectToString(T data) { checkForInitialized(); return tableInfo.objectToString(data); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testObjectToString() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(connectionSource, Foo.class) { }; dao.initialize(); Foo foo = new Foo(); String objStr = dao.objectToString(foo); assertTrue(objStr.contains("id=" + foo.id)); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public boolean objectsEqual(T data1, T data2) throws SQLException { checkForInitialized(); for (FieldType fieldType : tableInfo.getFieldTypes()) { Object fieldObj1 = fieldType.extractJavaFieldValue(data1); Object fieldObj2 = fieldType.extractJavaFieldValue(data2); if (!fieldType.getDataPersister().dataIsEqual(fieldObj1, fieldObj2)) { return false; } } return true; } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testObjectsEqual() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(connectionSource, Foo.class) { }; dao.initialize(); Foo foo = new Foo(); foo.id = 121134243; foo.val = 123123; Foo bar = new Foo(); assertTrue(dao.objectsEqual(foo, foo)); assertFalse(dao.objectsEqual(foo, bar)); assertFalse(dao.objectsEqual(bar, foo)); assertTrue(dao.objectsEqual(bar, bar)); bar.id = foo.id + 1; bar.val = foo.val; assertFalse(dao.objectsEqual(bar, foo)); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public CloseableIterator<T> iterator() { return iterator(DatabaseConnection.DEFAULT_RESULT_FLAGS); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testIterator() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); int equal1 = 1231231232; foo1.equal = equal1; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); int equal2 = 1231232; foo2.equal = equal2; assertEquals(1, dao.create(foo2)); CloseableIterator<Foo> iterator = dao.iterator(); assertTrue(iterator.hasNext()); Foo foo3 = iterator.next(); assertEquals(foo1.id, foo3.id); assertTrue(iterator.hasNext()); foo3 = iterator.next(); assertEquals(foo2.id, foo3.id); assertFalse(iterator.hasNext()); iterator.close(); }
@Test(expected = IllegalStateException.class) public void testIteratorNoInit() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(Foo.class) { }; dao.iterator(); }
@Test(expected = IllegalStateException.class) public void testIteratorPreparedNoInit() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(Foo.class) { }; dao.iterator((PreparedQuery<Foo>) null); }
|
BindingParameter { @Override public boolean equals(Object obj) { if (obj == null) return false; if (getClass() != obj.getClass()) return false; final BindingParameter other = (BindingParameter) obj; return Objects.equal(this.getParameterName(), other.getParameterName()) && Objects.equal(this.getPropertyPath(), other.getPropertyPath()) && Objects.equal(this.getJdbcType(), other.getJdbcType()); } BindingParameter(String parameterName, String propertyPath, JdbcType jdbcType); static BindingParameter create(String parameterName, String propertyPath, JdbcType jdbcType); BindingParameter rightShift(); String getParameterName(); String getPropertyPath(); JdbcType getJdbcType(); String getFullName(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }
|
@Test public void testEquals() throws Exception { BindingParameter bp = BindingParameter.create("a", "b", null); BindingParameter bp2 = BindingParameter.create("a", "b", null); assertThat(bp.equals(bp2), equalTo(true)); assertThat(bp.equals(null), equalTo(false)); assertThat(bp.equals(new Object()), equalTo(false)); }
|
BaseDaoImpl implements Dao<T, ID> { public DatabaseTableConfig<T> getTableConfig() { return tableConfig; } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testTableConfig() throws Exception { DatabaseTableConfig<Foo> config = DatabaseTableConfig.fromClass(connectionSource, Foo.class); BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(connectionSource, config) { }; assertSame(config, dao.getTableConfig()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public boolean isUpdatable() { return tableInfo.isUpdatable(); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testIsUpdatable() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, false); assertTrue(dao.isUpdatable()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public boolean isTableExists() throws SQLException { checkForInitialized(); DatabaseConnection connection = connectionSource.getReadOnlyConnection(tableInfo.getTableName()); try { return connection.isTableExists(tableInfo.getTableName()); } finally { connectionSource.releaseConnection(connection); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testIsTableExists() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, false); assertFalse(dao.isTableExists()); TableUtils.createTable(connectionSource, Foo.class); assertTrue(dao.isTableExists()); TableUtils.dropTable(connectionSource, Foo.class, true); assertFalse(dao.isTableExists()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public UpdateBuilder<T, ID> updateBuilder() { checkForInitialized(); return new UpdateBuilder<T, ID>(databaseType, tableInfo, this); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testUpdateBuilder() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(connectionSource, Foo.class) { }; dao.updateBuilder(); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public DeleteBuilder<T, ID> deleteBuilder() { checkForInitialized(); return new DeleteBuilder<T, ID>(databaseType, tableInfo, this); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testDeleteBuilder() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(connectionSource, Foo.class) { }; dao.deleteBuilder(); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public Class<T> getDataClass() { return dataClass; } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testDataClass() throws Exception { BaseDaoImpl<Foo, Integer> dao = new BaseDaoImpl<Foo, Integer>(Foo.class) { }; assertEquals(Foo.class, dao.getDataClass()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public int updateRaw(String statement, String... arguments) throws SQLException { checkForInitialized(); DatabaseConnection connection = connectionSource.getReadWriteConnection(tableInfo.getTableName()); try { return statementExecutor.updateRaw(connection, statement, arguments); } catch (SQLException e) { throw SqlExceptionUtil.create("Could not run raw update statement " + statement, e); } finally { connectionSource.releaseConnection(connection); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testUpdateRaw() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); assertEquals(1, dao.create(foo2)); assertEquals(2, dao.queryForAll().size()); dao.updateRaw("DELETE FROM FOO WHERE " + Foo.ID_COLUMN_NAME + " = ?", Integer.toString(foo1.id)); assertEquals(1, dao.queryForAll().size()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public int executeRaw(String statement, String... arguments) throws SQLException { checkForInitialized(); DatabaseConnection connection = connectionSource.getReadWriteConnection(tableInfo.getTableName()); try { return statementExecutor.executeRaw(connection, statement, arguments); } catch (SQLException e) { throw SqlExceptionUtil.create("Could not run raw execute statement " + statement, e); } finally { connectionSource.releaseConnection(connection); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testExecuteRaw() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); assertEquals(1, dao.create(foo2)); assertEquals(2, dao.queryForAll().size()); dao.executeRaw("TRUNCATE TABLE FOO"); assertEquals(0, dao.queryForAll().size()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public ID extractId(T data) throws SQLException { checkForInitialized(); FieldType idField = tableInfo.getIdField(); if (idField == null) { throw new SQLException("Class " + dataClass + " does not have an id field"); } @SuppressWarnings("unchecked") ID id = (ID) idField.extractJavaFieldValue(data); return id; } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testExtractId() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo = new Foo(); assertEquals((Integer) foo.id, dao.extractId(foo)); }
|
FunctionalBindingParameterInvoker implements BindingParameterInvoker { public static FunctionalBindingParameterInvoker create( Type originalType, BindingParameter bindingParameter) { try { FunctionalBindingParameterInvoker invokerGroup = new FunctionalBindingParameterInvoker(originalType, bindingParameter); return invokerGroup; } catch (UnreachablePropertyException e) { throw new BindingException("Parameter '" + bindingParameter + "' can't be readable", e); } } private FunctionalBindingParameterInvoker(Type originalType, BindingParameter bindingParameter); static FunctionalBindingParameterInvoker create(
Type originalType, BindingParameter bindingParameter); @Override Type getTargetType(); @Override Object invoke(Object obj); @Override BindingParameter getBindingParameter(); }
|
@Test public void testBindingException4() throws Exception { thrown.expect(BindingException.class); thrown.expectMessage("Parameter ':user.userBag.ite' can't be readable; " + "caused by: There is no getter/setter for property named 'ite' in 'class org.jfaster.mango.binding.FunctionalBindingParameterInvokerTest$UserBag'"); FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("user", "userBag.ite", null)); }
|
BeanUtil { public static List<PropertyMeta> fetchPropertyMetas(Class<?> clazz) { return cache.get(clazz); } static List<PropertyMeta> fetchPropertyMetas(Class<?> clazz); }
|
@Test public void fetchPropertyMetas() throws Exception { Set<PropertyMeta> pms = Sets.newHashSet(BeanUtil.fetchPropertyMetas(A.class)); Set<PropertyMeta> set = Sets.newHashSet(); set.add(getPropertyMeta(A.class, "id", int.class)); set.add(getPropertyMeta(A.class, "uid", int.class)); set.add(getPropertyMeta(A.class, "name", String.class)); assertThat(pms, equalTo(set)); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public long countOf() throws SQLException { checkForInitialized(); DatabaseConnection connection = connectionSource.getReadOnlyConnection(tableInfo.getTableName()); try { return statementExecutor.queryForCountStar(connection); } finally { connectionSource.releaseConnection(connection); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testCountOf() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); assertEquals(0, dao.countOf()); Foo foo = new Foo(); assertEquals(1, dao.create(foo)); assertEquals(1, dao.countOf()); assertEquals(1, dao.create(foo)); assertEquals(2, dao.countOf()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public List<T> queryForEq(String fieldName, Object value) throws SQLException { return queryBuilder().where().eq(fieldName, value).query(); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testQueryForEq() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); assertEquals(0, dao.countOf()); Foo foo1 = new Foo(); foo1.val = 1231231; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = foo1.val + 1; assertEquals(1, dao.create(foo2)); List<Foo> results = dao.queryForEq(Foo.VAL_COLUMN_NAME, foo1.val); assertEquals(1, results.size()); assertEquals(foo1.id, results.get(0).id); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public List<T> queryForMatching(T matchObj) throws SQLException { return queryForMatching(matchObj, false); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testQueryForMatching() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); assertEquals(0, dao.countOf()); Foo foo1 = new Foo(); int val = 1231231; foo1.val = val; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = val + 1; assertEquals(1, dao.create(foo2)); Foo match = new Foo(); match.val = val; List<Foo> results = dao.queryForMatching(match); assertEquals(1, results.size()); assertEquals(foo1.id, results.get(0).id); match = new Foo(); match.id = foo2.id; match.val = val; results = dao.queryForMatching(match); assertEquals(0, results.size()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public List<T> queryForMatchingArgs(T matchObj) throws SQLException { return queryForMatching(matchObj, true); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testQueryForMatchingArgs() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); assertEquals(0, dao.countOf()); Foo foo1 = new Foo(); int val = 1231231; foo1.val = val; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = val + 1; assertEquals(1, dao.create(foo2)); Foo match = new Foo(); match.stringField = "this id has a quote '"; List<Foo> results = dao.queryForMatchingArgs(match); assertEquals(0, results.size()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public List<T> queryForFieldValues(Map<String, Object> fieldValues) throws SQLException { return queryForFieldValues(fieldValues, false); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testQueryForFieldValues() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); assertEquals(0, dao.countOf()); Foo foo1 = new Foo(); foo1.val = 1231231; assertEquals(1, dao.create(foo1)); Foo foo2 = new Foo(); foo2.val = foo1.val + 1; assertEquals(1, dao.create(foo2)); Map<String, Object> fieldValues = new HashMap<String, Object>(); fieldValues.put(Foo.VAL_COLUMN_NAME, foo1.val); List<Foo> results = dao.queryForFieldValues(fieldValues); assertEquals(1, results.size()); assertEquals(foo1.id, results.get(0).id); fieldValues.put(Foo.ID_COLUMN_NAME, foo2.id); fieldValues.put(Foo.VAL_COLUMN_NAME, foo1.val); results = dao.queryForFieldValues(fieldValues); assertEquals(0, results.size()); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues) throws SQLException { return queryForFieldValues(fieldValues, true); } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testQueryForFieldValuesArgs() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Map<String, Object> fieldValues = new HashMap<String, Object>(); fieldValues.put(Foo.STRING_COLUMN_NAME, "this id has a quote '"); dao.queryForFieldValuesArgs(fieldValues); }
|
BaseDaoImpl implements Dao<T, ID> { static <T, ID> Dao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz) throws SQLException { return new BaseDaoImpl<T, ID>(connectionSource, clazz) { }; } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testForeignCollectionAutoRefresh() throws Exception { createDao(ForeignCollectionAutoRefresh.class, false); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public CreateOrUpdateStatus createOrUpdate(T data) throws SQLException { if (data == null) { return new CreateOrUpdateStatus(false, false, 0); } ID id = extractId(data); if (id == null || !idExists(id)) { int numRows = create(data); return new CreateOrUpdateStatus(true, false, numRows); } else { int numRows = update(data); return new CreateOrUpdateStatus(false, true, numRows); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testCreateOrUpdate() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); int equal1 = 21313; foo1.equal = equal1; CreateOrUpdateStatus status = dao.createOrUpdate(foo1); assertTrue(status.isCreated()); assertFalse(status.isUpdated()); assertEquals(1, status.getNumLinesChanged()); int equal2 = 4134132; foo1.equal = equal2; status = dao.createOrUpdate(foo1); assertFalse(status.isCreated()); assertTrue(status.isUpdated()); assertEquals(1, status.getNumLinesChanged()); Foo fooResult = dao.queryForId(foo1.id); assertEquals(equal2, fooResult.equal); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public T queryForSameId(T data) throws SQLException { checkForInitialized(); if (data == null) { return null; } ID id = extractId(data); if (id == null) { return null; } else { return queryForId(id); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testQueryForSameId() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); foo1.equal = 198412893; assertEquals(1, dao.create(foo1)); Foo fooResult = dao.queryForSameId(foo1); assertEquals(foo1.id, fooResult.id); assertEquals(foo1.equal, fooResult.equal); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public T createIfNotExists(T data) throws SQLException { if (data == null) { return null; } T existing = queryForSameId(data); if (existing == null) { create(data); return data; } else { return existing; } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testCreateIfNotExists() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); Foo foo1 = new Foo(); foo1.equal = 198412893; Foo fooResult = dao.createIfNotExists(foo1); assertSame(foo1, fooResult); fooResult = dao.createIfNotExists(foo1); assertNotSame(foo1, fooResult); assertEquals(foo1.id, fooResult.id); assertEquals(foo1.equal, fooResult.equal); }
|
InvocationContextFactory { public InvocationContext newInvocationContext(Object[] values) { InvocationContext context = DefaultInvocationContext.create(); for (int i = 0; i < values.length; i++) { String parameterName = parameterContext.getParameterNameByPosition(i); context.addParameter(parameterName, values[i]); } return context; } private InvocationContextFactory(ParameterContext parameterContext); static InvocationContextFactory create(ParameterContext parameterContext); InvocationContext newInvocationContext(Object[] values); }
|
@Test public void testNewInvocationContext() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "name"); ParameterDescriptor p1 = ParameterDescriptor.create(1, int.class, empty, "id"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext paramCtx = DefaultParameterContext.create(pds); InvocationContextFactory factory = InvocationContextFactory.create(paramCtx); InvocationContext invCtx = factory.newInvocationContext(new Object[]{"ash", 9527}); BindingParameterInvoker nameInvoker = FunctionalBindingParameterInvoker.create(String.class, BindingParameter.create("name", "", null)); BindingParameterInvoker idInvoker = FunctionalBindingParameterInvoker.create(String.class, BindingParameter.create("id", "", null)); assertThat(invCtx.getNullableBindingValue(nameInvoker), equalTo((Object) "ash")); assertThat(invCtx.getNullableBindingValue(idInvoker), equalTo((Object) 9527)); }
|
BaseDaoImpl implements Dao<T, ID> { @Override public long queryRawValue(String query, String... arguments) throws SQLException { checkForInitialized(); DatabaseConnection connection = connectionSource.getReadOnlyConnection(tableInfo.getTableName()); try { return statementExecutor.queryForLong(connection, query, arguments); } catch (SQLException e) { throw SqlExceptionUtil.create("Could not perform raw value query for " + query, e); } finally { connectionSource.releaseConnection(connection); } } protected BaseDaoImpl(Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass); protected BaseDaoImpl(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); private BaseDaoImpl(ConnectionSource connectionSource, Class<T> dataClass, DatabaseTableConfig<T> tableConfig); void initialize(); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override int create(T data); @Override int create(final Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(final PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override GenericRawResults<GR> queryRaw(String query, RawRowMapper<GR> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override void setObjectCache(ObjectCache objectCache); @Override ObjectCache getObjectCache(); @Override void clearObjectCache(); synchronized static void clearAllInternalObjectCaches(); @Override T mapSelectStarRow(DatabaseResults results); @Override void notifyChanges(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override RawRowMapper<T> getRawRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); ObjectFactory<T> getObjectFactory(); @Override void setObjectFactory(ObjectFactory<T> objectFactory); DatabaseTableConfig<T> getTableConfig(); TableInfo<T, ID> getTableInfo(); @Override ConnectionSource getConnectionSource(); void setConnectionSource(ConnectionSource connectionSource); void setTableConfig(DatabaseTableConfig<T> tableConfig); @Override String getTableName(); }
|
@Test public void testQueryRawValue() throws Exception { Dao<Foo, Object> dao = createDao(Foo.class, true); assertEquals(1, dao.create(new Foo())); assertEquals(1, dao.queryRawValue("select max(" + Foo.ID_COLUMN_NAME + ") from foo")); assertEquals(1, dao.create(new Foo())); assertEquals(2, dao.queryRawValue("select max(" + Foo.ID_COLUMN_NAME + ") from foo")); assertEquals(1, dao.create(new Foo())); assertEquals(3, dao.queryRawValue("select max(" + Foo.ID_COLUMN_NAME + ") from foo")); }
|
LruObjectCache implements ObjectCache { @Override public <T> int size(Class<T> clazz) { Map<Object, Object> objectMap = getMapForClass(clazz); if (objectMap == null) { return 0; } else { return objectMap.size(); } } LruObjectCache(int capacity); @Override synchronized void registerClass(Class<T> clazz); @Override T get(Class<T> clazz, ID id); @Override void put(Class<T> clazz, ID id, T data); @Override void clear(Class<T> clazz); @Override void clearAll(); @Override void remove(Class<T> clazz, ID id); @Override T updateId(Class<T> clazz, ID oldId, ID newId); @Override int size(Class<T> clazz); @Override int sizeAll(); }
|
@Test public void testStuff() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); LruObjectCache cache = new LruObjectCache(2); dao.setObjectCache(cache); Foo foo1 = new Foo(); int val = 12312321; foo1.val = val; assertEquals(1, dao.create(foo1)); assertEquals(1, cache.size(Foo.class)); Foo result = dao.queryForId(foo1.id); assertSame(foo1, result); Foo foo2 = new Foo(); int val2 = 21234761; foo2.val = val2; assertEquals(1, dao.create(foo2)); assertEquals(2, cache.size(Foo.class)); result = dao.queryForId(foo2.id); assertSame(foo2, result); result = dao.queryForId(foo2.id); assertSame(foo2, result); Foo foo3 = new Foo(); int val3 = 79834761; foo3.val = val3; assertEquals(1, dao.create(foo3)); assertEquals(2, cache.size(Foo.class)); result = dao.queryForId(foo1.id); assertNotSame(foo1, result); foo1 = result; result = dao.queryForId(foo2.id); assertNotSame(foo2, result); foo2 = result; result = dao.queryForId(foo1.id); assertSame(foo1, result); result = dao.queryForId(foo2.id); assertSame(foo2, result); }
|
LruObjectCache implements ObjectCache { @Override public <T> void clear(Class<T> clazz) { Map<Object, Object> objectMap = getMapForClass(clazz); if (objectMap != null) { objectMap.clear(); } } LruObjectCache(int capacity); @Override synchronized void registerClass(Class<T> clazz); @Override T get(Class<T> clazz, ID id); @Override void put(Class<T> clazz, ID id, T data); @Override void clear(Class<T> clazz); @Override void clearAll(); @Override void remove(Class<T> clazz, ID id); @Override T updateId(Class<T> clazz, ID oldId, ID newId); @Override int size(Class<T> clazz); @Override int sizeAll(); }
|
@Test public void testClear() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); LruObjectCache cache = new LruObjectCache(2); dao.setObjectCache(cache); Foo foo = new Foo(); int val = 12312321; foo.val = val; assertEquals(1, dao.create(foo)); assertEquals(1, cache.size(Foo.class)); Foo result = dao.queryForId(foo.id); assertSame(foo, result); dao.clearObjectCache(); result = dao.queryForId(foo.id); assertNotSame(foo, result); }
|
EagerForeignCollection extends BaseForeignCollection<T, ID> implements CloseableWrappedIterable<T>,
Serializable { @Override public boolean contains(Object o) { return results.contains(o); } EagerForeignCollection(Dao<T, ID> dao, Object parent, Object parentId, FieldType foreignFieldType,
String orderColumn, boolean orderAscending); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> iterator(int flags); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> closeableIterator(int flags); @Override CloseableIterator<T> iteratorThrow(); @Override CloseableIterator<T> iteratorThrow(int flags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(int flags); @Override void close(); @Override void closeLastIterator(); @Override boolean isEager(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override Object[] toArray(); @Override E[] toArray(E[] array); @Override boolean add(T data); @Override boolean addAll(Collection<? extends T> collection); @Override boolean remove(Object data); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override int updateAll(); @Override int refreshAll(); @Override int refreshCollection(); @Override boolean equals(Object obj); @Override int hashCode(); }
|
@Test public void testContains() throws Exception { Dao<Eager, Integer> eagerDao = createDao(Eager.class, true); Dao<Foreign, Integer> foreignDao = createDao(Foreign.class, true); Eager eager = new Eager(); assertEquals(1, eagerDao.create(eager)); Foreign f0 = new Foreign(); f0.eager = eager; assertEquals(1, foreignDao.create(f0)); Foreign f1 = new Foreign(); f1.eager = eager; assertEquals(1, foreignDao.create(f1)); Eager result = eagerDao.queryForId(eager.id); for (Foreign foreign : result.foreignCollection) { assertTrue(result.foreignCollection.contains(foreign)); } }
|
DaoManager { public synchronized static <D extends Dao<T, ?>, T> D createDao(ConnectionSource connectionSource, Class<T> clazz) throws SQLException { if (connectionSource == null) { throw new IllegalArgumentException("connectionSource argument cannot be null"); } ClassConnectionSource key = new ClassConnectionSource(connectionSource, clazz); Dao<?, ?> dao = lookupDao(key); if (dao != null) { @SuppressWarnings("unchecked") D castDao = (D) dao; return castDao; } dao = createDaoFromConfig(connectionSource, clazz); if (dao != null) { @SuppressWarnings("unchecked") D castDao = (D) dao; return castDao; } DatabaseTable databaseTable = clazz.getAnnotation(DatabaseTable.class); if (databaseTable == null || databaseTable.daoClass() == Void.class || databaseTable.daoClass() == BaseDaoImpl.class) { DatabaseType databaseType = connectionSource.getDatabaseType(); DatabaseTableConfig<T> config = databaseType.extractDatabaseTableConfig(connectionSource, clazz); Dao<T, ?> daoTmp; if (config == null) { daoTmp = BaseDaoImpl.createDao(connectionSource, clazz); } else { daoTmp = BaseDaoImpl.createDao(connectionSource, config); } dao = daoTmp; logger.debug("created dao for class {} with reflection", clazz); } else { Class<?> daoClass = databaseTable.daoClass(); Object[] arguments = new Object[] { connectionSource, clazz }; Constructor<?> daoConstructor = findConstructor(daoClass, arguments); if (daoConstructor == null) { arguments = new Object[] { connectionSource }; daoConstructor = findConstructor(daoClass, arguments); if (daoConstructor == null) { throw new SQLException( "Could not find public constructor with ConnectionSource and optional Class parameters " + daoClass + ". Missing static on class?"); } } try { dao = (Dao<?, ?>) daoConstructor.newInstance(arguments); logger.debug("created dao for class {} from constructor", clazz); } catch (Exception e) { throw SqlExceptionUtil.create("Could not call the constructor in class " + daoClass, e); } } registerDao(connectionSource, dao); @SuppressWarnings("unchecked") D castDao = (D) dao; return castDao; } synchronized static D createDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D lookupDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); synchronized static D lookupDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void unregisterDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void registerDaoWithTableConfig(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void clearCache(); static synchronized void clearDaoCache(); static synchronized void addCachedDatabaseConfigs(Collection<DatabaseTableConfig<?>> configs); }
|
@Test(expected = IllegalArgumentException.class) public void testCreateDaoNull() throws Exception { DaoManager.createDao(null, Foo.class); }
@Test(expected = IllegalArgumentException.class) public void testCreateDaoTableNull() throws Exception { DaoManager.createDao(null, new DatabaseTableConfig<Foo>()); }
@Test public void testDaoClassGenericDaoMethod() throws Exception { GenericDao<GenericBaz, String> bazdao = DaoManager.createDao(connectionSource, GenericBaz.class); assertSame(GenericBaz.class.getName(), bazdao.doGenericAction()); GenericDao<GenericBar, Void> bardao = DaoManager.createDao(connectionSource, GenericBar.class); assertSame(GenericBar.class.getName(), bardao.doGenericAction()); }
|
DaoManager { public synchronized static <D extends Dao<T, ?>, T> D lookupDao(ConnectionSource connectionSource, Class<T> clazz) { if (connectionSource == null) { throw new IllegalArgumentException("connectionSource argument cannot be null"); } ClassConnectionSource key = new ClassConnectionSource(connectionSource, clazz); Dao<?, ?> dao = lookupDao(key); @SuppressWarnings("unchecked") D castDao = (D) dao; return castDao; } synchronized static D createDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D lookupDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); synchronized static D lookupDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void unregisterDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void registerDaoWithTableConfig(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void clearCache(); static synchronized void clearDaoCache(); static synchronized void addCachedDatabaseConfigs(Collection<DatabaseTableConfig<?>> configs); }
|
@Test(expected = IllegalArgumentException.class) public void testLookupDaoNull() { DaoManager.lookupDao(null, Foo.class); }
@Test public void testLookupDaoUnknown() { assertNull(DaoManager.lookupDao(connectionSource, getClass())); }
@Test(expected = IllegalArgumentException.class) public void testLookupDaoTableNull() { DaoManager.lookupDao(null, new DatabaseTableConfig<Foo>()); }
@Test public void testLookupTableDaoUnknown() { assertNull(DaoManager.lookupDao(connectionSource, new DatabaseTableConfig<DaoManagerTest>(DaoManagerTest.class, new ArrayList<DatabaseFieldConfig>()))); }
|
DaoManager { public static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao) { if (connectionSource == null) { throw new IllegalArgumentException("connectionSource argument cannot be null"); } addDaoToClassMap(new ClassConnectionSource(connectionSource, dao.getDataClass()), dao); } synchronized static D createDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D lookupDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); synchronized static D lookupDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void unregisterDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void registerDaoWithTableConfig(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void clearCache(); static synchronized void clearDaoCache(); static synchronized void addCachedDatabaseConfigs(Collection<DatabaseTableConfig<?>> configs); }
|
@Test public void testRegisterDao() throws Exception { Dao<RegisterClass, Void> dao = DaoManager.lookupDao(connectionSource, RegisterClass.class); assertNull(dao); Dao<? extends RegisterClass, Object> daoImpl = BaseDaoImpl.createDao(connectionSource, RegisterClass.class); DaoManager.registerDao(connectionSource, daoImpl); dao = DaoManager.lookupDao(connectionSource, RegisterClass.class); assertSame(daoImpl, dao); }
@Test(expected = IllegalArgumentException.class) public void testRegisterNull() { DaoManager.registerDao(null, null); }
|
DefaultInvocationContext implements InvocationContext { @Override @Nullable public Object getNullableBindingValue(BindingParameterInvoker invoker) { String key = getCacheKey(invoker); if (cache.containsKey(key)) { return cache.get(key); } String parameterName = invoker.getBindingParameter().getParameterName(); if (!parameterNameToValueMap.containsKey(parameterName)) { throw new BindingException("Parameter '" + BindingParameter.create(parameterName, "", null) + "' not found, " + "available root parameters are " + transToBindingParameters(parameterNameToValueMap.keySet())); } Object obj = parameterNameToValueMap.get(parameterName); Object value = invoker.invoke(obj); cache.put(key, value); return value; } private DefaultInvocationContext(); static DefaultInvocationContext create(); @Override void addParameter(String parameterName, Object parameterValue); @Override Object getBindingValue(BindingParameterInvoker invoker); @Override @Nullable Object getNullableBindingValue(BindingParameterInvoker invoker); @Override void setBindingValue(BindingParameterInvoker invoker, Object value); @Override @Nullable String getGlobalTable(); @Override void setGlobalTable(String globalTable); @Override void writeToSqlBuffer(String str); @Override void appendToArgs(Object obj, TypeHandler<?> typeHandler); @Override BoundSql getBoundSql(); @Override List<Object> getParameterValues(); }
|
@Test public void testGetNullableBindingValue() throws Exception { DefaultInvocationContext ctx = DefaultInvocationContext.create(); UserBag userBag = new UserBag(); userBag.setName("ash"); User user = new User(); user.setUserBag(userBag); user.setId(100); ctx.addParameter("userId", 9527); ctx.addParameter("user", user); BindingParameterInvoker userIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("userId", "", null)); assertThat(ctx.getNullableBindingValue(userIdInvoker), equalTo((Object) 9527)); assertThat(ctx.getNullableBindingValue(userIdInvoker), equalTo((Object) 9527)); BindingParameterInvoker userDotIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("user", "id", null)); assertThat(ctx.getNullableBindingValue(userDotIdInvoker), equalTo((Object) 100)); assertThat(ctx.getNullableBindingValue(userDotIdInvoker), equalTo((Object) 100)); BindingParameterInvoker userDotObjIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("user", "objId", null)); assertThat(ctx.getNullableBindingValue(userDotObjIdInvoker), nullValue()); assertThat(ctx.getNullableBindingValue(userDotObjIdInvoker), nullValue()); BindingParameterInvoker userDotUserBagDotNameInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("user", "userBag.name", null)); assertThat(ctx.getNullableBindingValue(userDotUserBagDotNameInvoker), equalTo((Object) "ash")); assertThat(ctx.getNullableBindingValue(userDotUserBagDotNameInvoker), equalTo((Object) "ash")); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> iterator() { return dao.iterator(); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testIfAllMethodsAreThere() { List<String> failedMessages = new ArrayList<String>(); List<Method> runtimeMethods = new ArrayList<Method>(Arrays.asList(RuntimeExceptionDao.class.getDeclaredMethods())); List<Method> daoMethods = new ArrayList<Method>(Arrays.asList(Dao.class.getDeclaredMethods())); daoMethods.addAll(Arrays.asList(CloseableIterable.class.getDeclaredMethods())); daoMethods.addAll(Arrays.asList(Iterable.class.getDeclaredMethods())); Iterator<Method> daoIterator = daoMethods.iterator(); while (daoIterator.hasNext()) { Method daoMethod = daoIterator.next(); boolean found = false; if (daoMethod.getName().equals("$VRi") || daoMethod.getName().equals("spliterator") || daoMethod.getName().equals("forEach") ) { continue; } Iterator<Method> runtimeIterator = runtimeMethods.iterator(); while (runtimeIterator.hasNext()) { Method runtimeMethod = runtimeIterator.next(); if (daoMethod.getName().equals(runtimeMethod.getName()) && Arrays.equals(daoMethod.getParameterTypes(), runtimeMethod.getParameterTypes()) && daoMethod.getReturnType().equals(runtimeMethod.getReturnType())) { found = true; daoIterator.remove(); runtimeIterator.remove(); break; } } if (!found) { failedMessages.add(RuntimeExceptionDao.class.getName() + " did not include method: " + daoMethod); } } for (Method runtimeMethod : runtimeMethods) { if (runtimeMethod.getName().startsWith("$")) { continue; } if (runtimeMethod.getName().equals("createDao") || runtimeMethod.getName().equals("logMessage")) { continue; } failedMessages.add("Unknown RuntimeExceptionDao method: " + runtimeMethod); } if (!failedMessages.isEmpty()) { for (String message : failedMessages) { System.err.println(message); } fail(failedMessages.get(0) + ", see the console for more"); } }
@Test(expected = RuntimeException.class) public void testIteratorThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.iterator(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.iterator(null); verify(dao); }
@Test(expected = RuntimeException.class) public void testIteratorQueryFlags() { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(rtDao.iterator(null, 0)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.iterator(null, 0); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { public static <T, ID> RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz) throws SQLException { @SuppressWarnings("unchecked") Dao<T, ID> castDao = (Dao<T, ID>) DaoManager.createDao(connectionSource, clazz); return new RuntimeExceptionDao<T, ID>(castDao); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testCreateDao() throws Exception { createDao(Foo.class, true); RuntimeExceptionDao<Foo, String> dao = RuntimeExceptionDao.createDao(connectionSource, Foo.class); assertEquals(0, dao.countOf()); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public T queryForId(ID id) { try { return dao.queryForId(id); } catch (SQLException e) { logMessage(e, "queryForId threw exception on: " + id); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryForIdThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryForId(isA(String.class))).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryForId("wow"); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public T queryForFirst(PreparedQuery<T> preparedQuery) { try { return dao.queryForFirst(preparedQuery); } catch (SQLException e) { logMessage(e, "queryForFirst threw exception on: " + preparedQuery); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryForFirstPreparedThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryForFirst(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryForFirst(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public List<T> queryForAll() { try { return dao.queryForAll(); } catch (SQLException e) { logMessage(e, "queryForAll threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryForAllThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryForAll()).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryForAll(); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public List<T> queryForEq(String fieldName, Object value) { try { return dao.queryForEq(fieldName, value); } catch (SQLException e) { logMessage(e, "queryForEq threw exception on: " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryForEqThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryForEq(null, null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryForEq(null, null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public List<T> queryForMatching(T matchObj) { try { return dao.queryForMatching(matchObj); } catch (SQLException e) { logMessage(e, "queryForMatching threw exception on: " + matchObj); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryForMatchingThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryForMatching(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryForMatching(null); verify(dao); }
|
DefaultInvocationContext implements InvocationContext { @Override public Object getBindingValue(BindingParameterInvoker invoker) { Object value = getNullableBindingValue(invoker); if (value == null) { throw new BindingException("Parameter '" + invoker.getBindingParameter() + "' need a non-null value"); } return value; } private DefaultInvocationContext(); static DefaultInvocationContext create(); @Override void addParameter(String parameterName, Object parameterValue); @Override Object getBindingValue(BindingParameterInvoker invoker); @Override @Nullable Object getNullableBindingValue(BindingParameterInvoker invoker); @Override void setBindingValue(BindingParameterInvoker invoker, Object value); @Override @Nullable String getGlobalTable(); @Override void setGlobalTable(String globalTable); @Override void writeToSqlBuffer(String str); @Override void appendToArgs(Object obj, TypeHandler<?> typeHandler); @Override BoundSql getBoundSql(); @Override List<Object> getParameterValues(); }
|
@Test public void testGetBindingValue() throws Exception { DefaultInvocationContext ctx = DefaultInvocationContext.create(); ctx.addParameter("userId", 9527); BindingParameterInvoker userIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("userId", "", null)); assertThat(ctx.getBindingValue(userIdInvoker), equalTo((Object) 9527)); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public List<T> queryForMatchingArgs(T matchObj) { try { return dao.queryForMatchingArgs(matchObj); } catch (SQLException e) { logMessage(e, "queryForMatchingArgs threw exception on: " + matchObj); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryForMatchingArgsThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryForMatchingArgs(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryForMatchingArgs(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public List<T> queryForFieldValues(Map<String, Object> fieldValues) { try { return dao.queryForFieldValues(fieldValues); } catch (SQLException e) { logMessage(e, "queryForFieldValues threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryForFieldsValuesThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryForFieldValues(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryForFieldValues(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues) { try { return dao.queryForFieldValuesArgs(fieldValues); } catch (SQLException e) { logMessage(e, "queryForFieldValuesArgs threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryForFieldsValuesArgsThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryForFieldValuesArgs(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryForFieldValuesArgs(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public T queryForSameId(T data) { try { return dao.queryForSameId(data); } catch (SQLException e) { logMessage(e, "queryForSameId threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryForSameIdThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryForSameId(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryForSameId(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public List<T> query(PreparedQuery<T> preparedQuery) { try { return dao.query(preparedQuery); } catch (SQLException e) { logMessage(e, "query threw exception on: " + preparedQuery); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.query(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.query(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int create(T data) { try { return dao.create(data); } catch (SQLException e) { logMessage(e, "create threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testCreateThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.create((Foo) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.create((Foo) null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public T createIfNotExists(T data) { try { return dao.createIfNotExists(data); } catch (SQLException e) { logMessage(e, "createIfNotExists threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testCreateIfNotExistsThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.createIfNotExists(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.createIfNotExists(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CreateOrUpdateStatus createOrUpdate(T data) { try { return dao.createOrUpdate(data); } catch (SQLException e) { logMessage(e, "createOrUpdate threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testCreateOrUpdateThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.createOrUpdate(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.createOrUpdate(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int update(T data) { try { return dao.update(data); } catch (SQLException e) { logMessage(e, "update threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testUpdateThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.update((Foo) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.update((Foo) null); verify(dao); }
@Test(expected = RuntimeException.class) public void testUpdatePreparedThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.update((PreparedUpdate<Foo>) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.update((PreparedUpdate<Foo>) null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int updateId(T data, ID newId) { try { return dao.updateId(data, newId); } catch (SQLException e) { logMessage(e, "updateId threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testUpdateIdThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.updateId(null, null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.updateId(null, null); verify(dao); }
|
DefaultInvocationContext implements InvocationContext { @Override public void setBindingValue(BindingParameterInvoker invoker, Object value) { String key = getCacheKey(invoker); cache.put(key, value); } private DefaultInvocationContext(); static DefaultInvocationContext create(); @Override void addParameter(String parameterName, Object parameterValue); @Override Object getBindingValue(BindingParameterInvoker invoker); @Override @Nullable Object getNullableBindingValue(BindingParameterInvoker invoker); @Override void setBindingValue(BindingParameterInvoker invoker, Object value); @Override @Nullable String getGlobalTable(); @Override void setGlobalTable(String globalTable); @Override void writeToSqlBuffer(String str); @Override void appendToArgs(Object obj, TypeHandler<?> typeHandler); @Override BoundSql getBoundSql(); @Override List<Object> getParameterValues(); }
|
@Test public void testSetBindingValue() throws Exception { DefaultInvocationContext ctx = DefaultInvocationContext.create(); ctx.addParameter("userId", 9527); BindingParameterInvoker userIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("userId", "", null)); assertThat(ctx.getBindingValue(userIdInvoker), equalTo((Object) 9527)); ctx.setBindingValue(userIdInvoker, 666); assertThat(ctx.getBindingValue(userIdInvoker), equalTo((Object) 666)); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int refresh(T data) { try { return dao.refresh(data); } catch (SQLException e) { logMessage(e, "refresh threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testRefreshThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.refresh(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.refresh(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int delete(T data) { try { return dao.delete(data); } catch (SQLException e) { logMessage(e, "delete threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testDeleteThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.delete((Foo) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.delete((Foo) null); verify(dao); }
@Test(expected = RuntimeException.class) public void testDeleteCollectionThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.delete((Collection<Foo>) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.delete((Collection<Foo>) null); verify(dao); }
@Test(expected = RuntimeException.class) public void testDeletePreparedThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.delete((PreparedDelete<Foo>) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.delete((PreparedDelete<Foo>) null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int deleteById(ID id) { try { return dao.deleteById(id); } catch (SQLException e) { logMessage(e, "deleteById threw exception on: " + id); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testDeleteByIdThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.deleteById(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.deleteById(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int deleteIds(Collection<ID> ids) { try { return dao.deleteIds(ids); } catch (SQLException e) { logMessage(e, "deleteIds threw exception on: " + ids); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testDeleteIdsThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.deleteIds(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.deleteIds(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void closeLastIterator() { try { dao.closeLastIterator(); } catch (IOException e) { logMessage(e, "closeLastIterator threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testCloseLastIteratorThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.closeLastIterator(); expectLastCall().andThrow(new SQLException("Testing catch")); replay(dao); rtDao.closeLastIterator(); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public CloseableIterator<T> closeableIterator() { return dao.closeableIterator(); } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testCloseableIterator() { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.closeableIterator()).andReturn(null); replay(dao); rtDao.closeableIterator(); verify(dao); }
@Test(expected = RuntimeException.class) public void testCloseableIteratorThrow() { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.closeableIterator()).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.closeableIterator(); verify(dao); }
|
DefaultParameterContext implements ParameterContext { @Override public String getParameterNameByPosition(int position) { String name = positionToNameMap.get(position); if (name == null) { throw new IllegalStateException("parameter name can not be found by position [" + position + "]"); } return name; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
@Test public void testGetParameterNameByPosition() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "param1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, int.class, empty, "param2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); assertThat(ctx.getParameterNameByPosition(0), equalTo("param1")); assertThat(ctx.getParameterNameByPosition(1), equalTo("param2")); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public GenericRawResults<String[]> queryRaw(String query, String... arguments) { try { return dao.queryRaw(query, arguments); } catch (SQLException e) { logMessage(e, "queryRaw threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testQueryRawThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryRaw(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryRaw(null); verify(dao); }
@Test(expected = RuntimeException.class) public void testQueryRawRowMapperThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryRaw(null, (RawRowMapper<String>) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryRaw(null, (RawRowMapper<String>) null); verify(dao); }
@Test(expected = RuntimeException.class) public void testQueryRawDateTypesThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryRaw(null, (DataType[]) null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryRaw(null, (DataType[]) null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long queryRawValue(String query, String... arguments) { try { return dao.queryRawValue(query, arguments); } catch (SQLException e) { logMessage(e, "queryRawValue threw exception on: " + query); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testQueryRawValue() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); String query = "fkeowjfkewfewf"; expect(dao.queryRawValue(query, new String[0])).andReturn(0L); replay(dao); rtDao.queryRawValue(query); verify(dao); }
@Test(expected = RuntimeException.class) public void testQueryRawValueThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.queryRawValue(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.queryRawValue(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRaw(String statement, String... arguments) { try { return dao.executeRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "executeRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testExecuteRaw() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.executeRaw(null)).andReturn(0); replay(dao); rtDao.executeRaw(null); verify(dao); }
@Test(expected = RuntimeException.class) public void testExecuteRawThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.executeRaw(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.executeRaw(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void assignEmptyForeignCollection(T parent, String fieldName) { try { dao.assignEmptyForeignCollection(parent, fieldName); } catch (SQLException e) { logMessage(e, "assignEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testAssignEmptyForeignCollection() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.assignEmptyForeignCollection(null, null); replay(dao); rtDao.assignEmptyForeignCollection(null, null); verify(dao); }
@Test(expected = RuntimeException.class) public void testAssignEmptyForeignCollectionThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.assignEmptyForeignCollection(null, null); expectLastCall().andThrow(new SQLException("Testing catch")); replay(dao); rtDao.assignEmptyForeignCollection(null, null); verify(dao); }
|
DefaultParameterContext implements ParameterContext { @Override public BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter) { String parameterName = bindingParameter.getParameterName(); Type type = nameToTypeMap.get(parameterName); if (type == null) { throw new BindingException("Parameter '" + BindingParameter.create(bindingParameter.getParameterName(), "", null) + "' not found, available root parameters are " + transToBindingParameters(nameToTypeMap.keySet())); } return FunctionalBindingParameterInvoker.create(type, bindingParameter); } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
@Test public void testGetBindingParameterInvoker() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, User.class, empty, "2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); checkBindingParameterInvoker(ctx, "1", "", String.class); checkBindingParameterInvoker(ctx, "2", "userBag.item.itemId", int.class); checkBindingParameterInvoker(ctx, "2", "userBag.item.objItemId", Integer.class); checkBindingParameterInvoker(ctx, "2", "userId", String.class); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int executeRawNoArgs(String statement) { try { return dao.executeRawNoArgs(statement); } catch (SQLException e) { logMessage(e, "executeRawNoArgs threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testExecuteRawNoArgs() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.executeRawNoArgs(null)).andReturn(0); replay(dao); rtDao.executeRawNoArgs(null); verify(dao); }
@Test(expected = RuntimeException.class) public void testExecuteRawNoArgsThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.executeRawNoArgs(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.executeRawNoArgs(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public void setObjectCache(boolean enabled) { try { dao.setObjectCache(enabled); } catch (SQLException e) { logMessage(e, "setObjectCache(" + enabled + ") threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test public void testSetObjectCache() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.setObjectCache(false); replay(dao); rtDao.setObjectCache(false); verify(dao); }
@Test(expected = RuntimeException.class) public void testSetObjectCacheThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.setObjectCache(false); expectLastCall().andThrow(new SQLException("Testing catch")); replay(dao); rtDao.setObjectCache(false); verify(dao); }
@Test public void testSetObjectCacheCache() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.setObjectCache(null); replay(dao); rtDao.setObjectCache(null); verify(dao); }
@Test(expected = RuntimeException.class) public void testSetObjectCacheCacheThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); dao.setObjectCache(null); expectLastCall().andThrow(new SQLException("Testing catch")); replay(dao); rtDao.setObjectCache(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public int updateRaw(String statement, String... arguments) { try { return dao.updateRaw(statement, arguments); } catch (SQLException e) { logMessage(e, "updateRaw threw exception on: " + statement); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testUpdateRawThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.updateRaw(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.updateRaw(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public <CT> CT callBatchTasks(Callable<CT> callable) { try { return dao.callBatchTasks(callable); } catch (Exception e) { logMessage(e, "callBatchTasks threw exception on: " + callable); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testCallBatchTasksThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.callBatchTasks(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.callBatchTasks(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean objectsEqual(T data1, T data2) { try { return dao.objectsEqual(data1, data2); } catch (SQLException e) { logMessage(e, "objectsEqual threw exception on: " + data1 + " and " + data2); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testObjectsEqualThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.objectsEqual(null, null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.objectsEqual(null, null); verify(dao); }
|
DefaultParameterContext implements ParameterContext { @Override public List<ParameterDescriptor> getParameterDescriptors() { return parameterDescriptors; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }
|
@Test public void testGetParameterDescriptors() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, User.class, empty, "2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); assertThat(ctx.getParameterDescriptors(), equalTo(pds)); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public ID extractId(T data) { try { return dao.extractId(data); } catch (SQLException e) { logMessage(e, "extractId threw exception on: " + data); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testExtractIdThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.extractId(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.extractId(null); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public boolean isTableExists() { try { return dao.isTableExists(); } catch (SQLException e) { logMessage(e, "isTableExists threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testIsTableExistsThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.isTableExists()).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.isTableExists(); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public long countOf() { try { return dao.countOf(); } catch (SQLException e) { logMessage(e, "countOf threw exception"); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testCountOfThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.countOf()).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.countOf(); verify(dao); }
@Test(expected = RuntimeException.class) public void testCountOfPreparedThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); @SuppressWarnings("unchecked") PreparedQuery<Foo> prepared = (PreparedQuery<Foo>) createMock(PreparedQuery.class); expect(dao.countOf(prepared)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.countOf(prepared); verify(dao); }
|
RuntimeExceptionDao implements Dao<T, ID> { @Override public <FT> ForeignCollection<FT> getEmptyForeignCollection(String fieldName) { try { return dao.getEmptyForeignCollection(fieldName); } catch (SQLException e) { logMessage(e, "getEmptyForeignCollection threw exception on " + fieldName); throw new RuntimeException(e); } } RuntimeExceptionDao(Dao<T, ID> dao); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource, Class<T> clazz); static RuntimeExceptionDao<T, ID> createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); @Override T queryForId(ID id); @Override T queryForFirst(PreparedQuery<T> preparedQuery); @Override List<T> queryForAll(); @Override List<T> queryForEq(String fieldName, Object value); @Override List<T> queryForMatching(T matchObj); @Override List<T> queryForMatchingArgs(T matchObj); @Override List<T> queryForFieldValues(Map<String, Object> fieldValues); @Override List<T> queryForFieldValuesArgs(Map<String, Object> fieldValues); @Override T queryForSameId(T data); @Override QueryBuilder<T, ID> queryBuilder(); @Override UpdateBuilder<T, ID> updateBuilder(); @Override DeleteBuilder<T, ID> deleteBuilder(); @Override List<T> query(PreparedQuery<T> preparedQuery); @Override int create(T data); @Override int create(Collection<T> datas); @Override T createIfNotExists(T data); @Override CreateOrUpdateStatus createOrUpdate(T data); @Override int update(T data); @Override int updateId(T data, ID newId); @Override int update(PreparedUpdate<T> preparedUpdate); @Override int refresh(T data); @Override int delete(T data); @Override int deleteById(ID id); @Override int delete(Collection<T> datas); @Override int deleteIds(Collection<ID> ids); @Override int delete(PreparedDelete<T> preparedDelete); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> iterator(int resultFlags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(PreparedQuery<T> preparedQuery); @Override void closeLastIterator(); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery); @Override CloseableIterator<T> iterator(PreparedQuery<T> preparedQuery, int resultFlags); @Override GenericRawResults<String[]> queryRaw(String query, String... arguments); @Override long queryRawValue(String query, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, RawRowMapper<UO> mapper, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DataType[] columnTypes, RawRowObjectMapper<UO> mapper,
String... arguments); @Override GenericRawResults<Object[]> queryRaw(String query, DataType[] columnTypes, String... arguments); @Override GenericRawResults<UO> queryRaw(String query, DatabaseResultsMapper<UO> mapper, String... arguments); @Override int executeRaw(String statement, String... arguments); @Override int executeRawNoArgs(String statement); @Override int updateRaw(String statement, String... arguments); @Override CT callBatchTasks(Callable<CT> callable); @Override String objectToString(T data); @Override boolean objectsEqual(T data1, T data2); @Override ID extractId(T data); @Override Class<T> getDataClass(); @Override FieldType findForeignFieldType(Class<?> clazz); @Override boolean isUpdatable(); @Override boolean isTableExists(); @Override long countOf(); @Override long countOf(PreparedQuery<T> preparedQuery); @Override void assignEmptyForeignCollection(T parent, String fieldName); @Override ForeignCollection<FT> getEmptyForeignCollection(String fieldName); @Override void setObjectCache(boolean enabled); @Override ObjectCache getObjectCache(); @Override void setObjectCache(ObjectCache objectCache); @Override void clearObjectCache(); @Override T mapSelectStarRow(DatabaseResults results); @Override GenericRowMapper<T> getSelectStarRowMapper(); @Override boolean idExists(ID id); @Override DatabaseConnection startThreadConnection(); @Override void endThreadConnection(DatabaseConnection connection); @Override void setAutoCommit(DatabaseConnection connection, boolean autoCommit); @Override boolean isAutoCommit(DatabaseConnection connection); @Override void commit(DatabaseConnection connection); @Override void rollBack(DatabaseConnection connection); @Override void setObjectFactory(ObjectFactory<T> objectFactory); @Override RawRowMapper<T> getRawRowMapper(); @Override ConnectionSource getConnectionSource(); @Override void registerObserver(DaoObserver observer); @Override void unregisterObserver(DaoObserver observer); @Override void notifyChanges(); @Override String getTableName(); }
|
@Test(expected = RuntimeException.class) public void testGetEmptyForeignCollectionThrow() throws Exception { @SuppressWarnings("unchecked") Dao<Foo, String> dao = (Dao<Foo, String>) createMock(Dao.class); RuntimeExceptionDao<Foo, String> rtDao = new RuntimeExceptionDao<Foo, String>(dao); expect(dao.getEmptyForeignCollection(null)).andThrow(new SQLException("Testing catch")); replay(dao); rtDao.getEmptyForeignCollection(null); verify(dao); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.