docs: public <FT, FID> void configDaoInformation(ConnectionSource connectionSource, Class<?> parentClass)
  			throws SQLException {
  		Class<?> fieldClass = field.getType();
  		DatabaseType databaseType = connectionSource.getDatabaseType();
  		final FieldType foreignIdField;
  		final FieldType foreignRefField;
  		final FieldType foreignFieldType;
  		final Dao<FT, FID> foreignDao;
  		final MappedQueryForFieldEq<FT, FID> mappedQueryForForeignField;
  
  		String foreignColumnName = fieldConfig.getForeignColumnName();
  		if (fieldConfig.isForeignAutoRefresh() || foreignColumnName != null) {
  			DatabaseTableConfig<?> tableConfig = fieldConfig.getForeignTableConfig();
  			TableInfo<FT, FID> foreignTableInfo;
  			if (tableConfig == null) {
  				// NOTE: the cast is necessary for maven
  				@SuppressWarnings("unchecked")
  				Dao<FT, FID> castDao = (Dao<FT, FID>) DaoManager.createDao(connectionSource, fieldClass);
  				foreignDao = castDao;
  				foreignTableInfo = foreignDao.getTableInfo();
  			} else {
  				tableConfig.extractFieldTypes(databaseType);
  				// NOTE: the cast is necessary for maven
  				@SuppressWarnings("unchecked")
  				Dao<FT, FID> castDao = (Dao<FT, FID>) DaoManager.createDao(connectionSource, tableConfig);
  				foreignDao = castDao;
  				foreignTableInfo = castDao.getTableInfo();
  			}
  			foreignIdField = foreignTableInfo.getIdField();
  			if (foreignIdField == null) {
  				throw new IllegalArgumentException("Foreign field " + fieldClass + " does not have id field");
  			}
  			if (foreignColumnName == null) {
  				foreignRefField = foreignIdField;
  			} else {
  				foreignRefField = foreignTableInfo.getFieldTypeByColumnName(foreignColumnName);
  				if (foreignRefField == null) {
  					throw new IllegalArgumentException(
  							"Foreign field " + fieldClass + " does not have field named '" + foreignColumnName + "'");
  				}
  			}
  			MappedQueryForFieldEq<FT, FID> castMappedQueryForForeignField =
  					MappedQueryForFieldEq.build(foreignDao, foreignTableInfo, foreignRefField);
  			mappedQueryForForeignField = castMappedQueryForForeignField;
  			foreignFieldType = null;
  		} else if (fieldConfig.isForeign()) {
  			if (this.dataPersister != null && this.dataPersister.isPrimitive()) {
  				throw new IllegalArgumentException(
  						"Field " + this + " is a primitive class " + fieldClass + " but marked as foreign");
  			}
  			DatabaseTableConfig<?> tableConfig = fieldConfig.getForeignTableConfig();
  			if (tableConfig != null) {
  				tableConfig.extractFieldTypes(databaseType);
  				// NOTE: the cast is necessary for maven
  				@SuppressWarnings("unchecked")
  				Dao<FT, FID> castDao = (Dao<FT, FID>) DaoManager.createDao(connectionSource, tableConfig);
  				foreignDao = castDao;
  			} else {
  				/*
  				 * Initially we were only doing this just for BaseDaoEnabled.class and isForeignAutoCreate(). But we
  				 * need it also for foreign fields because the alternative was to use reflection. Chances are if it is
  				 * foreign we're going to need the DAO in the future anyway so we might as well create it. This also
  				 * allows us to make use of any table configs.
  				 */
  				// NOTE: the cast is necessary for maven
  				@SuppressWarnings("unchecked")
  				Dao<FT, FID> castDao = (Dao<FT, FID>) DaoManager.createDao(connectionSource, fieldClass);
  				foreignDao = castDao;
  			}
  			TableInfo<FT, FID> foreignTableInfo = foreignDao.getTableInfo();
  			foreignIdField = foreignTableInfo.getIdField();
  			if (foreignIdField == null) {
  				throw new IllegalArgumentException("Foreign field " + fieldClass + " does not have id field");
  			}
  			foreignRefField = foreignIdField;
  			if (isForeignAutoCreate() && !foreignIdField.isGeneratedId()) {
  				throw new IllegalArgumentException(
  						"Field " + field.getName() + ", if foreignAutoCreate = true then class "
  								+ fieldClass.getSimpleName() + " must have id field with generatedId = true");
  			}
  			foreignFieldType = null;
  			mappedQueryForForeignField = null;
  		} else if (fieldConfig.isForeignCollection()) {
  			if (fieldClass != Collection.class && !ForeignCollection.class.isAssignableFrom(fieldClass)) {
  				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) {
  				// i doubt this will ever be reached
  				throw new SQLException("Field class for '" + field.getName()
  						+ "' must be a parameterized Collection with at least 1 type.");
  			}
  
  			// If argument is a type variable we need to get arguments from superclass
  			if (genericArguments[0] instanceof TypeVariable) {
  				genericArguments = ((ParameterizedType) parentClass.getGenericSuperclass()).getActualTypeArguments();
  			}
  
  			if (!(genericArguments[0] instanceof Class)) {
  				throw new SQLException("Field class for '" + field.getName()
  						+ "' must be a parameterized Collection whose generic argument is an entity class not: "
  						+ genericArguments[0]);
  			}
  			@SuppressWarnings("unchecked")
  			Class<FT> collectionClazz = (Class<FT>) genericArguments[0];
  			@SuppressWarnings("unchecked")
  			DatabaseTableConfig<FT> tableConfig = (DatabaseTableConfig<FT>) fieldConfig.getForeignTableConfig();
  			Dao<FT, FID> foundDao;
  			if (tableConfig == null) {
  				Dao<FT, FID> castDao = DaoManager.createDao(connectionSource, collectionClazz);
  				foundDao = castDao;
  			} else {
  				Dao<FT, FID> castDao = DaoManager.createDao(connectionSource, tableConfig);
  				foundDao = castDao;
  			}
  			foreignDao = foundDao;
  			foreignFieldType = findForeignFieldType(collectionClazz, parentClass, foundDao);
  			foreignIdField = null;
  			foreignRefField = null;
  			mappedQueryForForeignField = null;
  		} else {
  			foreignIdField = null;
  			foreignRefField = null;
  			foreignFieldType = null;
  			foreignDao = null;
  			mappedQueryForForeignField = null;
  		}
  
  		this.mappedQueryForForeignField = mappedQueryForForeignField;
  		this.foreignFieldType = foreignFieldType;
  		this.foreignDao = foreignDao;
  		this.foreignIdField = foreignIdField;
  		this.foreignRefField = foreignRefField;
  
  		// we have to do this because if we have a foreign field then our id type might have gone to an _id primitive
  		if (this.foreignRefField != null) {
  			assignDataType(databaseType, this.foreignRefField.getDataPersister());
  		}
  	}