field.IgnoreMigration = true
		case "migration":
			field.IgnoreMigration = true
		}
	}

	if v, ok := field.TagSettings["->"]; ok {
		field.Creatable = false
		field.Updatable = false
		if strings.ToLower(v) == "false" {
			field.Readable = false
		} else {
			field.Readable = true
		}
	}

	if v, ok := field.TagSettings["<-"]; ok {
		field.Creatable = true
		field.Updatable = true

     *
     * @param field the field (must not be {@literal null})
     * @return {@literal true} if it is an instance field
     */
    public static boolean isInstanceField(final Field field) {
        assertArgumentNotNull("field", field);

        return !Modifier.isStatic(field.getModifiers());
    }

    /**
     * Checks if the given field is a public field.
     *

	PrimaryKey    *Field
	PrimaryValue  string
	ForeignKey    *Field
	OwnPrimaryKey bool
}

func (schema *Schema) parseRelation(field *Field) *Relationship {
	var (
		err        error
		fieldValue = reflect.New(field.IndirectFieldType).Interface()
		relation   = &Relationship{
			Name:        field.Name,
			Field:       field,
			Schema:      schema,
			foreignKeys: toColumns(field.TagSettings["FOREIGNKEY"]),

				field := stmt.Schema.FieldsByDBName[column.Name]
				if values.Values[0][idx], isZero = field.ValueOf(stmt.Context, stmt.ReflectValue); isZero {
					if field.DefaultValueInterface != nil {
						values.Values[0][idx] = field.DefaultValueInterface
						stmt.AddError(field.Set(stmt.Context, stmt.ReflectValue, field.DefaultValueInterface))
					} else if field.AutoCreateTime > 0 || field.AutoUpdateTime > 0 {

  /** The HTTP {@code Cache-Control} header field name. */
  public static final String CACHE_CONTROL = "Cache-Control";

  /** The HTTP {@code Content-Length} header field name. */
  public static final String CONTENT_LENGTH = "Content-Length";

  /** The HTTP {@code Content-Type} header field name. */
  public static final String CONTENT_TYPE = "Content-Type";

  /** The HTTP {@code Date} header field name. */

        }
        if (DEFAULT_FIELD.equals(field)) {
            return convertDefaultTermQuery(fessConfig, context, termQuery, boost, field, text);
        }
        if (SORT_FIELD.equals(field)) {
            return convertSortQuery(fessConfig, context, termQuery, boost, field, text);
        }
        if (SITE_FIELD.equals(field)) {

	for _, field := range schema.Fields {
		if field.DataType != "" && field.HasDefaultValue && field.DefaultValueInterface == nil {
			schema.FieldsWithDefaultDBValue = append(schema.FieldsWithDefaultDBValue, field)
		}

		if !embedded {
			if field.DataType == "" && field.GORMDataType == "" && (field.Creatable || field.Updatable || field.Readable) {
				relationshipFields = append(relationshipFields, field)

	expr.SQL = m.DataTypeOf(field)

	if field.NotNull {
		expr.SQL += " NOT NULL"
	}

	if field.HasDefaultValue && (field.DefaultValueInterface != nil || field.DefaultValue != "") {
		if field.DefaultValueInterface != nil {
			defaultStmt := &gorm.Statement{Vars: []interface{}{field.DefaultValueInterface}}
			m.Dialector.BindVarTo(defaultStmt, defaultStmt, field.DefaultValueInterface)

    protected AvgAggregationBuilder regAvgA(String name, String field) {
        AvgAggregationBuilder builder = AggregationBuilders.avg(name).field(field);
        regA(builder);
        return builder;
    }

    protected MaxAggregationBuilder regMaxA(String name, String field) {
        MaxAggregationBuilder builder = AggregationBuilders.max(name).field(field);
        regA(builder);
        return builder;
    }

    }

    // Test annotation on field
    public void test_annotationOnField() throws Exception {
        final Field field = CustomSizeTest.class.getDeclaredField("testField");
        final CustomSize annotation = field.getAnnotation(CustomSize.class);

        assertNotNull("Annotation should be present on field", annotation);