---
product: "AG Studio"
title: "Sharing & Caching Data"
description: "Share AG Studio's built-in data engine across instances, or cache it across a Studio instance's lifecycle."
framework: vue
version: "3.1.0"
related:
    - title: "Data Overview"
      url: "https://www.ag-grid.com/studio/archive/3.1.0/vue/data/"
    - title: "Data Modelling"
      url: "https://www.ag-grid.com/studio/archive/3.1.0/vue/data-modelling/"
    - title: "Loading Data"
      url: "https://www.ag-grid.com/studio/archive/3.1.0/vue/loading-data/"
    - title: "Live Data"
      url: "https://www.ag-grid.com/studio/archive/3.1.0/vue/live-data/"
llms: "https://www.ag-grid.com/studio/archive/3.1.0/llms.txt"
---

# Sharing & Caching Data

A Data Engine loads, processes, and caches data for Studio widgets.

Studio creates one automatically when you pass data sources via the `data` property, but you can create the built-in engine yourself to share it across instances, or cache it across a Studio instance's lifecycle.

## Built-in Engine

When you pass data sources directly to Studio, it creates a built-in Data Engine behind the scenes. Creating the engine externally with `createDataEngine(data)` gives you two benefits:

- **Sharing** - multiple Studio instances can point at the same engine, so they share a single copy of the data.
- **Caching across lifecycles** - the engine survives when Studio is destroyed and recreated, so data doesn't need to be re-fetched or reprocessed on remount.

#### Data Engine

```ts
import type {
  AgDataEngine,
  AgDataSourcesDefinition,
  AgReportState,
} from "ag-studio";
import { createDataEngine, enableStudioDevValidations } from "ag-studio";
import { AgStudio } from "ag-studio-vue3";
import { createApp, defineComponent, onMounted, ref, shallowRef } from "vue";

if (process.env.NODE_ENV !== "production") {
  // Enable extended validations only for development
  enableStudioDevValidations();
}

const VueExample = defineComponent({
  template: `
        <div style="height: 100%">
            <div style="display: flex; flex-direction: column; height: 100%">
                <div class="example-controls">
                    <div class="controls-row">
                        <button v-on:click="recreate()">{{ created ? 'Destroy Studio Instance' : 'Recreate with Data Engine' }}</button>
                    </div>
                </div>
                <ag-studio
                    v-if="created"
                    style="width: 100%; height: 100%;"
                    class="my-studio-container"
                    :initialState="initialState"
                    :mode="'edit'"
                    :data="data"></ag-studio>
                <div class="my-studio-container" v-if="!created">No current Studio instance</div>
            </div>
        </div>
    `,
  components: {
    "ag-studio": AgStudio,
  },
  setup(props) {
    const initialState = ref<AgReportState>({
      pages: [
        {
          id: "page1",
          widgets: {
            "1": {
              type: "grid",
              dataMapping: {
                cols: [
                  { id: "medals.country" },
                  { id: "medals.sport" },
                  { id: "medals.gold", aggregation: "sum" },
                  { id: "medals.silver", aggregation: "sum" },
                  { id: "medals.bronze", aggregation: "sum" },
                  { id: "medals.total", aggregation: "sum" },
                ],
              },
            },
            "2": {
              type: "column-chart-grouped",
              dataMapping: {
                categoryKey: [{ id: "medals.country" }],
                valueKey: [
                  { id: "medals.gold", aggregation: "sum" },
                  { id: "medals.silver", aggregation: "sum" },
                  { id: "medals.bronze", aggregation: "sum" },
                ],
                tooltipKey: [],
              },
            },
          },
          widgetLayout: {
            "1": {
              xTrack: 0,
              yTrack: 0,
              xSpan: 24,
              ySpan: 16,
            },
            "2": {
              xTrack: 0,
              yTrack: 16,
              xSpan: 24,
              ySpan: 16,
            },
          },
        },
      ],
      selectedPageId: "page1",
      panels: {
        filters: {
          collapsed: true,
        },
        edit: {
          collapsed: true,
        },
      },
    });
    const created = ref<boolean>(true);
    const data = shallowRef<AgDataSourcesDefinition | AgDataEngine>(null);

    onMounted(() => {
      fetch("https://www.ag-grid.com/studio/archive/3.1.0/example-assets/olympic-winners.json")
        .then((resp) => resp.json())
        .then(
          (respData) =>
            (data.value = createDataEngine({
              sources: [{ id: "medals", data: respData }],
            })),
        );
    });

    const recreate = () => {
      created.value = !created.value;
    };

    return {
      initialState,
      created,
      data,
      recreate,
    };
  },
});

const app = createApp(VueExample);
app.mount("#app");
```

[Live example: Data Engine](https://www.ag-grid.com/studio/archive/3.1.0/examples/sharing-caching-data/data-engine/vue3/)

```ts
const dataEngine = createDataEngine({
    sources: [{
        id: 'medals',
        data: [
            {
                year: 2000,
                sport: 'Swimming',
                country: 'United States',
                // ... other fields
            },
            // ... other rows
        ],
    }],
});
```

```ts
<ag-studio
    :data="data"
    /* other studio properties ... */>
</ag-studio>

this.data = dataEngine;
```

See [Loading Data](https://www.ag-grid.com/studio/archive/3.1.0/vue/loading-data/) for the full range of data loading patterns.

`createDataEngine(data)` accepts a `data` object of type `AgDataSourcesDefinition`.

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `sources` | `AgDataSource<TRegistry>[]` |  | One or more data sources. |
| `relationships` | `AgRelationDefinition[]` |  | When using multiple related tables, this describes the fields that link the tables together. |
| `expressions` | `AgExpressionFieldDefinition<TRegistry, AgFormat<TRegistry>, any>[]` |  | Expression field definitions for calculated columns. |
| `formats` | `TRegistry["formats"]` |  | Overrides to existing formats, or additional custom formats. |
| `description` | `string` |  | AI-facing overview of the entire dataset: what it contains, what it's for, domain quirks. |
| `calendars` | `AgCalendar[]` |  | Named time dimensions (calendars) that supply date fragments and a continuous date spine. |
| `buckets` | `TRegistry["buckets"]` |  | Additional date-fragment bucket definitions to register alongside the built-in set (year, quarter, month, week, day, monthOfYear, dayOfWeek, …). Use this to add project-specific groupings such as `weekend`, `dayOfMonth`, or `hour` that the built-in registry does not include. Provide via `createBuckets` so type-level registry inference works correctly. |
| `options` | `AgDataSourcesOptions` |  | Engine-wide behavioural options, such as fan-out detection policy. |

## Retrieving the Engine

`api.getDataEngine()` returns the engine the Studio instance is using, whether Studio created it or you passed your own in. It returns `undefined` until the engine is in place, which it is by the time the `studioReady` event fires.

If Studio created the engine, it is released when that Studio instance is destroyed. To keep the engine alive across a destroy and recreate, or to share it between instances, create it with `createDataEngine()` as above and pass it via the `data` property.

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `getDataEngine` | `Function` |  | Returns the data engine this Studio instance is currently using, or `undefined` if it does not have one. A Studio configured without the `data` property never has an engine, and one that is still loading does not have it yet - the engine is in place by the time the `studioReady` event fires. If Studio created the engine, its lifetime is tied to this Studio instance: the engine is released when Studio is destroyed. To keep an engine alive across a Studio instance being destroyed and recreated, or to share one engine between several instances, create it yourself with `createDataEngine()` and pass it via the `data` property. Studio then leaves it in your hands, and `getDataEngine()` returns that same engine. |

## Custom Engines

Sharing and caching, as described above, are features of the built-in engine only. For larger datasets, or when you want to replace query execution with a backend you already own, see the [Custom Engine](https://www.ag-grid.com/studio/archive/3.1.0/vue/server-side-data/) guide in the Server-Side Data section.
