// SetColumnMapper set the column name mapping rule
198231
func (eg *EngineGroup) SetColumnMapper(mapper core.IMapper) {
	eg.Engine.ColumnMapper = mapper
	for i := 0; i < len(eg.slaves); i++ {
		eg.slaves[i].ColumnMapper = mapper
	}
}
813784
func (s *GetNamedQueryOutput) SetNamedQuery(v *NamedQuery) *GetNamedQueryOutput {
	s.NamedQuery = v
	return s
}
126264
func (s *AwsApiCallAction) SetServiceName(v string) *AwsApiCallAction {
	s.ServiceName = &v
	return s
}
53221
func (profile *UserProfile) SetFieldsMap(m map[string]UserProfileCustomField) {
	profile.Fields.SetMap(m)
}
457094
func (s *PolicyParameter) SetMapEntries(v []*ParameterMapEntry) *PolicyParameter {
	s.MapEntries = v
	return s
}
140712
func (s setMap) SetStringMap(key string, value interface{}) {
	// because these methods are meant to be chained without intermediate
	// checks for nil, we are likely to get interfaces with dynamic types but
	// a nil value.
	if reflect.ValueOf(value).IsNil() {
		return
	}

	m := make(map[string]interface{})

	switch value := value.(type) {
	case map[string]string:
		for k, v := range value {
			m[k] = v
		}
	case map[string]*string:
		for k, v := range value {
			if v == nil {
				continue
			}
			m[k] = *v
		}
	case map[string]interface{}:
		for k, v := range value {
			if v == nil {
				continue
			}

			switch v := v.(type) {
			case string:
				m[k] = v
			case *string:
				if v != nil {
					m[k] = *v
				}
			default:
				panic(fmt.Sprintf("unknown type for SetString: %T", v))
			}
		}
	}

	// catch the case where the interface wasn't nil, but we had no non-nil values
	if len(m) > 0 {
		s[key] = m
	}
}
84504
func (s *CreateResolverInput) SetResponseMappingTemplate(v string) *CreateResolverInput {
	s.ResponseMappingTemplate = &v
	return s
}
1336740
func (b *UpdateBuilder) SetNamed(column, name string) *UpdateBuilder {
	b.assignments = append(
		b.assignments, assignment{column: column, value: param(name)})
	return b
}
207158
func (s *GetApiKeysInput) SetNameQuery(v string) *GetApiKeysInput {
	s.NameQuery = &v
	return s
}
244206
func (s *GetIdentityPoolRolesOutput) SetRoleMappings(v map[string]*RoleMapping) *GetIdentityPoolRolesOutput {
	s.RoleMappings = v
	return s
}
339849
func (s *ResultSetMetadata) SetColumnInfo(v []*ColumnInfo) *ResultSetMetadata {
	s.ColumnInfo = v
	return s
}
953411
func (scope *Scope) SetColumn(column interface{}, value interface{}) error {
	var updateAttrs = map[string]interface{}{}
	if attrs, ok := scope.InstanceGet("gorm:update_attrs"); ok {
		updateAttrs = attrs.(map[string]interface{})
		defer scope.InstanceSet("gorm:update_attrs", updateAttrs)
	}

	if field, ok := column.(*Field); ok {
		updateAttrs[field.DBName] = value
		return field.Set(value)
	} else if name, ok := column.(string); ok {
		var (
			dbName           = ToDBName(name)
			mostMatchedField *Field
		)
		for _, field := range scope.Fields() {
			if field.DBName == value {
				updateAttrs[field.DBName] = value
				return field.Set(value)
			}
			if (field.DBName == dbName) || (field.Name == name && mostMatchedField == nil) {
				mostMatchedField = field
			}
		}

		if mostMatchedField != nil {
			updateAttrs[mostMatchedField.DBName] = value
			return mostMatchedField.Set(value)
		}
	}
	return errors.New("could not convert column to field")
}
783328
func (m *Mat4) SetCol(col int, v Vec4) {
	m[col*4+0], m[col*4+1], m[col*4+2], m[col*4+3] = v[0], v[1], v[2], v[3]
}
1205903
func (s *OpenXJsonSerDe) SetColumnToJsonKeyMappings(v map[string]*string) *OpenXJsonSerDe {
	s.ColumnToJsonKeyMappings = v
	return s
}
1202261
func (s *ResultSetMetadata) SetColumnCount(v int64) *ResultSetMetadata {
	s.ColumnCount = &v
	return s
}
116287
func (s *SkewedInfo) SetSkewedColumnNames(v []*string) *SkewedInfo {
	s.SkewedColumnNames = v
	return s
}
1227180
func (t *Table) SetColMinWidth(column int, width int) {
	t.cs[column] = width
}