Scripting Helpers is winding down operations and is now read-only. More info→

DataStore request was added to queue. If request queue fills, further Try sending fewer requests??

Asked by

theking66hayday 841

2 years ago

Edited 2 years ago

Hi I keep receiving this error on my House Data Store system: DataStore request was added to queue. If request queue fills, further requests will be dropped. Try sending fewer requests.Key. Script:

001local DataStoreService = game:GetService("DataStoreService")
002 
003local MainData = DataStoreService:GetDataStore("MainData")
004 
005local HouseData = DataStoreService:GetDataStore("HouseData")
006 
007--Variables--
008 
009function saveHouseData(player)
010 
011 
012 
013    local Houses = {}
014 
015    for i, value in pairs(player.Houses:GetChildren()) do
016 
017 
018 
019        Houses[value.Name] = value.Value
020 
021 
022 
023    end
024 
025    HouseData:SetAsync(player.UserId, Houses)
026 
027end
028 
029--House Data--
030 
031game.Players.PlayerAdded:Connect(function(player)
032 
033 
034 
035    local Plot = Instance.new("StringValue")
036 
037    Plot.Name = "Plot"
038 
039    Plot.Value = ""
040 
041    Plot.Parent = player
042 
043 
044 
045    local Houses = Instance.new("Folder")
046 
047    Houses.Name = "Houses"
048 
049    Houses.Parent = player
050 
051 
052 
053    for i, house in pairs(game.ReplicatedStorage.Houses:GetChildren()) do
054 
055        local newValue = Instance.new("BoolValue")
056 
057        newValue.Name = house.Name
058 
059        newValue.Value = false
060 
061        newValue.Parent = Houses
062 
063 
064 
065    end
066 
067    local houseData = HouseData:GetAsync(player.UserId) or {}
068 
069 
070 
071    for houseName, houseValue in pairs(HouseData) 
072 
073        Houses[houseName].Value = houseValue
074 
075    end
076 
077end)
078 
079 
080 
081 
082 
083--House Saving--
084 
085game.Players.PlayerRemoving:Connect(function(player)
086 
087    if game.Workspace:FindFirstChild(player.Name.."'sHouse") then
088 
089        game.Workspace:FindFirstChild(player.Name.."'sHouse"):Destroy()
090 
091    end
092 
093    local PlayerPlot = player.Plot
094 
095 
096 
097    game.Workspace:FindFirstChild(PlayerPlot.Value).CurrentOwner.Value = ""
098 
099    player.Plot.Value = ""
100 
101    end)
102 
103 
104 
105game.Players.PlayerRemoving:Connect(saveHouseData)
106 
107game:BindToClose(function()
108 
109    for i, player in pairs(game.Players:GetPlayers()) do
110 
111        saveHouseData(player)
112 
113        end
114 
115end)
 View all 115 lines...

Updated

I got rid of all errors datastore still doesn't work here is the updated code

001local DataStoreService = game:GetService("DataStoreService")
002 
003local MainData = DataStoreService:GetDataStore("MainData")
004 
005local HouseData = DataStoreService:GetDataStore("HouseData")
006 
007 
008 
009local Players = game:GetService("Players")
010 
011local ReplicatedStorage = game:GetService("ReplicatedStorage")
012 
013local RunService = game:GetService("RunService")
014 
015 
016 
017local function waitForRequestBudget(requestType: Enum.DataStoreRequestType)
018 
019    local currentBudget = DataStoreService:GetRequestBudgetForRequestType(requestType)
020 
021    while currentBudget < 1 do
022 
023        currentBudget = DataStoreService:GetRequestBudgetForRequestType(requestType)
024 
025        task.wait(5)
026 
027    end
028 
029end
030 
031 
032 
033-- House Data --
034 
035game.Players.PlayerAdded:Connect(function(player)
036 
037 
038 
039local Plot = Instance.new("StringValue")
040 
041Plot.Name = "Plot"
042 
043Plot.Value = ""
044 
045    Plot.Parent = player
046 
047 
048 
049    local Houses = Instance.new("Folder")
050 
051    Houses.Name = "Houses"
052 
053    Houses.Parent = player
054 
055    for i, house in pairs(ReplicatedStorage.Houses:GetChildren()) do
056 
057        local newValue = Instance.new("BoolValue")
058 
059        newValue.Name = house.Name
060 
061        newValue.Value = false
062 
063        newValue.Parent = Houses
064 
065 
066 
067    end
068 
069end)
070 
071 
072 
073function loadHouseData(player)
074 
075 
076 
077    local Houses = Players.Houses
078 
079 
080 
081 
082 
083    waitForRequestBudget(Enum.DataStoreRequestType.GetAsync)
084 
085    local success, houseData = pcall(HouseData.GetAsync, HouseData, player.UserId)
086 
087    if success then
088 
089        for houseName, houseValue in pairs(HouseData) do
090 
091            Houses[houseName].Value = houseValue
092 
093    end
094 
095    else -- if it errors (mostly when player has no data)
096 
097    print("Player " .. player.Name .. " has no data!")
098 
099    warn(houseData) -- warns the error message
100 
101end
102 
103end
104 
105 
106 
107-- House Saving --
108 
109function saveHouseData(player)
110 
111    local Houses = {}
112 
113    local success
114 
115    repeat
116 
117        waitForRequestBudget(Enum.DataStoreRequestType.UpdateAsync)
118 
119        success = pcall(HouseData.UpdateAsync, HouseData, player.UserId, function()
120 
121            return Houses       
122 
123        end)
124 
125    until success
126 
127    if workspace:FindFirstChild(player.Name.."'sHouse") then
128 
129        game.Workspace:FindFirstChild(player.Name.."'sHouse"):Destroy()
130 
131    end
132 
133    local Plot = player.Plot
134 
135    local PlayerPlot = player.Plot
136 
137    workspace:FindFirstChild(Plot)player.Plot.Value = ""
138 
139    player.Plot.Value = ""
140 
141 
142 
143    local Houses = {}
144 
145 
146 
147    for i, value in pairs(player.Houses:GetChildren()) do
148 
149        Houses[value.Name] = value.Value
150 
151    end
152 
153end
154 
155for _, player in ipairs(Players:GetPlayers()) do
156 
157    coroutine.wrap(loadHouseData)(player)
158 
159end
160 
161 
162 
163game.Players.PlayerAdded:Connect(function(loadHouseData)
164 
165    game.Players.PlayerRemoving:Connect(saveHouseData)
166 
167 
168 
169    game:BindToClose(function()
170 
171        if RunService:IsStudio() then
172 
173            task.wait(2)
174 
175            print("task waited")
176 
177        else
178 
179 
180 
181            local finished = Instance.new("BindableEvent")
182 
183 
184 
185            local allPlayers = Players:GetPlayers()
186 
187 
188 
189            local leftPlayers = #allPlayers
190 
191            for _, player in ipairs(allPlayers) do
192 
193                coroutine.wrap(function()
194 
195                    saveHouseData(player)
196 
197                    leftPlayers -= 1
198 
199                    if leftPlayers == 0 then
200 
201                        finished:Fire()
202 
203                        print("finishing")
204 
205                    end
206 
207                end)()
208 
209            end
210 
211 
212 
213            finished.Event:Wait()
214 
215end
216 
217        end)
218 
219    end)
 View all 219 lines...

Sorry about the spacing I sent the code to my other computer to post it and the format gets weird theking66hayday 841 — 2y

1 answer

Answered by

T3_MasterGamer 2189

2 years ago

Edited 2 years ago

Solution

This is where RequestBudget comes in. If there isn't enough RequestBudget, it will show that warning. To fix that, you will need to wait until there is enough budget.

1local function waitForRequestBudget(requestType: Enum.DataStoreRequestType)
2    local currentBudget = DataStoreService:GetRequestBudgetForRequestType(requestType)
3    while currentBudget < 1 do
4        currentBudget = DataStoreService:GetRequestBudgetForRequestType(requestType)
5        task.wait(5)
6    end
7end

Now you can use that function in GetAsync() and SetAsync().

1-- House Data --
2waitForRequestBudget(Enum.DataStoreRequestType.GetAsync)
3local houseData = HouseData:GetAsync(player.UserId) or {}
4 
5-- House Saving --
6waitForRequestBudget(Enum.DataStoreRequestType.SetAsync)
7HouseData:SetAsync(player.UserId, Houses)

Pcall (Protected Call)

I recommend using a pcall() when using an asynchronous function since they can error and break the script. pcall() calls a function and if it errors, it won't affect the script and the error message will just get returned by pcall(). If it didn't error and it was successful, pcall() will return everything returned by the called function.

01-- House Data --
02waitForRequestBudget(Enum.DataStoreRequestType.GetAsync)
03 
04local success, houseData = pcall(function()
05    return HouseData:GetAsync(player.UserId)
06end)
07-- or
08local success, houseData = pcall(HouseData.GetAsync, HouseData, player.UserId)
09 
10if success == true then -- if successful
11    for houseName, houseValue in pairs(HouseData) 
12        Houses[houseName].Value = houseValue
13    end
14else -- if it errors (mostly when player has no data)
15    print("Player " .. Player.Name .. " has no data!")
16    warn(houseData) -- warns the error message
17end

Retries

If you use SetAsync() once, there's a chance it might error, not saving the data. What you can do is retry until data is saved.

1-- House Saving --
2local success
3repeat
4    waitForRequestBudget(Enum.DataStoreRequestType.SetAsync)
5    success = pcall(HouseData.SetAsync, HouseData player.UserId, Houses)
6until success == true

UpdateAsync > SetAsync

UpdateAsync() is safer to use in multi-server attempts than SetAsync(), so you should use it except when using an OrderedDataStore (commonly used in global leaderboards).

1-- House Saving --
2local success
3repeat
4    waitForRequestBudget(Enum.DataStoreRequestType.UpdateAsync)
5    success = pcall(HouseData.UpdateAsync, HouseData, player.UserId, function()
6        return Houses
7    end)
8until success == true

Final Script

001local DataStoreService = game:GetService("DataStoreService")
002local MainData = DataStoreService:GetDataStore("MainData")
003local HouseData = DataStoreService:GetDataStore("HouseData")
004 
005local Players = game:GetService("Players")
006local ReplicatedStorage = game:GetService("ReplicatedStorage")
007local RunService = game:GetService("RunService")
008 
009local function waitForRequestBudget(requestType: Enum.DataStoreRequestType)
010    local currentBudget = DataStoreService:GetRequestBudgetForRequestType(requestType)
011    while currentBudget < 1 do
012        currentBudget = DataStoreService:GetRequestBudgetForRequestType(requestType)
013        task.wait(5)
014    end
015end
016 
017-- House Data --
018function loadHouseData(player: Player?)
019    local Plot = Instance.new("StringValue")
020    Plot.Name = "Plot"
021    Plot.Value = ""
022    Plot.Parent = player
023 
024    local Houses = Instance.new("Folder")
025    Houses.Name = "Houses"
026    Houses.Parent = player
027 
028    for i, house in pairs(ReplicatedStorage.Houses:GetChildren()) do
029        local newValue = Instance.new("BoolValue")
030        newValue.Name = house.Name
031        newValue.Value = false
032        newValue.Parent = Houses
033    end
034 
035    waitForRequestBudget(Enum.DataStoreRequestType.GetAsync)
036    local success, houseData
037    local retries = 0
038    repeat
039        waitForRequestBudget(Enum.DataStoreRequestType.GetAsync)
040        success, houseData = pcall(HouseData.GetAsync, HouseData, player.UserId)
041        retries += 1
042    until (success and houseData) or retries >= 5
043 
044    if success then
045        for houseName, houseValue in pairs(houseData) do
046            Houses[houseName].Value = houseValue
047        end
048    else -- if it errors (mostly when player has no data)
049        print("Player " .. Player.Name .. " has no data!")
050        warn(houseData) -- warns the error message
051    end
052end
053 
054-- House Saving --
055function saveHouseData(player: Player, dontWait: boolean?)
056    if workspace:FindFirstChild(player.Name.."'sHouse") then
057        workspace:FindFirstChild(player.Name.."'sHouse"):Destroy()
058    end
059 
060    local PlayerPlot = player.Plot
061    workspace:FindFirstChild(PlayerPlot.Value).CurrentOwner.Value = ""
062    player.Plot.Value = ""
063 
064    local Houses = {}
065 
066    for i, value in pairs(player.Houses:GetChildren()) do
067        Houses[value.Name] = value.Value
068    end
069 
070    local success
071    repeat
072        if not dontWait then
073            waitForRequestBudget(Enum.DataStoreRequestType.UpdateAsync)
074        end
075        success = pcall(HouseData.UpdateAsync, HouseData, player.UserId, function()
076            return Houses
077        end)
078    until success
079end
080 
081for _, player in ipairs(Players:GetPlayers()) do
082    coroutine.wrap(loadHouseData)(player)
083end
084 
085Players.PlayerAdded:Connect(loadHouseData)
086Players.PlayerRemoving:Connect(saveHouseData)
087 
088game:BindToClose(function()
089    if RunService:IsStudio() then
090        task.wait(2)
091    else
092        local finished = Instance.new("BindableEvent")
093        local allPlayers = Players:GetPlayers()
094        local leftPlayers = #allPlayers
095 
096        for _, player in ipairs(allPlayers) do
097            coroutine.wrap(function()
098                saveHouseData(player, true)
099                leftPlayers -= 1
100                if leftPlayers == 0 then
101                    finished:Fire()
102                end
103            end)()
104        end
105 
106        finished.Event:Wait()
107    end
108end)
 View all 108 lines...

Source

It still doesn't work. I edited the script a bit to fix somethings. Errors: First error is when a player doesn't have a plot claimed and buys a house and then leaves error code line 123 ServerScriptService.DataManager:121: attempt to index nil with 'CurrentOwner' but if a player does have plot claimed and buys house then leaves no errors come up and won't save data though theking66hayday 841 — 2y

I updated my post with the new code if you can have look at it -- Thanks theking66hayday 841 — 2y

I got rid of all the errors but datastore doesn't work still theking66hayday 841 — 2y

OH T3_MasterGamer 2189 — 2y

View all comments (2 more)

The error was on line 76 and I forgot to removed "function(" so I changed my answer and removed it. T3_MasterGamer 2189 — 2y

ok now I keep getting error on line 38 ServerScriptService.DataManager:38: invalid argument #1 to 'pairs' (table expected, got Instance) theking66hayday 841 — 2y