We use cookies on this site to enhance your user experience

Sep 12 2018, 6:48 PM PST 15 min

Data stores are a storage feature for Roblox games. They can be used to save data which should persist between game sessions, including items in a player’s inventory, experience points, or almost anything else.

Data stores are shared per game, so any place in a game, including places in different servers, can access and change the same data.

Structure

A data store is essentially a dictionary, like a Lua table. Each value in the data store can be indexed by a unique key which includes the player’s Player/UserId|UserId, for instance:

Key Value
Player_1234 50
Player_2345 20
Player_7462 78000
Player_8934 1200
Player_10345 0

Data Store Access

Data stores are managed by DataStoreService, so your scripts must get the service before doing much else:

local DataStoreService = game:GetService("DataStoreService")

Once you’ve included DataStoreService in your script, a data store can be accessed by name using the DataStoreService/GetDataStore|GetDataStore() function. For example:

local experienceStore = DataStoreService:GetDataStore("PlayerExperience")

Managing a Data Store

Setting Data

GlobalDataStore/SetAsync|SetAsync() sets the value of a new data store entry. This function requires the key name of the entry and the value to set.

local DataStoreService = game:GetService("DataStoreService")
local experienceStore = DataStoreService:GetDataStore("PlayerExperience")

local success, err = pcall(function()
	experienceStore:SetAsync("Player_1234", 50)
end)

if success then
	print("Success!")
end

Reading Data

The GlobalDataStore/GetAsync|GetAsync() function reads the value of a data store entry. It requires just the key name of the entry.

local DataStoreService = game:GetService("DataStoreService")
local experienceStore = DataStoreService:GetDataStore("PlayerExperience")

local success, currentExperience = pcall(function()
	return experienceStore:GetAsync("Player_1234")
end)

if success then
	print("Current Experience:", currentExperience)
end

Incrementing Data

GlobalDataStore/IncrementAsync|IncrementAsync() changes a numerical value in a data store. This function requires the key name of the entry and a number indicating how much to change the value.

local DataStoreService = game:GetService("DataStoreService")
local experienceStore = DataStoreService:GetDataStore("PlayerExperience")

local success, newExperience = pcall(function()
	return experienceStore:IncrementAsync("Player_1234", 1)
end)

if success then
	print("New Experience:", newExperience)
end

Updating Data

GlobalDataStore/UpdateAsync|UpdateAsync() changes any stored value in a data store. This function requires the key name of the entry plus a function which defines how the entry should be updated. This function takes the current value and returns the new value, based on whatever logic you define.

local DataStoreService = game:GetService("DataStoreService")
local nicknameStore = DataStoreService:GetDataStore("Nicknames")
 
local function makeNameUpper(currentName)
	local newName = string.upper(currentName)
	return newName
end
 
local success, newName = pcall(function()
	return nicknameStore:UpdateAsync("Player_1234", makeNameUpper)
end)

if success then
	print("Uppercase Name:", newName)
end

Removing Data

GlobalDataStore/RemoveAsync|RemoveAsync() removes an entry from a data store and returns the value that was associated with the key.

local DataStoreService = game:GetService("DataStoreService")
local nicknameStore = DataStoreService:GetDataStore("Nicknames")

local success, nickname = pcall(function()
	return nicknameStore:RemoveAsync("Player_1234")
end)

if success then
	print("Removed Nickname:", nickname)
end

Data Store Events

Each key in a data store can fire an event when its value changes. This can be connected to a custom function by GlobalDataStore/OnUpdate|OnUpdate() which requires the key name of the entry plus the function to call when the event occurs.

local DataStoreService = game:GetService("DataStoreService")
local levelStore = DataStoreService:GetDataStore("PlayerLevel")

local connection

local function onLevelUpdate(newLevel)
	if newLevel == 50 then
		print("Player has reached max level!")
		-- Disconnect connection when player reaches max level
		connection:Disconnect()
	end
end
 
connection = experienceStore:OnUpdate("Player_1234", onLevelUpdate)

local success, err = pcall(function()
	levelStore:IncrementAsync("Player_1234", 1)
end)

Ordered Data Stores

Regular data stores do not sort their content. This isn’t a concern for many games, but sometimes it’s useful to get data in an ordered fashion, like leaderboard stats.

An OrderedDataStore is a special type of data store that can:

  • Easily return its content in a sorted order.
  • Return multiple records in one request (versus a regular data store where you can only request one entry at a time).

An ordered data store uses the same functions as a regular data store including GlobalDataStore/GetAsync|GetAsync(), GlobalDataStore/SetAsync|SetAsync(), GlobalDataStore/UpdateAsync|UpdateAsync(), etc. In addition, it provides the OrderedDataStore/GetSortedAsync|GetSortedAsync() function which accepts parameters for the “page size” of the returned DataStorePages object, the sort order, and minimum/maximum values.

Consider an ordered data store populated with five characters and their ages. This example sorts the data into pages with 3 entries each, in descending order, then loops through the pages and outputs each character’s name/age.

Error Handling / Limits

Requests to data stores, like all network calls, may occasionally fail due to poor connectivity or other issues. As you’ve seen throughout this article, it’s important to wrap data store commands in pcall() and handle any resulting errors. Every error message contains an error code that you can cross-reference in the Articles/Datastore Errors|Data Store Errors and Limits tables.

In addition, there are Articles/Datastore Errors|limits applied to the data store model. If a game exceeds these limits, the Roblox engine will automatically throttle the game’s data store usage, causing data requests to take longer.

Using Data Stores in Studio

By default, places simulated in Studio do not have access to data stores, so any request function like GlobalDataStore/SetAsync|SetAsync() or GlobalDataStore/GetAsync|GetAsync() will cause an error if called from Studio.

If desired, data stores can be enabled in Studio as follows:

  1. Go to the Create menu on the Roblox site.
  2. Select Configure Game for the desired game.
  1. In the Basic Settings tab, check Enable Studio Access to API Services.
  1. Click Save to register your changes.

Now that you understand data stores, the primary request commands, and the basic limits, learn how to implement a functional data store in Articles/Saving Player Data|Saving Player Data.

Tags:
  • data
  • storage