diff options
Diffstat (limited to 'OpenSim/Region/Storage')
3 files changed, 0 insertions, 1288 deletions
diff --git a/OpenSim/Region/Storage/OpenSim.DataStore.DB4o/DB4oDataStore.cs b/OpenSim/Region/Storage/OpenSim.DataStore.DB4o/DB4oDataStore.cs deleted file mode 100644 index 5380e7b..0000000 --- a/OpenSim/Region/Storage/OpenSim.DataStore.DB4o/DB4oDataStore.cs +++ /dev/null | |||
@@ -1,132 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSim Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Text; | ||
31 | |||
32 | using OpenSim.Region.Environment.Scenes; | ||
33 | using OpenSim.Region.Environment.LandManagement; | ||
34 | using OpenSim.Region.Environment; | ||
35 | using OpenSim.Region.Interfaces; | ||
36 | using OpenSim.Framework.Console; | ||
37 | using libsecondlife; | ||
38 | |||
39 | using Db4objects.Db4o; | ||
40 | using Db4objects.Db4o.Query; | ||
41 | |||
42 | namespace OpenSim.DataStore.DB4oStorage | ||
43 | { | ||
44 | public class SceneObjectQuery : Predicate | ||
45 | { | ||
46 | private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); | ||
47 | |||
48 | private LLUUID globalIDSearch; | ||
49 | |||
50 | public SceneObjectQuery(LLUUID find) | ||
51 | { | ||
52 | globalIDSearch = find; | ||
53 | } | ||
54 | |||
55 | public bool Match(SceneObjectGroup obj) | ||
56 | { | ||
57 | return obj.UUID == globalIDSearch; | ||
58 | } | ||
59 | } | ||
60 | |||
61 | public class DB4oDataStore : IRegionDataStore | ||
62 | { | ||
63 | private IObjectContainer db; | ||
64 | |||
65 | public void Initialise(string dbfile, string dbname) | ||
66 | { | ||
67 | m_log.Info("[DATASTORE]: DB4O - Opening " + dbfile); | ||
68 | db = Db4oFactory.OpenFile(dbfile); | ||
69 | } | ||
70 | |||
71 | public void StoreObject(SceneObjectGroup obj, LLUUID regionUUID) | ||
72 | { | ||
73 | db.Set(obj); | ||
74 | } | ||
75 | |||
76 | public void RemoveObject(LLUUID obj, LLUUID regionUUID) | ||
77 | { | ||
78 | IObjectSet result = db.Query(new SceneObjectQuery(obj)); | ||
79 | if (result.Count > 0) | ||
80 | { | ||
81 | SceneObjectGroup item = (SceneObjectGroup)result.Next(); | ||
82 | db.Delete(item); | ||
83 | } | ||
84 | } | ||
85 | |||
86 | public List<SceneObjectGroup> LoadObjects(LLUUID regionUUID) | ||
87 | { | ||
88 | IObjectSet result = db.Get(typeof(SceneObjectGroup)); | ||
89 | List<SceneObjectGroup> retvals = new List<SceneObjectGroup>(); | ||
90 | |||
91 | m_log.Info("[DATASTORE]: DB4O - LoadObjects found " + result.Count.ToString() + " objects"); | ||
92 | |||
93 | foreach (Object obj in result) | ||
94 | { | ||
95 | retvals.Add((SceneObjectGroup)obj); | ||
96 | } | ||
97 | |||
98 | return retvals; | ||
99 | } | ||
100 | |||
101 | public void StoreTerrain(double[,] ter) | ||
102 | { | ||
103 | } | ||
104 | |||
105 | public double[,] LoadTerrain() | ||
106 | { | ||
107 | return null; | ||
108 | } | ||
109 | |||
110 | public void RemoveLandObject(uint id) | ||
111 | { | ||
112 | } | ||
113 | |||
114 | public void StoreParcel(Land parcel) | ||
115 | { | ||
116 | } | ||
117 | |||
118 | public List<Land> LoadLandObjects() | ||
119 | { | ||
120 | return new List<Land>(); | ||
121 | } | ||
122 | |||
123 | public void Shutdown() | ||
124 | { | ||
125 | if (db != null) | ||
126 | { | ||
127 | db.Commit(); | ||
128 | db.Close(); | ||
129 | } | ||
130 | } | ||
131 | } | ||
132 | } | ||
diff --git a/OpenSim/Region/Storage/OpenSim.DataStore.DB4o/Properties/AssemblyInfo.cs b/OpenSim/Region/Storage/OpenSim.DataStore.DB4o/Properties/AssemblyInfo.cs deleted file mode 100644 index 0416779..0000000 --- a/OpenSim/Region/Storage/OpenSim.DataStore.DB4o/Properties/AssemblyInfo.cs +++ /dev/null | |||
@@ -1,62 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSim Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System.Reflection; | ||
29 | using System.Runtime.CompilerServices; | ||
30 | using System.Runtime.InteropServices; | ||
31 | |||
32 | // General information about an assembly is controlled through the following | ||
33 | // set of attributes. Change these attribute values to modify the information | ||
34 | // associated with an assembly. | ||
35 | [assembly: AssemblyTitle("OpenSim.DataStore.DB4o")] | ||
36 | [assembly: AssemblyDescription("")] | ||
37 | [assembly: AssemblyConfiguration("")] | ||
38 | [assembly: AssemblyCompany("")] | ||
39 | [assembly: AssemblyProduct("OpenSim.DataStore.DB4o")] | ||
40 | [assembly: AssemblyCopyright("Copyright (c) 2007")] | ||
41 | [assembly: AssemblyTrademark("")] | ||
42 | [assembly: AssemblyCulture("")] | ||
43 | |||
44 | // Setting ComVisible to false makes the types in this assembly not visible | ||
45 | // to COM components. If you need to access a type in this assembly from | ||
46 | // COM, set the ComVisible attribute to true on that type. | ||
47 | [assembly: ComVisible(false)] | ||
48 | |||
49 | // The following GUID is for the ID of the typelib if this project is exposed to COM | ||
50 | [assembly: Guid("7a12de8b-fdd1-48f5-89a9-8dc2dafbeebc")] | ||
51 | |||
52 | // Version information for an assembly consists of the following four values: | ||
53 | // | ||
54 | // Major Version | ||
55 | // Minor Version | ||
56 | // Build Number | ||
57 | // Revision | ||
58 | // | ||
59 | // You can specify all the values or you can default the Revision and Build Numbers | ||
60 | // by using the '*' as shown below: | ||
61 | [assembly: AssemblyVersion("1.0.0.0")] | ||
62 | [assembly: AssemblyFileVersion("1.0.0.0")] | ||
diff --git a/OpenSim/Region/Storage/OpenSim.DataStore.MSSQL/MSSQLDataStore.cs b/OpenSim/Region/Storage/OpenSim.DataStore.MSSQL/MSSQLDataStore.cs deleted file mode 100644 index edbb1b7..0000000 --- a/OpenSim/Region/Storage/OpenSim.DataStore.MSSQL/MSSQLDataStore.cs +++ /dev/null | |||
@@ -1,1094 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSim Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Data; | ||
31 | using System.Data.SqlClient; | ||
32 | using System.IO; | ||
33 | using System.Reflection; | ||
34 | using libsecondlife; | ||
35 | using log4net; | ||
36 | using OpenSim.Data; | ||
37 | using OpenSim.Framework; | ||
38 | using OpenSim.Region.Environment.Interfaces; | ||
39 | using OpenSim.Region.Environment.Scenes; | ||
40 | |||
41 | namespace OpenSim.DataStore.MSSQL | ||
42 | { | ||
43 | public class MSSQLDataStore : IRegionDataStore | ||
44 | { | ||
45 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
46 | |||
47 | private const string primSelect = "select * from prims"; | ||
48 | private const string shapeSelect = "select * from primshapes"; | ||
49 | private const string terrainSelect = "select * from terrain"; | ||
50 | |||
51 | private DataSet ds; | ||
52 | private SqlDataAdapter primDa; | ||
53 | private SqlDataAdapter shapeDa; | ||
54 | private SqlDataAdapter terrainDa; | ||
55 | |||
56 | // see IRegionDataStore | ||
57 | public void Initialise(string dbfile, bool persistPrimInventories) | ||
58 | { | ||
59 | IniFile GridDataMySqlFile = new IniFile("mssql_connection.ini"); | ||
60 | string settingDataSource = GridDataMySqlFile.ParseFileReadValue("data_source"); | ||
61 | string settingInitialCatalog = GridDataMySqlFile.ParseFileReadValue("initial_catalog"); | ||
62 | string settingPersistSecurityInfo = GridDataMySqlFile.ParseFileReadValue("persist_security_info"); | ||
63 | string settingUserId = GridDataMySqlFile.ParseFileReadValue("user_id"); | ||
64 | string settingPassword = GridDataMySqlFile.ParseFileReadValue("password"); | ||
65 | |||
66 | string connectionString = "Data Source=" + settingDataSource + ";Initial Catalog=" + settingInitialCatalog + | ||
67 | ";Persist Security Info=" + settingPersistSecurityInfo + ";User ID=" + | ||
68 | settingUserId + ";Password=" + settingPassword + ";"; | ||
69 | |||
70 | ds = new DataSet(); | ||
71 | |||
72 | m_log.Info("[DATASTORE]: MSSQL - connecting: " + settingInitialCatalog); | ||
73 | SqlConnection conn = new SqlConnection(connectionString); | ||
74 | SqlCommand primSelectCmd = new SqlCommand(primSelect, conn); | ||
75 | primDa = new SqlDataAdapter(primSelectCmd); | ||
76 | // SqlCommandBuilder primCb = new SqlCommandBuilder(primDa); | ||
77 | |||
78 | SqlCommand shapeSelectCmd = new SqlCommand(shapeSelect, conn); | ||
79 | shapeDa = new SqlDataAdapter(shapeSelectCmd); | ||
80 | // SqlCommandBuilder shapeCb = new SqlCommandBuilder(shapeDa); | ||
81 | |||
82 | SqlCommand terrainSelectCmd = new SqlCommand(terrainSelect, conn); | ||
83 | terrainDa = new SqlDataAdapter(terrainSelectCmd); | ||
84 | |||
85 | |||
86 | // We fill the data set, now we've got copies in memory for the information | ||
87 | // TODO: see if the linkage actually holds. | ||
88 | // primDa.FillSchema(ds, SchemaType.Source, "PrimSchema"); | ||
89 | TestTables(conn); | ||
90 | |||
91 | lock (ds) | ||
92 | { | ||
93 | ds.Tables.Add(createPrimTable()); | ||
94 | setupPrimCommands(primDa, conn); | ||
95 | primDa.Fill(ds.Tables["prims"]); | ||
96 | |||
97 | ds.Tables.Add(createShapeTable()); | ||
98 | setupShapeCommands(shapeDa, conn); | ||
99 | |||
100 | ds.Tables.Add(createTerrainTable()); | ||
101 | setupTerrainCommands(terrainDa, conn); | ||
102 | |||
103 | // WORKAROUND: This is a work around for Sql on | ||
104 | // windows, which gets really unhappy with blob columns | ||
105 | // that have no sample data in them. At some point we | ||
106 | // need to actually find a proper way to handle this. | ||
107 | try | ||
108 | { | ||
109 | shapeDa.Fill(ds.Tables["primshapes"]); | ||
110 | } | ||
111 | catch (Exception) | ||
112 | { | ||
113 | m_log.Info("[DATASTORE]: Caught fill error on primshapes table"); | ||
114 | } | ||
115 | try | ||
116 | { | ||
117 | terrainDa.Fill(ds.Tables["terrain"]); | ||
118 | } | ||
119 | catch (Exception) | ||
120 | { | ||
121 | m_log.Info("[DATASTORE]: Caught fill error on terrain table"); | ||
122 | } | ||
123 | return; | ||
124 | } | ||
125 | } | ||
126 | |||
127 | public void StoreRegionSettings(RegionSettings rs) | ||
128 | { | ||
129 | } | ||
130 | |||
131 | public RegionSettings LoadRegionSettings(LLUUID regionUUID) | ||
132 | { | ||
133 | return null; | ||
134 | } | ||
135 | |||
136 | public void StoreObject(SceneObjectGroup obj, LLUUID regionUUID) | ||
137 | { | ||
138 | lock (ds) | ||
139 | { | ||
140 | foreach (SceneObjectPart prim in obj.Children.Values) | ||
141 | { | ||
142 | //m_log.Info("[DATASTORE]: Adding obj: " + obj.UUID + " to region: " + regionUUID); | ||
143 | addPrim(prim, obj.UUID, regionUUID); | ||
144 | } | ||
145 | } | ||
146 | |||
147 | Commit(); | ||
148 | // m_log.Info("Dump of prims:", ds.GetXml()); | ||
149 | } | ||
150 | |||
151 | public void RemoveObject(LLUUID obj, LLUUID regionUUID) | ||
152 | { | ||
153 | m_log.InfoFormat("[DATASTORE]: Removing obj: {0} from region: {1}", obj.UUID, regionUUID); | ||
154 | |||
155 | DataTable prims = ds.Tables["prims"]; | ||
156 | DataTable shapes = ds.Tables["primshapes"]; | ||
157 | |||
158 | string selectExp = "SceneGroupID = '" + obj.ToString() + "'"; | ||
159 | lock (ds) | ||
160 | { | ||
161 | DataRow[] primRows = prims.Select(selectExp); | ||
162 | foreach (DataRow row in primRows) | ||
163 | { | ||
164 | LLUUID uuid = new LLUUID((string) row["UUID"]); | ||
165 | DataRow shapeRow = shapes.Rows.Find(uuid); | ||
166 | if (shapeRow != null) | ||
167 | { | ||
168 | shapeRow.Delete(); | ||
169 | } | ||
170 | row.Delete(); | ||
171 | } | ||
172 | } | ||
173 | |||
174 | Commit(); | ||
175 | } | ||
176 | |||
177 | public List<SceneObjectGroup> LoadObjects(LLUUID regionUUID) | ||
178 | { | ||
179 | Dictionary<LLUUID, SceneObjectGroup> createdObjects = new Dictionary<LLUUID, SceneObjectGroup>(); | ||
180 | |||
181 | List<SceneObjectGroup> retvals = new List<SceneObjectGroup>(); | ||
182 | |||
183 | DataTable prims = ds.Tables["prims"]; | ||
184 | DataTable shapes = ds.Tables["primshapes"]; | ||
185 | |||
186 | string byRegion = "RegionUUID = '" + regionUUID.ToString() + "'"; | ||
187 | string orderByParent = "ParentID ASC"; | ||
188 | |||
189 | lock (ds) | ||
190 | { | ||
191 | DataRow[] primsForRegion = prims.Select(byRegion, orderByParent); | ||
192 | m_log.Info("[DATASTORE]: " + | ||
193 | "Loaded " + primsForRegion.Length + " prims for region: " + regionUUID); | ||
194 | |||
195 | foreach (DataRow primRow in primsForRegion) | ||
196 | { | ||
197 | try | ||
198 | { | ||
199 | string uuid = (string) primRow["UUID"]; | ||
200 | string objID = (string) primRow["SceneGroupID"]; | ||
201 | if (uuid == objID) //is new SceneObjectGroup ? | ||
202 | { | ||
203 | SceneObjectGroup group = new SceneObjectGroup(); | ||
204 | SceneObjectPart prim = buildPrim(primRow); | ||
205 | DataRow shapeRow = shapes.Rows.Find(prim.UUID); | ||
206 | if (shapeRow != null) | ||
207 | { | ||
208 | prim.Shape = buildShape(shapeRow); | ||
209 | } | ||
210 | else | ||
211 | { | ||
212 | m_log.Info( | ||
213 | "No shape found for prim in storage, so setting default box shape"); | ||
214 | prim.Shape = PrimitiveBaseShape.Default; | ||
215 | } | ||
216 | group.AddPart(prim); | ||
217 | group.RootPart = prim; | ||
218 | |||
219 | createdObjects.Add(group.UUID, group); | ||
220 | retvals.Add(group); | ||
221 | } | ||
222 | else | ||
223 | { | ||
224 | SceneObjectPart prim = buildPrim(primRow); | ||
225 | DataRow shapeRow = shapes.Rows.Find(prim.UUID); | ||
226 | if (shapeRow != null) | ||
227 | { | ||
228 | prim.Shape = buildShape(shapeRow); | ||
229 | } | ||
230 | else | ||
231 | { | ||
232 | m_log.Info( | ||
233 | "No shape found for prim in storage, so setting default box shape"); | ||
234 | prim.Shape = PrimitiveBaseShape.Default; | ||
235 | } | ||
236 | createdObjects[new LLUUID(objID)].AddPart(prim); | ||
237 | } | ||
238 | } | ||
239 | catch (Exception e) | ||
240 | { | ||
241 | m_log.Error("[DATASTORE]: Failed create prim object, exception and data follows"); | ||
242 | m_log.Info("[DATASTORE]: " + e.ToString()); | ||
243 | foreach (DataColumn col in prims.Columns) | ||
244 | { | ||
245 | m_log.Info("[DATASTORE]: Col: " + col.ColumnName + " => " + primRow[col]); | ||
246 | } | ||
247 | } | ||
248 | } | ||
249 | } | ||
250 | return retvals; | ||
251 | } | ||
252 | |||
253 | |||
254 | public void StoreTerrain(double[,] ter, LLUUID regionID) | ||
255 | { | ||
256 | int revision = Util.UnixTimeSinceEpoch(); | ||
257 | |||
258 | m_log.Info("[DATASTORE]: Storing terrain revision r" + revision.ToString()); | ||
259 | |||
260 | DataTable terrain = ds.Tables["terrain"]; | ||
261 | lock (ds) | ||
262 | { | ||
263 | DataRow newrow = terrain.NewRow(); | ||
264 | fillTerrainRow(newrow, regionID, revision, ter); | ||
265 | terrain.Rows.Add(newrow); | ||
266 | |||
267 | Commit(); | ||
268 | } | ||
269 | } | ||
270 | |||
271 | public double[,] LoadTerrain(LLUUID regionID) | ||
272 | { | ||
273 | double[,] terret = new double[256,256]; | ||
274 | terret.Initialize(); | ||
275 | |||
276 | DataTable terrain = ds.Tables["terrain"]; | ||
277 | |||
278 | lock (ds) | ||
279 | { | ||
280 | DataRow[] rows = terrain.Select("RegionUUID = '" + regionID.ToString() + "'", "Revision DESC"); | ||
281 | |||
282 | int rev = 0; | ||
283 | |||
284 | if (rows.Length > 0) | ||
285 | { | ||
286 | DataRow row = rows[0]; | ||
287 | |||
288 | byte[] heightmap = (byte[]) row["Heightfield"]; | ||
289 | for (int x = 0; x < 256; x++) | ||
290 | { | ||
291 | for (int y = 0; y < 256; y++) | ||
292 | { | ||
293 | terret[x, y] = BitConverter.ToDouble(heightmap, ((x*256) + y)*8); | ||
294 | } | ||
295 | } | ||
296 | |||
297 | rev = (int) row["Revision"]; | ||
298 | } | ||
299 | else | ||
300 | { | ||
301 | m_log.Info("[DATASTORE]: No terrain found for region"); | ||
302 | return null; | ||
303 | } | ||
304 | |||
305 | |||
306 | m_log.Info("[DATASTORE]: Loaded terrain revision r" + rev.ToString()); | ||
307 | } | ||
308 | |||
309 | return terret; | ||
310 | } | ||
311 | |||
312 | public void RemoveLandObject(LLUUID globalID) | ||
313 | { | ||
314 | } | ||
315 | |||
316 | public void StoreLandObject(ILandObject parcel) | ||
317 | { | ||
318 | } | ||
319 | |||
320 | public List<LandData> LoadLandObjects(LLUUID regionUUID) | ||
321 | { | ||
322 | return new List<LandData>(); | ||
323 | } | ||
324 | |||
325 | public void Commit() | ||
326 | { | ||
327 | lock (ds) | ||
328 | { | ||
329 | primDa.Update(ds, "prims"); | ||
330 | shapeDa.Update(ds, "primshapes"); | ||
331 | terrainDa.Update(ds, "terrain"); | ||
332 | ds.AcceptChanges(); | ||
333 | } | ||
334 | } | ||
335 | |||
336 | public void Shutdown() | ||
337 | { | ||
338 | Commit(); | ||
339 | } | ||
340 | |||
341 | /*********************************************************************** | ||
342 | * | ||
343 | * Database Definition Functions | ||
344 | * | ||
345 | * This should be db agnostic as we define them in ADO.NET terms | ||
346 | * | ||
347 | **********************************************************************/ | ||
348 | |||
349 | private static void createCol(DataTable dt, string name, Type type) | ||
350 | { | ||
351 | DataColumn col = new DataColumn(name, type); | ||
352 | dt.Columns.Add(col); | ||
353 | } | ||
354 | |||
355 | private static DataTable createTerrainTable() | ||
356 | { | ||
357 | DataTable terrain = new DataTable("terrain"); | ||
358 | |||
359 | createCol(terrain, "RegionUUID", typeof (String)); | ||
360 | createCol(terrain, "Revision", typeof (Int32)); | ||
361 | createCol(terrain, "Heightfield", typeof (Byte[])); | ||
362 | |||
363 | return terrain; | ||
364 | } | ||
365 | |||
366 | private static DataTable createPrimTable() | ||
367 | { | ||
368 | DataTable prims = new DataTable("prims"); | ||
369 | |||
370 | createCol(prims, "UUID", typeof (String)); | ||
371 | createCol(prims, "RegionUUID", typeof (String)); | ||
372 | createCol(prims, "ParentID", typeof (Int32)); | ||
373 | createCol(prims, "CreationDate", typeof (Int32)); | ||
374 | createCol(prims, "Name", typeof (String)); | ||
375 | createCol(prims, "SceneGroupID", typeof (String)); | ||
376 | // various text fields | ||
377 | createCol(prims, "Text", typeof (String)); | ||
378 | createCol(prims, "Description", typeof (String)); | ||
379 | createCol(prims, "SitName", typeof (String)); | ||
380 | createCol(prims, "TouchName", typeof (String)); | ||
381 | // permissions | ||
382 | createCol(prims, "ObjectFlags", typeof (Int32)); | ||
383 | createCol(prims, "CreatorID", typeof (String)); | ||
384 | createCol(prims, "OwnerID", typeof (String)); | ||
385 | createCol(prims, "GroupID", typeof (String)); | ||
386 | createCol(prims, "LastOwnerID", typeof (String)); | ||
387 | createCol(prims, "OwnerMask", typeof (Int32)); | ||
388 | createCol(prims, "NextOwnerMask", typeof (Int32)); | ||
389 | createCol(prims, "GroupMask", typeof (Int32)); | ||
390 | createCol(prims, "EveryoneMask", typeof (Int32)); | ||
391 | createCol(prims, "BaseMask", typeof (Int32)); | ||
392 | // vectors | ||
393 | createCol(prims, "PositionX", typeof (Double)); | ||
394 | createCol(prims, "PositionY", typeof (Double)); | ||
395 | createCol(prims, "PositionZ", typeof (Double)); | ||
396 | createCol(prims, "GroupPositionX", typeof (Double)); | ||
397 | createCol(prims, "GroupPositionY", typeof (Double)); | ||
398 | createCol(prims, "GroupPositionZ", typeof (Double)); | ||
399 | createCol(prims, "VelocityX", typeof (Double)); | ||
400 | createCol(prims, "VelocityY", typeof (Double)); | ||
401 | createCol(prims, "VelocityZ", typeof (Double)); | ||
402 | createCol(prims, "AngularVelocityX", typeof (Double)); | ||
403 | createCol(prims, "AngularVelocityY", typeof (Double)); | ||
404 | createCol(prims, "AngularVelocityZ", typeof (Double)); | ||
405 | createCol(prims, "AccelerationX", typeof (Double)); | ||
406 | createCol(prims, "AccelerationY", typeof (Double)); | ||
407 | createCol(prims, "AccelerationZ", typeof (Double)); | ||
408 | // quaternions | ||
409 | createCol(prims, "RotationX", typeof (Double)); | ||
410 | createCol(prims, "RotationY", typeof (Double)); | ||
411 | createCol(prims, "RotationZ", typeof (Double)); | ||
412 | createCol(prims, "RotationW", typeof (Double)); | ||
413 | |||
414 | // sit target | ||
415 | createCol(prims, "SitTargetOffsetX", typeof (Double)); | ||
416 | createCol(prims, "SitTargetOffsetY", typeof (Double)); | ||
417 | createCol(prims, "SitTargetOffsetZ", typeof (Double)); | ||
418 | |||
419 | createCol(prims, "SitTargetOrientW", typeof (Double)); | ||
420 | createCol(prims, "SitTargetOrientX", typeof (Double)); | ||
421 | createCol(prims, "SitTargetOrientY", typeof (Double)); | ||
422 | createCol(prims, "SitTargetOrientZ", typeof (Double)); | ||
423 | |||
424 | // Add in contraints | ||
425 | prims.PrimaryKey = new DataColumn[] {prims.Columns["UUID"]}; | ||
426 | |||
427 | return prims; | ||
428 | } | ||
429 | |||
430 | private static DataTable createShapeTable() | ||
431 | { | ||
432 | DataTable shapes = new DataTable("primshapes"); | ||
433 | createCol(shapes, "UUID", typeof (String)); | ||
434 | // shape is an enum | ||
435 | createCol(shapes, "Shape", typeof (Int32)); | ||
436 | // vectors | ||
437 | createCol(shapes, "ScaleX", typeof (Double)); | ||
438 | createCol(shapes, "ScaleY", typeof (Double)); | ||
439 | createCol(shapes, "ScaleZ", typeof (Double)); | ||
440 | // paths | ||
441 | createCol(shapes, "PCode", typeof (Int32)); | ||
442 | createCol(shapes, "PathBegin", typeof (Int32)); | ||
443 | createCol(shapes, "PathEnd", typeof (Int32)); | ||
444 | createCol(shapes, "PathScaleX", typeof (Int32)); | ||
445 | createCol(shapes, "PathScaleY", typeof (Int32)); | ||
446 | createCol(shapes, "PathShearX", typeof (Int32)); | ||
447 | createCol(shapes, "PathShearY", typeof (Int32)); | ||
448 | createCol(shapes, "PathSkew", typeof (Int32)); | ||
449 | createCol(shapes, "PathCurve", typeof (Int32)); | ||
450 | createCol(shapes, "PathRadiusOffset", typeof (Int32)); | ||
451 | createCol(shapes, "PathRevolutions", typeof (Int32)); | ||
452 | createCol(shapes, "PathTaperX", typeof (Int32)); | ||
453 | createCol(shapes, "PathTaperY", typeof (Int32)); | ||
454 | createCol(shapes, "PathTwist", typeof (Int32)); | ||
455 | createCol(shapes, "PathTwistBegin", typeof (Int32)); | ||
456 | // profile | ||
457 | createCol(shapes, "ProfileBegin", typeof (Int32)); | ||
458 | createCol(shapes, "ProfileEnd", typeof (Int32)); | ||
459 | createCol(shapes, "ProfileCurve", typeof (Int32)); | ||
460 | createCol(shapes, "ProfileHollow", typeof (Int32)); | ||
461 | // text TODO: this isn't right, but I'm not sure the right | ||
462 | // way to specify this as a blob atm | ||
463 | createCol(shapes, "Texture", typeof (Byte[])); | ||
464 | createCol(shapes, "ExtraParams", typeof (Byte[])); | ||
465 | |||
466 | shapes.PrimaryKey = new DataColumn[] {shapes.Columns["UUID"]}; | ||
467 | |||
468 | return shapes; | ||
469 | } | ||
470 | |||
471 | /*********************************************************************** | ||
472 | * | ||
473 | * Convert between ADO.NET <=> OpenSim Objects | ||
474 | * | ||
475 | * These should be database independant | ||
476 | * | ||
477 | **********************************************************************/ | ||
478 | |||
479 | private static SceneObjectPart buildPrim(DataRow row) | ||
480 | { | ||
481 | // TODO: this doesn't work yet because something more | ||
482 | // interesting has to be done to actually get these values | ||
483 | // back out. Not enough time to figure it out yet. | ||
484 | SceneObjectPart prim = new SceneObjectPart(); | ||
485 | prim.UUID = new LLUUID((String) row["UUID"]); | ||
486 | // explicit conversion of integers is required, which sort | ||
487 | // of sucks. No idea if there is a shortcut here or not. | ||
488 | prim.ParentID = Convert.ToUInt32(row["ParentID"]); | ||
489 | prim.CreationDate = Convert.ToInt32(row["CreationDate"]); | ||
490 | prim.Name = (String) row["Name"]; | ||
491 | // various text fields | ||
492 | prim.Text = (String) row["Text"]; | ||
493 | prim.Description = (String) row["Description"]; | ||
494 | prim.SitName = (String) row["SitName"]; | ||
495 | prim.TouchName = (String) row["TouchName"]; | ||
496 | // permissions | ||
497 | prim.ObjectFlags = Convert.ToUInt32(row["ObjectFlags"]); | ||
498 | prim.CreatorID = new LLUUID((String) row["CreatorID"]); | ||
499 | prim.OwnerID = new LLUUID((String) row["OwnerID"]); | ||
500 | prim.GroupID = new LLUUID((String) row["GroupID"]); | ||
501 | prim.LastOwnerID = new LLUUID((String) row["LastOwnerID"]); | ||
502 | prim.OwnerMask = Convert.ToUInt32(row["OwnerMask"]); | ||
503 | prim.NextOwnerMask = Convert.ToUInt32(row["NextOwnerMask"]); | ||
504 | prim.GroupMask = Convert.ToUInt32(row["GroupMask"]); | ||
505 | prim.EveryoneMask = Convert.ToUInt32(row["EveryoneMask"]); | ||
506 | prim.BaseMask = Convert.ToUInt32(row["BaseMask"]); | ||
507 | // vectors | ||
508 | prim.OffsetPosition = new LLVector3( | ||
509 | Convert.ToSingle(row["PositionX"]), | ||
510 | Convert.ToSingle(row["PositionY"]), | ||
511 | Convert.ToSingle(row["PositionZ"]) | ||
512 | ); | ||
513 | prim.GroupPosition = new LLVector3( | ||
514 | Convert.ToSingle(row["GroupPositionX"]), | ||
515 | Convert.ToSingle(row["GroupPositionY"]), | ||
516 | Convert.ToSingle(row["GroupPositionZ"]) | ||
517 | ); | ||
518 | prim.Velocity = new LLVector3( | ||
519 | Convert.ToSingle(row["VelocityX"]), | ||
520 | Convert.ToSingle(row["VelocityY"]), | ||
521 | Convert.ToSingle(row["VelocityZ"]) | ||
522 | ); | ||
523 | prim.AngularVelocity = new LLVector3( | ||
524 | Convert.ToSingle(row["AngularVelocityX"]), | ||
525 | Convert.ToSingle(row["AngularVelocityY"]), | ||
526 | Convert.ToSingle(row["AngularVelocityZ"]) | ||
527 | ); | ||
528 | prim.Acceleration = new LLVector3( | ||
529 | Convert.ToSingle(row["AccelerationX"]), | ||
530 | Convert.ToSingle(row["AccelerationY"]), | ||
531 | Convert.ToSingle(row["AccelerationZ"]) | ||
532 | ); | ||
533 | // quaternions | ||
534 | prim.RotationOffset = new LLQuaternion( | ||
535 | Convert.ToSingle(row["RotationX"]), | ||
536 | Convert.ToSingle(row["RotationY"]), | ||
537 | Convert.ToSingle(row["RotationZ"]), | ||
538 | Convert.ToSingle(row["RotationW"]) | ||
539 | ); | ||
540 | |||
541 | try | ||
542 | { | ||
543 | prim.SitTargetPositionLL = new LLVector3( | ||
544 | Convert.ToSingle(row["SitTargetOffsetX"]), | ||
545 | Convert.ToSingle(row["SitTargetOffsetY"]), | ||
546 | Convert.ToSingle(row["SitTargetOffsetZ"])); | ||
547 | prim.SitTargetOrientationLL = new LLQuaternion( | ||
548 | Convert.ToSingle( | ||
549 | row["SitTargetOrientX"]), | ||
550 | Convert.ToSingle( | ||
551 | row["SitTargetOrientY"]), | ||
552 | Convert.ToSingle( | ||
553 | row["SitTargetOrientZ"]), | ||
554 | Convert.ToSingle( | ||
555 | row["SitTargetOrientW"])); | ||
556 | } | ||
557 | catch (InvalidCastException) | ||
558 | { | ||
559 | // Database table was created before we got here and now has null values :P | ||
560 | } | ||
561 | |||
562 | return prim; | ||
563 | } | ||
564 | |||
565 | |||
566 | private static void fillPrimRow(DataRow row, SceneObjectPart prim, LLUUID sceneGroupID, LLUUID regionUUID) | ||
567 | { | ||
568 | row["UUID"] = prim.UUID; | ||
569 | row["RegionUUID"] = regionUUID; | ||
570 | row["ParentID"] = prim.ParentID; | ||
571 | row["CreationDate"] = prim.CreationDate; | ||
572 | row["Name"] = prim.Name; | ||
573 | row["SceneGroupID"] = sceneGroupID; // the UUID of the root part for this SceneObjectGroup | ||
574 | // various text fields | ||
575 | row["Text"] = prim.Text; | ||
576 | row["Description"] = prim.Description; | ||
577 | row["SitName"] = prim.SitName; | ||
578 | row["TouchName"] = prim.TouchName; | ||
579 | // permissions | ||
580 | row["ObjectFlags"] = prim.ObjectFlags; | ||
581 | row["CreatorID"] = prim.CreatorID; | ||
582 | row["OwnerID"] = prim.OwnerID; | ||
583 | row["GroupID"] = prim.GroupID; | ||
584 | row["LastOwnerID"] = prim.LastOwnerID; | ||
585 | row["OwnerMask"] = prim.OwnerMask; | ||
586 | row["NextOwnerMask"] = prim.NextOwnerMask; | ||
587 | row["GroupMask"] = prim.GroupMask; | ||
588 | row["EveryoneMask"] = prim.EveryoneMask; | ||
589 | row["BaseMask"] = prim.BaseMask; | ||
590 | // vectors | ||
591 | row["PositionX"] = prim.OffsetPosition.X; | ||
592 | row["PositionY"] = prim.OffsetPosition.Y; | ||
593 | row["PositionZ"] = prim.OffsetPosition.Z; | ||
594 | row["GroupPositionX"] = prim.GroupPosition.X; | ||
595 | row["GroupPositionY"] = prim.GroupPosition.Y; | ||
596 | row["GroupPositionZ"] = prim.GroupPosition.Z; | ||
597 | row["VelocityX"] = prim.Velocity.X; | ||
598 | row["VelocityY"] = prim.Velocity.Y; | ||
599 | row["VelocityZ"] = prim.Velocity.Z; | ||
600 | row["AngularVelocityX"] = prim.AngularVelocity.X; | ||
601 | row["AngularVelocityY"] = prim.AngularVelocity.Y; | ||
602 | row["AngularVelocityZ"] = prim.AngularVelocity.Z; | ||
603 | row["AccelerationX"] = prim.Acceleration.X; | ||
604 | row["AccelerationY"] = prim.Acceleration.Y; | ||
605 | row["AccelerationZ"] = prim.Acceleration.Z; | ||
606 | // quaternions | ||
607 | row["RotationX"] = prim.RotationOffset.X; | ||
608 | row["RotationY"] = prim.RotationOffset.Y; | ||
609 | row["RotationZ"] = prim.RotationOffset.Z; | ||
610 | row["RotationW"] = prim.RotationOffset.W; | ||
611 | |||
612 | try | ||
613 | { | ||
614 | // Sit target | ||
615 | LLVector3 sitTargetPos = prim.SitTargetPositionLL; | ||
616 | row["SitTargetOffsetX"] = sitTargetPos.X; | ||
617 | row["SitTargetOffsetY"] = sitTargetPos.Y; | ||
618 | row["SitTargetOffsetZ"] = sitTargetPos.Z; | ||
619 | |||
620 | LLQuaternion sitTargetOrient = prim.SitTargetOrientationLL; | ||
621 | row["SitTargetOrientW"] = sitTargetOrient.W; | ||
622 | row["SitTargetOrientX"] = sitTargetOrient.X; | ||
623 | row["SitTargetOrientY"] = sitTargetOrient.Y; | ||
624 | row["SitTargetOrientZ"] = sitTargetOrient.Z; | ||
625 | } | ||
626 | catch (Exception) | ||
627 | { | ||
628 | // TODO: Add Sit Target Rows! | ||
629 | } | ||
630 | } | ||
631 | |||
632 | private static PrimitiveBaseShape buildShape(DataRow row) | ||
633 | { | ||
634 | PrimitiveBaseShape s = new PrimitiveBaseShape(); | ||
635 | s.Scale = new LLVector3( | ||
636 | Convert.ToSingle(row["ScaleX"]), | ||
637 | Convert.ToSingle(row["ScaleY"]), | ||
638 | Convert.ToSingle(row["ScaleZ"]) | ||
639 | ); | ||
640 | // paths | ||
641 | s.PCode = Convert.ToByte(row["PCode"]); | ||
642 | s.PathBegin = Convert.ToUInt16(row["PathBegin"]); | ||
643 | s.PathEnd = Convert.ToUInt16(row["PathEnd"]); | ||
644 | s.PathScaleX = Convert.ToByte(row["PathScaleX"]); | ||
645 | s.PathScaleY = Convert.ToByte(row["PathScaleY"]); | ||
646 | s.PathShearX = Convert.ToByte(row["PathShearX"]); | ||
647 | s.PathShearY = Convert.ToByte(row["PathShearY"]); | ||
648 | s.PathSkew = Convert.ToSByte(row["PathSkew"]); | ||
649 | s.PathCurve = Convert.ToByte(row["PathCurve"]); | ||
650 | s.PathRadiusOffset = Convert.ToSByte(row["PathRadiusOffset"]); | ||
651 | s.PathRevolutions = Convert.ToByte(row["PathRevolutions"]); | ||
652 | s.PathTaperX = Convert.ToSByte(row["PathTaperX"]); | ||
653 | s.PathTaperY = Convert.ToSByte(row["PathTaperY"]); | ||
654 | s.PathTwist = Convert.ToSByte(row["PathTwist"]); | ||
655 | s.PathTwistBegin = Convert.ToSByte(row["PathTwistBegin"]); | ||
656 | // profile | ||
657 | s.ProfileBegin = Convert.ToUInt16(row["ProfileBegin"]); | ||
658 | s.ProfileEnd = Convert.ToUInt16(row["ProfileEnd"]); | ||
659 | s.ProfileCurve = Convert.ToByte(row["ProfileCurve"]); | ||
660 | s.ProfileHollow = Convert.ToUInt16(row["ProfileHollow"]); | ||
661 | |||
662 | // text TODO: this isn't right] = but I'm not sure the right | ||
663 | // way to specify this as a blob atm | ||
664 | byte[] textureEntry = (byte[]) row["Texture"]; | ||
665 | s.TextureEntry = textureEntry; | ||
666 | |||
667 | |||
668 | s.ExtraParams = (byte[]) row["ExtraParams"]; | ||
669 | |||
670 | return s; | ||
671 | } | ||
672 | |||
673 | private static void fillShapeRow(DataRow row, SceneObjectPart prim) | ||
674 | { | ||
675 | PrimitiveBaseShape s = prim.Shape; | ||
676 | row["UUID"] = prim.UUID; | ||
677 | // shape is an enum | ||
678 | row["Shape"] = 0; | ||
679 | // vectors | ||
680 | row["ScaleX"] = s.Scale.X; | ||
681 | row["ScaleY"] = s.Scale.Y; | ||
682 | row["ScaleZ"] = s.Scale.Z; | ||
683 | // paths | ||
684 | row["PCode"] = s.PCode; | ||
685 | row["PathBegin"] = s.PathBegin; | ||
686 | row["PathEnd"] = s.PathEnd; | ||
687 | row["PathScaleX"] = s.PathScaleX; | ||
688 | row["PathScaleY"] = s.PathScaleY; | ||
689 | row["PathShearX"] = s.PathShearX; | ||
690 | row["PathShearY"] = s.PathShearY; | ||
691 | row["PathSkew"] = s.PathSkew; | ||
692 | row["PathCurve"] = s.PathCurve; | ||
693 | row["PathRadiusOffset"] = s.PathRadiusOffset; | ||
694 | row["PathRevolutions"] = s.PathRevolutions; | ||
695 | row["PathTaperX"] = s.PathTaperX; | ||
696 | row["PathTaperY"] = s.PathTaperY; | ||
697 | row["PathTwist"] = s.PathTwist; | ||
698 | row["PathTwistBegin"] = s.PathTwistBegin; | ||
699 | // profile | ||
700 | row["ProfileBegin"] = s.ProfileBegin; | ||
701 | row["ProfileEnd"] = s.ProfileEnd; | ||
702 | row["ProfileCurve"] = s.ProfileCurve; | ||
703 | row["ProfileHollow"] = s.ProfileHollow; | ||
704 | // text TODO: this isn't right] = but I'm not sure the right | ||
705 | // way to specify this as a blob atm | ||
706 | |||
707 | // And I couldn't work out how to save binary data either | ||
708 | // seems that the texture colum is being treated as a string in the Datarow | ||
709 | // if you do a .getType() on it, it returns string, while the other columns return correct type | ||
710 | // MW[10-08-07] | ||
711 | // Added following xml hack but not really ideal , also ExtraParams isn't currently part of the database | ||
712 | // am a bit worried about adding it now as some people will have old format databases, so for now including that data in this xml data | ||
713 | // MW[17-08-07] | ||
714 | row["Texture"] = s.TextureEntry; | ||
715 | row["ExtraParams"] = s.ExtraParams; | ||
716 | // TextureBlock textureBlock = new TextureBlock(s.TextureEntry); | ||
717 | // textureBlock.ExtraParams = s.ExtraParams; | ||
718 | // System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding(); | ||
719 | // row["Texture"] = encoding.GetBytes(textureBlock.ToXMLString()); | ||
720 | } | ||
721 | |||
722 | private void addPrim(SceneObjectPart prim, LLUUID sceneGroupID, LLUUID regionUUID) | ||
723 | { | ||
724 | DataTable prims = ds.Tables["prims"]; | ||
725 | DataTable shapes = ds.Tables["primshapes"]; | ||
726 | |||
727 | DataRow primRow = prims.Rows.Find(prim.UUID); | ||
728 | if (primRow == null) | ||
729 | { | ||
730 | primRow = prims.NewRow(); | ||
731 | fillPrimRow(primRow, prim, sceneGroupID, regionUUID); | ||
732 | prims.Rows.Add(primRow); | ||
733 | } | ||
734 | else | ||
735 | { | ||
736 | fillPrimRow(primRow, prim, sceneGroupID, regionUUID); | ||
737 | } | ||
738 | |||
739 | DataRow shapeRow = shapes.Rows.Find(prim.UUID); | ||
740 | if (shapeRow == null) | ||
741 | { | ||
742 | shapeRow = shapes.NewRow(); | ||
743 | fillShapeRow(shapeRow, prim); | ||
744 | shapes.Rows.Add(shapeRow); | ||
745 | } | ||
746 | else | ||
747 | { | ||
748 | fillShapeRow(shapeRow, prim); | ||
749 | } | ||
750 | } | ||
751 | |||
752 | // see IRegionDatastore | ||
753 | public void StorePrimInventory(LLUUID primID, ICollection<TaskInventoryItem> items) | ||
754 | { | ||
755 | // No implementation yet | ||
756 | } | ||
757 | |||
758 | /*********************************************************************** | ||
759 | * | ||
760 | * SQL Statement Creation Functions | ||
761 | * | ||
762 | * These functions create SQL statements for update, insert, and create. | ||
763 | * They can probably be factored later to have a db independant | ||
764 | * portion and a db specific portion | ||
765 | * | ||
766 | **********************************************************************/ | ||
767 | |||
768 | private static SqlCommand createInsertCommand(string table, DataTable dt) | ||
769 | { | ||
770 | /** | ||
771 | * This is subtle enough to deserve some commentary. | ||
772 | * Instead of doing *lots* and *lots of hardcoded strings | ||
773 | * for database definitions we'll use the fact that | ||
774 | * realistically all insert statements look like "insert | ||
775 | * into A(b, c) values(:b, :c) on the parameterized query | ||
776 | * front. If we just have a list of b, c, etc... we can | ||
777 | * generate these strings instead of typing them out. | ||
778 | */ | ||
779 | string[] cols = new string[dt.Columns.Count]; | ||
780 | for (int i = 0; i < dt.Columns.Count; i++) | ||
781 | { | ||
782 | DataColumn col = dt.Columns[i]; | ||
783 | cols[i] = col.ColumnName; | ||
784 | } | ||
785 | |||
786 | string sql = "insert into " + table + "("; | ||
787 | sql += String.Join(", ", cols); | ||
788 | // important, the first ':' needs to be here, the rest get added in the join | ||
789 | sql += ") values (@"; | ||
790 | sql += String.Join(", @", cols); | ||
791 | sql += ")"; | ||
792 | SqlCommand cmd = new SqlCommand(sql); | ||
793 | // this provides the binding for all our parameters, so | ||
794 | // much less code than it used to be | ||
795 | foreach (DataColumn col in dt.Columns) | ||
796 | { | ||
797 | cmd.Parameters.Add(createSqlParameter(col.ColumnName, col.DataType)); | ||
798 | } | ||
799 | return cmd; | ||
800 | } | ||
801 | |||
802 | private static SqlCommand createUpdateCommand(string table, string pk, DataTable dt) | ||
803 | { | ||
804 | string sql = "update " + table + " set "; | ||
805 | string subsql = String.Empty; | ||
806 | foreach (DataColumn col in dt.Columns) | ||
807 | { | ||
808 | if (subsql.Length > 0) | ||
809 | { | ||
810 | // a map function would rock so much here | ||
811 | subsql += ", "; | ||
812 | } | ||
813 | subsql += col.ColumnName + "= @" + col.ColumnName; | ||
814 | } | ||
815 | sql += subsql; | ||
816 | sql += " where " + pk; | ||
817 | SqlCommand cmd = new SqlCommand(sql); | ||
818 | // this provides the binding for all our parameters, so | ||
819 | // much less code than it used to be | ||
820 | |||
821 | foreach (DataColumn col in dt.Columns) | ||
822 | { | ||
823 | cmd.Parameters.Add(createSqlParameter(col.ColumnName, col.DataType)); | ||
824 | } | ||
825 | return cmd; | ||
826 | } | ||
827 | |||
828 | |||
829 | private static string defineTable(DataTable dt) | ||
830 | { | ||
831 | string sql = "create table " + dt.TableName + "("; | ||
832 | string subsql = String.Empty; | ||
833 | foreach (DataColumn col in dt.Columns) | ||
834 | { | ||
835 | if (subsql.Length > 0) | ||
836 | { | ||
837 | // a map function would rock so much here | ||
838 | subsql += ",\n"; | ||
839 | } | ||
840 | subsql += col.ColumnName + " " + SqlType(col.DataType); | ||
841 | if (dt.PrimaryKey.Length > 0 && col == dt.PrimaryKey[0]) | ||
842 | { | ||
843 | subsql += " primary key"; | ||
844 | } | ||
845 | } | ||
846 | sql += subsql; | ||
847 | sql += ")"; | ||
848 | |||
849 | return sql; | ||
850 | } | ||
851 | |||
852 | private static void fillTerrainRow(DataRow row, LLUUID regionUUID, int rev, double[,] val) | ||
853 | { | ||
854 | row["RegionUUID"] = regionUUID; | ||
855 | row["Revision"] = rev; | ||
856 | |||
857 | MemoryStream str = new MemoryStream(65536*sizeof (double)); | ||
858 | BinaryWriter bw = new BinaryWriter(str); | ||
859 | |||
860 | // TODO: COMPATIBILITY - Add byte-order conversions | ||
861 | for (int x = 0; x < 256; x++) | ||
862 | for (int y = 0; y < 256; y++) | ||
863 | bw.Write(val[x, y]); | ||
864 | |||
865 | row["Heightfield"] = str.ToArray(); | ||
866 | } | ||
867 | |||
868 | /*********************************************************************** | ||
869 | * | ||
870 | * Database Binding functions | ||
871 | * | ||
872 | * These will be db specific due to typing, and minor differences | ||
873 | * in databases. | ||
874 | * | ||
875 | **********************************************************************/ | ||
876 | |||
877 | ///<summary> | ||
878 | /// This is a convenience function that collapses 5 repetitive | ||
879 | /// lines for defining SqlParameters to 2 parameters: | ||
880 | /// column name and database type. | ||
881 | /// | ||
882 | /// It assumes certain conventions like :param as the param | ||
883 | /// name to replace in parametrized queries, and that source | ||
884 | /// version is always current version, both of which are fine | ||
885 | /// for us. | ||
886 | ///</summary> | ||
887 | ///<returns>a built Sql parameter</returns> | ||
888 | private static SqlParameter createSqlParameter(string name, Type type) | ||
889 | { | ||
890 | SqlParameter param = new SqlParameter(); | ||
891 | param.ParameterName = "@" + name; | ||
892 | param.DbType = dbtypeFromType(type); | ||
893 | param.SourceColumn = name; | ||
894 | param.SourceVersion = DataRowVersion.Current; | ||
895 | return param; | ||
896 | } | ||
897 | |||
898 | private void setupPrimCommands(SqlDataAdapter da, SqlConnection conn) | ||
899 | { | ||
900 | da.InsertCommand = createInsertCommand("prims", ds.Tables["prims"]); | ||
901 | da.InsertCommand.Connection = conn; | ||
902 | |||
903 | da.UpdateCommand = createUpdateCommand("prims", "UUID=@UUID", ds.Tables["prims"]); | ||
904 | da.UpdateCommand.Connection = conn; | ||
905 | |||
906 | SqlCommand delete = new SqlCommand("delete from prims where UUID = @UUID"); | ||
907 | delete.Parameters.Add(createSqlParameter("UUID", typeof (String))); | ||
908 | delete.Connection = conn; | ||
909 | da.DeleteCommand = delete; | ||
910 | } | ||
911 | |||
912 | private void setupShapeCommands(SqlDataAdapter da, SqlConnection conn) | ||
913 | { | ||
914 | da.InsertCommand = createInsertCommand("primshapes", ds.Tables["primshapes"]); | ||
915 | da.InsertCommand.Connection = conn; | ||
916 | |||
917 | da.UpdateCommand = createUpdateCommand("primshapes", "UUID=@UUID", ds.Tables["primshapes"]); | ||
918 | da.UpdateCommand.Connection = conn; | ||
919 | |||
920 | SqlCommand delete = new SqlCommand("delete from primshapes where UUID = @UUID"); | ||
921 | delete.Parameters.Add(createSqlParameter("UUID", typeof (String))); | ||
922 | delete.Connection = conn; | ||
923 | da.DeleteCommand = delete; | ||
924 | } | ||
925 | |||
926 | private void setupTerrainCommands(SqlDataAdapter da, SqlConnection conn) | ||
927 | { | ||
928 | da.InsertCommand = createInsertCommand("terrain", ds.Tables["terrain"]); | ||
929 | da.InsertCommand.Connection = conn; | ||
930 | } | ||
931 | |||
932 | private static void InitDB(SqlConnection conn) | ||
933 | { | ||
934 | string createPrims = defineTable(createPrimTable()); | ||
935 | string createShapes = defineTable(createShapeTable()); | ||
936 | string createTerrain = defineTable(createTerrainTable()); | ||
937 | |||
938 | SqlCommand pcmd = new SqlCommand(createPrims, conn); | ||
939 | SqlCommand scmd = new SqlCommand(createShapes, conn); | ||
940 | SqlCommand tcmd = new SqlCommand(createTerrain, conn); | ||
941 | conn.Open(); | ||
942 | try | ||
943 | { | ||
944 | pcmd.ExecuteNonQuery(); | ||
945 | pcmd.Dispose(); | ||
946 | } | ||
947 | catch (SqlException) | ||
948 | { | ||
949 | m_log.Warn("[MSSQL]: Primitives Table Already Exists"); | ||
950 | } | ||
951 | |||
952 | try | ||
953 | { | ||
954 | scmd.ExecuteNonQuery(); | ||
955 | scmd.Dispose(); | ||
956 | } | ||
957 | catch (SqlException) | ||
958 | { | ||
959 | m_log.Warn("[MSSQL]: Shapes Table Already Exists"); | ||
960 | } | ||
961 | |||
962 | try | ||
963 | { | ||
964 | tcmd.ExecuteNonQuery(); | ||
965 | tcmd.Dispose(); | ||
966 | } | ||
967 | catch (SqlException) | ||
968 | { | ||
969 | m_log.Warn("[MSSQL]: Terrain Table Already Exists"); | ||
970 | } | ||
971 | |||
972 | conn.Close(); | ||
973 | } | ||
974 | |||
975 | private static bool TestTables(SqlConnection conn) | ||
976 | { | ||
977 | SqlCommand primSelectCmd = new SqlCommand(primSelect, conn); | ||
978 | SqlDataAdapter pDa = new SqlDataAdapter(primSelectCmd); | ||
979 | SqlCommand shapeSelectCmd = new SqlCommand(shapeSelect, conn); | ||
980 | SqlDataAdapter sDa = new SqlDataAdapter(shapeSelectCmd); | ||
981 | SqlCommand terrainSelectCmd = new SqlCommand(terrainSelect, conn); | ||
982 | SqlDataAdapter tDa = new SqlDataAdapter(terrainSelectCmd); | ||
983 | |||
984 | DataSet tmpDS = new DataSet(); | ||
985 | try | ||
986 | { | ||
987 | pDa.Fill(tmpDS, "prims"); | ||
988 | sDa.Fill(tmpDS, "primshapes"); | ||
989 | tDa.Fill(tmpDS, "terrain"); | ||
990 | } | ||
991 | catch (SqlException) | ||
992 | { | ||
993 | m_log.Info("[DATASTORE]: MSSQL Database doesn't exist... creating"); | ||
994 | InitDB(conn); | ||
995 | } | ||
996 | |||
997 | try | ||
998 | { | ||
999 | if (tmpDS.Tables == null || tmpDS.Tables.Count == 0) | ||
1000 | { | ||
1001 | pDa.Fill(tmpDS, "prims"); | ||
1002 | sDa.Fill(tmpDS, "primshapes"); | ||
1003 | tDa.Fill(tmpDS, "terrain"); | ||
1004 | } | ||
1005 | } | ||
1006 | catch (SqlException e) | ||
1007 | { | ||
1008 | m_log.Info("[DATASTORE]: " + e.ToString()); | ||
1009 | } | ||
1010 | |||
1011 | foreach (DataColumn col in createPrimTable().Columns) | ||
1012 | { | ||
1013 | if (!tmpDS.Tables["prims"].Columns.Contains(col.ColumnName)) | ||
1014 | { | ||
1015 | m_log.Info("[DATASTORE]: Missing required column:" + col.ColumnName); | ||
1016 | return false; | ||
1017 | } | ||
1018 | } | ||
1019 | foreach (DataColumn col in createShapeTable().Columns) | ||
1020 | { | ||
1021 | if (!tmpDS.Tables["primshapes"].Columns.Contains(col.ColumnName)) | ||
1022 | { | ||
1023 | m_log.Info("[DATASTORE]: Missing required column:" + col.ColumnName); | ||
1024 | return false; | ||
1025 | } | ||
1026 | } | ||
1027 | foreach (DataColumn col in createTerrainTable().Columns) | ||
1028 | { | ||
1029 | if (!tmpDS.Tables["terrain"].Columns.Contains(col.ColumnName)) | ||
1030 | { | ||
1031 | m_log.Info("[DATASTORE]: Missing require column:" + col.ColumnName); | ||
1032 | return false; | ||
1033 | } | ||
1034 | } | ||
1035 | return true; | ||
1036 | } | ||
1037 | |||
1038 | /*********************************************************************** | ||
1039 | * | ||
1040 | * Type conversion functions | ||
1041 | * | ||
1042 | **********************************************************************/ | ||
1043 | |||
1044 | private static DbType dbtypeFromType(Type type) | ||
1045 | { | ||
1046 | if (type == typeof (String)) | ||
1047 | { | ||
1048 | return DbType.String; | ||
1049 | } | ||
1050 | else if (type == typeof (Int32)) | ||
1051 | { | ||
1052 | return DbType.Int32; | ||
1053 | } | ||
1054 | else if (type == typeof (Double)) | ||
1055 | { | ||
1056 | return DbType.Double; | ||
1057 | } | ||
1058 | else if (type == typeof (Byte[])) | ||
1059 | { | ||
1060 | return DbType.Binary; | ||
1061 | } | ||
1062 | else | ||
1063 | { | ||
1064 | return DbType.String; | ||
1065 | } | ||
1066 | } | ||
1067 | |||
1068 | // this is something we'll need to implement for each db | ||
1069 | // slightly differently. | ||
1070 | private static string SqlType(Type type) | ||
1071 | { | ||
1072 | if (type == typeof (String)) | ||
1073 | { | ||
1074 | return "varchar(255)"; | ||
1075 | } | ||
1076 | else if (type == typeof (Int32)) | ||
1077 | { | ||
1078 | return "integer"; | ||
1079 | } | ||
1080 | else if (type == typeof (Double)) | ||
1081 | { | ||
1082 | return "float"; | ||
1083 | } | ||
1084 | else if (type == typeof (Byte[])) | ||
1085 | { | ||
1086 | return "image"; | ||
1087 | } | ||
1088 | else | ||
1089 | { | ||
1090 | return "string"; | ||
1091 | } | ||
1092 | } | ||
1093 | } | ||
1094 | } | ||