Method MapStringsToUUIDs

internal/persistence/sql/uuid_mapping.go:88–131

(ctx context.Context, values ...string)

}

func (p *Persister) MapStringsToUUIDs(ctx context.Context, values ...string) (uuids []uuid.UUID, err error) {
	if len(values) == 0 {
		return
	}

	ctx, span := p.d.Tracer(ctx).Tracer().Start(ctx, "persistence.sql.MapStringsToUUIDs",
		trace.WithAttributes(attribute.Int("num_values", len(values))))
	defer otelx.End(span, &err)

	uuids, err = p.MapStringsToUUIDsReadOnly(ctx, values...)
	if err != nil {
		return nil, err
	}

	p.d.Logger().WithField("values", values).WithField("UUIDs", uuids).Trace("adding UUID mappings")

	mappings := make([]UUIDMapping, len(values))
	for i := range values {
		mappings[i] = UUIDMapping{
			ID:                   uuids[i],
			StringRepresentation: values[i],
		}
	}
	slices.SortFunc(mappings, func(a, b UUIDMapping) int {
		return bytes.Compare(a.ID[:], b.ID[:])
	})
	mappings = slices.CompactFunc(mappings, func(a, b UUIDMapping) bool {
		return a.ID == b.ID
	})

	span.SetAttributes(attribute.Int("num_mappings", len(mappings)))

	err = p.Transaction(ctx, func(ctx context.Context) error {
		for chunk := range slices.Chunk(mappings, chunkSizeInsertUUIDMappings) {
			query, args := buildInsertUUIDs(chunk, p.conn.Dialect.Name())
			if err := p.Connection(ctx).RawQuery(query, args...).Exec(); err != nil {
				return sqlcon.HandleError(err)
			}
		}
		return nil
	})

	return uuids, err
}

func (p *Persister) MapStringsToUUIDsReadOnly(ctx context.Context, ss ...string) (uuids []uuid.UUID, err error) {
	// This function doesn't talk to the database or do anything interesting, so we don't need to trace it.