Map.of("_default", List.of("QUERY1")), //
                Set.of("QUERY1"), //

		}})
		stmt.Clauses["soft_delete_enabled"] = clause.Clause{}
	}
}

func (DeletedAt) UpdateClauses(f *schema.Field) []clause.Interface {
	return []clause.Interface{SoftDeleteUpdateClause{Field: f, ZeroValue: parseZeroValueTag(f)}}
}

type SoftDeleteUpdateClause struct {
	ZeroValue sql.NullString
	Field     *schema.Field
}

        }

        context.addFieldLog(field, text + "*");
        context.addHighlightedQuery(text);
        if (getQueryFieldConfig().notAnalyzedFieldSet.contains(field)) {
            return QueryBuilders.prefixQuery(field, toLowercaseWildcard(text)).boost(boost);
        }
        return QueryBuilders.matchPhrasePrefixQuery(field, toLowercaseWildcard(text)).boost(boost)

	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Bins":
			var zb0002 uint32

				}
			}

			for _, name := range []string{f.DBName, f.Name} {
				if name != "" {
					if field := s.LookUpField(name); field == nil || (field.Name != name && field.DBName != name) {
						t.Errorf("schema %v failed to look up field with dbname %v", s, f.DBName)
					}
				}
			}

			if f.PrimaryKey {
				var found bool

    header_params: List[ModelField] = field(default_factory=list)
    cookie_params: List[ModelField] = field(default_factory=list)
    body_params: List[ModelField] = field(default_factory=list)
    dependencies: List["Dependant"] = field(default_factory=list)
    security_requirements: List[SecurityRequirement] = field(default_factory=list)
    name: Optional[str] = None
    call: Optional[Callable[..., Any]] = None

	user, err := schema.Parse(&User{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {
		t.Fatalf("failed to parse user with map, got error %v", err)
	}

	if field := user.FieldsByName["Attrs"]; field.DataType != "Map(String,String)" {
		t.Errorf("failed to parse user field Attrs")
	}
}

func TestParseSchemaWithPointerFields(t *testing.T) {
	user, err := schema.Parse(&User{}, &sync.Map{}, schema.NamingStrategy{})
	if err != nil {

	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "v":
			z.Version, err = dc.ReadInt()

        final Map<String, FieldAnalyzerMapping> fieldAnalyzerMapping = fieldAnalyzerMappingMap.get(analyzerSettingsIndexName);
        final Set<String> analyzerNames = analyzerMap.get(analyzerSettingsIndexName);
        final String analyzerName;
        if (StringUtil.isNotBlank(field) && fieldAnalyzerMapping.containsKey(field)
                && fieldAnalyzerMapping.get(field).readingTermAnalyzer != null) {

    /**
     * Gets the location of the specified field in the input
     * source.
     *
     * @param field The key of the field, must not be
     * <code>null</code>.
     * @return The location of the field in the input source or
     * <code>null</code> if unknown.
     */
    public InputLocation getLocation(Object field);
    /**
     * Sets the location of the specified field.
     *