¡Maestría en Core Data! Persistencia de Datos en iOS con SwiftUI y MVVM

Core Data es un framework de Apple que te permite gestionar el ciclo de vida de los objetos, serializarlos a un almacén persistente (como una base de datos SQLite) y recuperarlos. Es una parte fundamental del desarrollo de aplicaciones iOS cuando se necesita persistencia de datos robusta y escalable. Aunque no es una base de datos en sí, Core Data actúa como una interfaz de alto nivel que simplifica enormemente la interacción con el almacenamiento subyacente. En combinación con SwiftUI y el patrón MVVM (Model-View-ViewModel), podemos construir aplicaciones iOS modernas, reactivas y fáciles de mantener.

Este tutorial te sumergirá en el mundo de Core Data, desglosando sus componentes clave, explicando cómo integrarlo con SwiftUI de forma reactiva y demostrando cómo aplicar el patrón MVVM para una arquitectura de aplicación limpia y desacoplada. Preparémonos para dominar la persistencia de datos.

🚀 ¿Por Qué Core Data? La Ventaja de la Abstracción

Cuando hablamos de persistencia de datos en iOS, existen varias opciones: UserDefaults, serialización a archivos (Property Lists, JSON), Realm, SQLite (directamente) y Core Data. Cada una tiene sus pros y contras. UserDefaults es ideal para pequeñas preferencias del usuario. Serializar a archivos funciona para estructuras de datos simples y no relacionales. Realm y SQLite son bases de datos, pero requieren una gestión más manual de las operaciones y los objetos.

Core Data se distingue porque no es solo una solución de almacenamiento; es un framework de gestión de objetos gráficos. Esto significa que se encarga de muchos detalles de bajo nivel, como la gestión de memoria, el tracking de cambios, la validación de propiedades y la serialización a disco. Al usar Core Data, trabajamos con objetos Swift (NSManagedObject) que representan nuestros datos, y el framework se encarga de mapearlos a la capa de almacenamiento subyacente. Esta abstracción reduce significativamente el código boilerplate y permite enfocarnos en la lógica de negocio.

🛠️ Configuración Inicial: Project Setup con SwiftUI y Core Data

Comenzaremos creando un nuevo proyecto en Xcode y asegurándonos de que Core Data esté habilitado desde el inicio. Esto simplificará la configuración.

Paso 1: Crear un Nuevo Proyecto en Xcode

1. Abre Xcode y selecciona Create a new Xcode project.
2. Elige la plantilla iOS -> App y haz clic en Next.
3. Configura tu proyecto:
   • Product Name: CoreDataMVVMApp (o el nombre que prefieras).
   • Interface: SwiftUI.
   • Life Cycle: SwiftUI App.
   • Language: Swift.
4. ¡Importante! Marca la casilla Use Core Data. Esto generará automáticamente algunos archivos necesarios.
5. Haz clic en Next y elige dónde guardar tu proyecto.

Paso 2: Entendiendo los Archivos Generados

Al marcar Use Core Data, Xcode genera un archivo .xcdatamodeld y una extensión al PersistenceController (o un método en tu App si es una plantilla más reciente de SwiftUI) que inicializa el stack de Core Data. El archivo .xcdatamodeld es donde definiremos nuestro esquema de datos.

// Ejemplo de PersistenceController.swift (puede variar ligeramente según la versión de Xcode)
import CoreData

struct PersistenceController {
    static let shared = PersistenceController()

    static var preview: PersistenceController = {
        let result = PersistenceController(inMemory: true)
        let viewContext = result.container.viewContext
        for _ in 0..<10 {
            let newItem = Item(context: viewContext)
            newItem.timestamp = Date()
        }
        do {
            try viewContext.save()
        } catch {
            let nsError = error as NSError
            fatalError("Unresolved error \(nsError), \(nsError.userInfo)")
        }
        return result
    }()

    let container: NSPersistentContainer

    init(inMemory: Bool = false) {
        container = NSPersistentContainer(name: "CoreDataMVVMApp") // Usa el nombre de tu .xcdatamodeld
        if inMemory {
            container.persistentStoreDescriptions.first!.url = URL(fileURLWithPath: "/dev/null")
        }
        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        })
        container.viewContext.automaticallyMergesChangesFromParent = true
    }
}

Este PersistenceController es el punto de entrada a tu stack de Core Data. Contiene un NSPersistentContainer, que gestiona el modelo de objetos, los persistent stores y los managed object contexts.

📊 Modelado de Datos: El Corazón de Core Data

El archivo .xcdatamodeld es la interfaz gráfica donde definimos nuestras entidades, sus atributos y sus relaciones. Imagina que cada entidad es una 'tabla' en una base de datos relacional, y cada atributo es una 'columna'.

Paso 3: Crear Entidades y Atributos

Abramos el archivo CoreDataMVVMApp.xcdatamodeld. Por defecto, Xcode crea una entidad Item con un atributo timestamp.

Vamos a crear una entidad más útil para nuestro ejemplo: una lista de tareas (Task).

1. Haz clic en Add Entity en la parte inferior del editor.
2. Renombra la nueva entidad a Task.
3. Selecciona la entidad Task y haz clic en Add Attribute.
   • Name: title, Type: String.
   • Name: isCompleted, Type: Boolean.
   • Name: dueDate, Type: Date.
   • Name: priority, Type: Int16.

Paso 4: Generación de Clases NSManagedObject

Cuando defines entidades en el modelo, Core Data puede generar automáticamente las clases NSManagedObject correspondientes. Estas clases son las que interactuarás directamente en tu código Swift.

1. Selecciona tu entidad Task en el .xcdatamodeld.
2. En el panel de la derecha (Data Model Inspector), busca la sección Codegen.
3. Asegúrate de que Class esté seleccionado en el desplegable y Module sea Global Namespace.
4. Xcode automáticamente generará los archivos Task+CoreDataProperties.swift y Task+CoreDataClass.swift (o una única clase si usas Current Product Module).

Estos archivos extienden NSManagedObject y proporcionan acceso tipado a tus atributos. Por ejemplo, podrás acceder a task.title en lugar de task.value(forKey: "title").

// Task+CoreDataProperties.swift (ejemplo generado)
import Foundation
import CoreData

extension Task {

    @nonobjc public class func fetchRequest() -> NSFetchRequest<Task> {
        return NSFetchRequest<Task>(entityName: "Task")
    }

    @NSManaged public var title: String?
    @NSManaged public var isCompleted: Bool
    @NSManaged public var dueDate: Date?
    @NSManaged public var priority: Int16

}

extension Task : Identifiable { }

🏗️ Implementando MVVM con Core Data en SwiftUI

El patrón Model-View-ViewModel (MVVM) es ideal para SwiftUI, ya que promueve la separación de intereses. El View (SwiftUI) se encarga de la interfaz de usuario, el ViewModel expone datos y comandos a la View, y el Model (Core Data en este caso) se encarga de la lógica de negocio y la persistencia.

Paso 5: Creando el ViewModel de Core Data

Necesitamos un ViewModel que interactúe con el PersistenceController para realizar operaciones CRUD (Crear, Leer, Actualizar, Borrar) en nuestras entidades de Core Data. Este ViewModel expondrá los datos a la vista de forma reactiva.

Crea un nuevo archivo Swift llamado TaskListViewModel.swift:

import Foundation
import CoreData
import Combine // Para manejar la reactividad con @Published

class TaskListViewModel: ObservableObject {
    // Publica los cambios en las tareas para que las vistas puedan reaccionar
    @Published var tasks: [Task] = []
    @Published var searchText: String = "" {
        didSet { // Cuando el texto de búsqueda cambia, actualizamos las tareas
            fetchTasks()
        }
    }

    private let viewContext: NSManagedObjectContext
    private var cancellables = Set<AnyCancellable>()

    // Constructor que recibe el contexto de vista para las operaciones de Core Data
    init(context: NSManagedObjectContext = PersistenceController.shared.container.viewContext) {
        self.viewContext = context
        fetchTasks()
    }

    // MARK: - Core Data Operations

    func fetchTasks() {
        let request: NSFetchRequest<Task> = Task.fetchRequest()
        request.sortDescriptors = [
            NSSortDescriptor(keyPath: \Task.priority, ascending: true),
            NSSortDescriptor(keyPath: \Task.dueDate, ascending: true)
        ]

        if !searchText.isEmpty {
            request.predicate = NSPredicate(format: "title CONTAINS[cd] %@", searchText)
        }

        do {
            tasks = try viewContext.fetch(request)
        } catch {
            print("Error fetching tasks: \(error.localizedDescription)")
        }
    }

    func addTask(title: String, dueDate: Date, priority: Int16) {
        let newTask = Task(context: viewContext)
        newTask.id = UUID() // Asignar un UUID único para identificación
        newTask.title = title
        newTask.dueDate = dueDate
        newTask.priority = priority
        newTask.isCompleted = false

        saveContext()
        fetchTasks()
    }

    func updateTask(task: Task, newTitle: String, newDueDate: Date, newPriority: Int16, isCompleted: Bool) {
        task.title = newTitle
        task.dueDate = newDueDate
        task.priority = newPriority
        task.isCompleted = isCompleted
        saveContext()
        fetchTasks()
    }

    func toggleCompletion(for task: Task) {
        task.isCompleted.toggle()
        saveContext()
        fetchTasks()
    }

    func deleteTask(at offsets: IndexSet) {
        offsets.map { tasks[$0] }.forEach(viewContext.delete)
        saveContext()
        fetchTasks()
    }

    // MARK: - Persistence Helper

    private func saveContext() {
        do {
            try viewContext.save()
        } catch {
            let nsError = error as NSError
            print("Error saving context: \(nsError), \(nsError.userInfo)")
        }
    }
}

🎨 Conectando SwiftUI y Core Data con MVVM

Ahora que tenemos nuestro ViewModel, podemos construir la interfaz de usuario de SwiftUI para interactuar con él.

Paso 6: Crear la Vista Principal (TaskListContentView)

Modificaremos ContentView.swift para mostrar nuestra lista de tareas y permitir añadir nuevas.

import SwiftUI
import CoreData

struct TaskListContentView: View {
    // Inyectamos el ViewModel como un EnvironmentObject o StateObject
    // Para simplificar, lo inicializamos aquí. En apps grandes, inyectar.
    @StateObject private var viewModel: TaskListViewModel

    @State private var showingAddTaskSheet = false
    @State private var showingEditTaskSheet: Task? // Para editar una tarea existente

    // Para inicializar el ViewModel con el contexto adecuado
    init(context: NSManagedObjectContext) {
        _viewModel = StateObject(wrappedValue: TaskListViewModel(context: context))
    }

    var body: some View {
        NavigationView {
            VStack {
                SearchBar(text: $viewModel.searchText)

                List {
                    ForEach(viewModel.tasks) { task in
                        HStack {
                            Image(systemName: task.isCompleted ? "checkmark.circle.fill" : "circle")
                                .foregroundColor(task.isCompleted ? .green : .gray)
                                .onTapGesture {
                                    viewModel.toggleCompletion(for: task)
                                }
                            VStack(alignment: .leading) {
                                Text(task.title ?? "Tarea sin título")
                                    .font(.headline)
                                    .strikethrough(task.isCompleted)
                                Text("Vence: \(task.dueDate ?? Date(), formatter: dateFormatter)")
                                    .font(.subheadline)
                                    .foregroundColor(.secondary)
                                Text("Prioridad: \(task.priority)")
                                    .font(.caption)
                                    .foregroundColor(priorityColor(for: task.priority))
                            }
                            Spacer()
                            // Botón de edición
                            Button(action: {
                                showingEditTaskSheet = task
                            }) {
                                Image(systemName: "pencil")
                                    .foregroundColor(.blue)
                            }
                        }
                        .swipeActions(edge: .trailing) {
                            Button(role: .destructive) {
                                viewModel.deleteTask(at: IndexSet(integer: viewModel.tasks.firstIndex(of: task)!))
                            } label: {
                                Label("Eliminar", systemImage: "trash.fill")
                            }
                        }
                    }
                }
                .navigationTitle("Mis Tareas")
                .toolbar {
                    ToolbarItem(placement: .navigationBarTrailing) {
                        EditButton()
                    }
                    ToolbarItem {
                        Button {
                            showingAddTaskSheet = true
                        } label: {
                            Label("Añadir Tarea", systemImage: "plus.circle.fill")
                        }
                    }
                }
                .sheet(isPresented: $showingAddTaskSheet) {
                    AddTaskView(viewModel: viewModel, isPresented: $showingAddTaskSheet)
                }
                .sheet(item: $showingEditTaskSheet) { taskToEdit in
                    EditTaskView(viewModel: viewModel, taskToEdit: taskToEdit, isPresented: $showingEditTaskSheet)
                }
                .onAppear(perform: viewModel.fetchTasks) // Actualizar al aparecer la vista
            }
        }
    }

    private func priorityColor(for priority: Int16) -> Color {
        switch priority {
        case 1: return .red
        case 2: return .orange
        case 3: return .yellow
        default: return .gray
        }
    }

    private var dateFormatter: DateFormatter {
        let formatter = DateFormatter()
        formatter.dateStyle = .short
        formatter.timeStyle = .short
        return formatter
    }
}

// Pequeño componente SearchBar para el ejemplo
struct SearchBar: View {
    @Binding var text: String

    var body: some View {
        HStack {
            Image(systemName: "magnifyingglass")
                .foregroundColor(.gray)
            TextField("Buscar tareas...", text: $text)
                .padding(7)
                .background(Color(.systemGray6))
                .cornerRadius(8)
                .padding(.horizontal, 10)
            if !text.isEmpty {
                Button(action: { text = "" }) {
                    Image(systemName: "xmark.circle.fill")
                        .foregroundColor(.gray)
                }
                .padding(.trailing, 10)
            }
        }
        .padding(.vertical, 5)
    }
}

// Preview Provider para SwiftUI
struct TaskListContentView_Previews: PreviewProvider {
    static var previews: some View {
        let persistenceController = PersistenceController.preview
        TaskListContentView(context: persistenceController.container.viewContext)
    }
}

Paso 7: Vista para Añadir Tareas (AddTaskView)

Crea un nuevo archivo Swift llamado AddTaskView.swift:

import SwiftUI

struct AddTaskView: View {
    @ObservedObject var viewModel: TaskListViewModel
    @Binding var isPresented: Bool

    @State private var taskTitle: String = ""
    @State private var taskDueDate: Date = Date()
    @State private var taskPriority: Int = 1 // 1: Alta, 2: Media, 3: Baja

    var body: some View {
        NavigationView {
            Form {
                Section(header: Text("Detalles de la Tarea")) {
                    TextField("Título de la tarea", text: $taskTitle)
                    DatePicker("Fecha de vencimiento", selection: $taskDueDate, displayedComponents: .date)
                    Picker("Prioridad", selection: $taskPriority) {
                        Text("Alta").tag(1)
                        Text("Media").tag(2)
                        Text("Baja").tag(3)
                    }
                    .pickerStyle(.segmented)
                }

                Button("Guardar Tarea") {
                    viewModel.addTask(title: taskTitle, dueDate: taskDueDate, priority: Int16(taskPriority))
                    isPresented = false // Cierra la hoja después de guardar
                }
                .disabled(taskTitle.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
            }
            .navigationTitle("Nueva Tarea")
            .navigationBarItems(leading: Button("Cancelar") { isPresented = false })
        }
    }
}

Paso 8: Vista para Editar Tareas (EditTaskView)

Crea un nuevo archivo Swift llamado EditTaskView.swift:

import SwiftUI

struct EditTaskView: View {
    @ObservedObject var viewModel: TaskListViewModel
    @Binding var isPresented: Task?

    @State private var editedTitle: String
    @State private var editedDueDate: Date
    @State private var editedPriority: Int
    @State private var editedIsCompleted: Bool

    let taskToEdit: Task

    init(viewModel: TaskListViewModel, taskToEdit: Task, isPresented: Binding<Task?>) {
        self.viewModel = viewModel
        self.taskToEdit = taskToEdit
        self._isPresented = isPresented

        _editedTitle = State(initialValue: taskToEdit.title ?? "")
        _editedDueDate = State(initialValue: taskToEdit.dueDate ?? Date())
        _editedPriority = State(initialValue: Int(taskToEdit.priority))
        _editedIsCompleted = State(initialValue: taskToEdit.isCompleted)
    }

    var body: some View {
        NavigationView {
            Form {
                Section(header: Text("Editar Detalles de la Tarea")) {
                    TextField("Título", text: $editedTitle)
                    DatePicker("Fecha de Vencimiento", selection: $editedDueDate, displayedComponents: .date)
                    Picker("Prioridad", selection: $editedPriority) {
                        Text("Alta").tag(1)
                        Text("Media").tag(2)
                        Text("Baja").tag(3)
                    }
                    .pickerStyle(.segmented)
                    Toggle(isOn: $editedIsCompleted) {
                        Text("Completada")
                    }
                }

                Button("Guardar Cambios") {
                    viewModel.updateTask(task: taskToEdit,
                                       newTitle: editedTitle,
                                       newDueDate: editedDueDate,
                                       newPriority: Int16(editedPriority),
                                       isCompleted: editedIsCompleted)
                    isPresented = nil // Cierra la hoja
                }
                .disabled(editedTitle.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
            }
            .navigationTitle("Editar Tarea")
            .navigationBarItems(leading: Button("Cancelar") { isPresented = nil })
        }
    }
}

Paso 9: Integración en la App Principal

Finalmente, asegurémonos de que nuestro TaskListContentView sea el punto de entrada de la aplicación y que reciba el NSManagedObjectContext adecuado.

En tu archivo CoreDataMVVMApp.swift (el archivo principal de tu aplicación):

import SwiftUI

@main
struct CoreDataMVVMApp: App {
    let persistenceController = PersistenceController.shared

    var body: some Scene {
        WindowGroup {
            TaskListContentView(context: persistenceController.container.viewContext)
                .environment(\.managedObjectContext, persistenceController.container.viewContext)
        }
    }
}

Aquí estamos inyectando el managedObjectContext en el entorno de SwiftUI. Esto permite que cualquier vista descendiente pueda acceder a él si es necesario (por ejemplo, con @Environment(\.managedObjectContext)), aunque en nuestro caso el ViewModel lo gestiona directamente.

🔍 Fetches Avanzados: Predicados y Ordenación

Core Data ofrece potentes herramientas para consultar tus datos. Ya vimos NSPredicate para filtrar por searchText y NSSortDescriptor para ordenar.

Filtrado y Búsqueda

El NSPredicate es increíblemente versátil. Permite crear condiciones de filtrado complejas. En nuestro fetchTasks, ya usamos:

request.predicate = NSPredicate(format: "title CONTAINS[cd] %@", searchText)

Aquí, CONTAINS[cd] busca subtítulos ignorando mayúsculas y minúsculas (la c de case-insensitive y la d de diacritic-insensitive). Otros ejemplos:

• Igualdad: NSPredicate(format: "isCompleted == %@", NSNumber(value: true))
• Rango de Fechas: NSPredicate(format: "dueDate >= %@ AND dueDate <= %@", startDate as NSDate, endDate as NSDate)
• Múltiples condiciones: NSPredicate(format: "priority == %d AND isCompleted == NO", 1)

Ordenación Personalizada

NSSortDescriptor permite ordenar los resultados de tus fetches. Puedes usar múltiples descriptores para una ordenación multinivel.

request.sortDescriptors = [
    NSSortDescriptor(keyPath: \Task.priority, ascending: true),
    NSSortDescriptor(keyPath: \Task.dueDate, ascending: true)
]

Esto ordenará primero por prioridad (ascendente) y luego, para tareas con la misma prioridad, por fecha de vencimiento (ascendente).

🔄 Migración de Esquemas: Evolucionando tu Modelo de Datos

Una de las características más potentes y a menudo subestimadas de Core Data es su capacidad para gestionar la evolución de tu modelo de datos. A medida que tu aplicación crece, es probable que necesites añadir nuevas entidades, atributos o relaciones. La migración de esquemas permite actualizar los datos existentes de los usuarios a un nuevo formato sin perder información.

Tipos de Migración

Core Data ofrece varios niveles de migración:

1. Migración Ligera (Lightweight Migration): Es el tipo más común y fácil de usar. Core Data puede inferir automáticamente los cambios en tu modelo si son simples (añadir un atributo opcional, eliminar un atributo, cambiar el nombre de una entidad o atributo sin cambiar su tipo). Simplemente añades un nuevo .xcdatamodeld (una nueva versión del modelo) y Core Data se encarga del resto.
2. Migración Manual/Pesada (Heavyweight Migration): Para cambios más complejos que la migración ligera no puede manejar (cambiar tipos de atributos, añadir atributos no opcionales sin valor por defecto, fusionar entidades, etc.), necesitas crear un NSEntityMapping y clases de NSMappingModel para definir cómo se transforman los datos.

Realizando una Migración Ligera (Añadiendo un Atributo)

Vamos a añadir un nuevo atributo a nuestra entidad Task para demostrar una migración ligera.

Después de estos pasos, si lanzas la aplicación en un dispositivo o simulador que ya tenía datos de la versión anterior, Core Data debería migrar automáticamente los datos, añadiendo el atributo notes (con valor nil ya que es opcional) a las tareas existentes.

🎯 Consideraciones Avanzadas y Mejores Prácticas

Para llevar tu uso de Core Data al siguiente nivel, considera estas mejores prácticas.

Hilos y Contextos

Core Data no es thread-safe para los NSManagedObjectContext y los NSManagedObject mismos. Cada contexto debe usarse en el hilo donde fue creado. El NSPersistentContainer viene con un viewContext que está ligado al hilo principal (main queue). Para operaciones en segundo plano, debes crear contextos privados (newBackgroundContext()).

// Ejemplo de operación en segundo plano
func importDataInBackground() {
    container.performBackgroundTask { backgroundContext in
        // Realiza operaciones de Core Data aquí en un hilo de fondo
        let newEntity = MyEntity(context: backgroundContext)
        newEntity.property = "Some value"

        do {
            try backgroundContext.save()
        } catch {
            print("Error saving background context: \(error)")
        }
    }
}

Esto es crucial para evitar freezes en la UI al realizar operaciones de larga duración.

Rendimiento: Batching y Fetched Results Controller

Para grandes conjuntos de datos, Core Data ofrece NSBatchDeleteRequest y NSBatchUpdateRequest para operaciones masivas sin cargar todos los objetos en memoria. Para colecciones que cambian dinámicamente, NSFetchedResultsController (que SwiftUI ahora maneja con @FetchRequest) es fundamental para optimizar las actualizaciones de la UI.

Testabilidad del ViewModel

El patrón MVVM ayuda a que tu ViewModel sea más fácilmente testeable. Puedes inicializar TaskListViewModel con un NSManagedObjectContext en memoria (inMemory: true en PersistenceController) para tus tests, aislando la lógica de negocio de la persistencia real.

// En tu test target
func testAddTask() {
    let mockPersistence = PersistenceController(inMemory: true)
    let viewModel = TaskListViewModel(context: mockPersistence.container.viewContext)

    let initialTaskCount = viewModel.tasks.count
    viewModel.addTask(title: "Test Task", dueDate: Date(), priority: 1)

    XCTAssertEqual(viewModel.tasks.count, initialTaskCount + 1)
    XCTAssertEqual(viewModel.tasks.last?.title, "Test Task")
}

📝 Resumen y Próximos Pasos

Hemos cubierto un terreno considerable en este tutorial, desde la configuración inicial de Core Data en un proyecto SwiftUI hasta la implementación de un robusto patrón MVVM, el modelado de datos, las operaciones CRUD, el manejo de búsquedas y ordenación, y una introducción a la migración de esquemas.

Has aprendido a:

• ✅ Configurar Core Data en un proyecto SwiftUI.
• ✅ Diseñar entidades, atributos y relaciones en el modelo de datos.
• ✅ Implementar un ViewModel reactivo usando ObservableObject y @Published.
• ✅ Conectar las vistas de SwiftUI con el ViewModel para crear, leer, actualizar y borrar tareas.
• ✅ Utilizar NSPredicate y NSSortDescriptor para consultas avanzadas.
• ✅ Entender los principios de la migración ligera de Core Data.
• ✅ Explorar consideraciones sobre threading y rendimiento.

Core Data es una herramienta poderosa que, una vez dominada, se convierte en un activo invaluable para cualquier desarrollador iOS. Te anima a experimentar con más tipos de relaciones (uno-a-uno, uno-a-muchos, muchos-a-muchos), a explorar la validación de atributos y a implementar transformables para tipos de datos personalizados.

¡Felicidades, ahora tienes una base sólida para construir aplicaciones iOS con persistencia de datos profesional!