diff options
author | Melanie Thielker | 2008-11-26 07:34:38 +0000 |
---|---|---|
committer | Melanie Thielker | 2008-11-26 07:34:38 +0000 |
commit | 3efdccbb12fc2d5339870ade39e1b1d54da4fe9b (patch) | |
tree | 5fd5d0e9c802da79aed0579718211507945699cc | |
parent | Next step of the PresenceModule. Still not complete; local optimizations and the (diff) | |
download | opensim-SC_OLD-3efdccbb12fc2d5339870ade39e1b1d54da4fe9b.zip opensim-SC_OLD-3efdccbb12fc2d5339870ade39e1b1d54da4fe9b.tar.gz opensim-SC_OLD-3efdccbb12fc2d5339870ade39e1b1d54da4fe9b.tar.bz2 opensim-SC_OLD-3efdccbb12fc2d5339870ade39e1b1d54da4fe9b.tar.xz |
Committing the LCO database layer. Native MySQL, no ADO. New reconnect
mechanism to prevent prim loss. Preserve link order on sim restart
and drag copy. Fix drag-copied prims' inventories. Fix persistence
of child prim inventories.
Diffstat (limited to '')
-rw-r--r-- | OpenSim/Data/MySQL/MySQLRegionData.cs | 2212 | ||||
-rw-r--r-- | OpenSim/Data/MySQL/Resources/023_RegionStore.sql | 6 | ||||
-rw-r--r-- | OpenSim/Framework/TaskInventoryItem.cs | 1 | ||||
-rw-r--r-- | OpenSim/Region/Environment/Scenes/SceneObjectGroup.cs | 20 | ||||
-rw-r--r-- | OpenSim/Region/Environment/Scenes/SceneObjectPart.cs | 10 | ||||
-rw-r--r-- | OpenSim/Region/Environment/Scenes/SceneObjectPartInventory.cs | 8 |
6 files changed, 778 insertions, 1479 deletions
diff --git a/OpenSim/Data/MySQL/MySQLRegionData.cs b/OpenSim/Data/MySQL/MySQLRegionData.cs index 2e36123..743c0d9 100644 --- a/OpenSim/Data/MySQL/MySQLRegionData.cs +++ b/OpenSim/Data/MySQL/MySQLRegionData.cs | |||
@@ -48,1107 +48,678 @@ namespace OpenSim.Data.MySQL | |||
48 | { | 48 | { |
49 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | 49 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); |
50 | 50 | ||
51 | private const string m_primSelect = "select * from prims"; | 51 | private string m_ConnectionString; |
52 | private const string m_shapeSelect = "select * from primshapes"; | ||
53 | private const string m_itemsSelect = "select * from primitems"; | ||
54 | private const string m_terrainSelect = "select * from terrain limit 1"; | ||
55 | private const string m_landSelect = "select * from land"; | ||
56 | private const string m_landAccessListSelect = "select * from landaccesslist"; | ||
57 | private const string m_regionSettingsSelect = "select * from regionsettings"; | ||
58 | private const string m_waitTimeoutSelect = "select @@wait_timeout"; | ||
59 | |||
60 | private MySqlConnection m_connection; | ||
61 | private string m_connectionString; | ||
62 | 52 | ||
63 | /// <summary> | 53 | private MySqlConnection m_Connection = null; |
64 | /// Wait timeout for our connection in ticks. | ||
65 | /// </summary> | ||
66 | private long m_waitTimeout; | ||
67 | |||
68 | /// <summary> | ||
69 | /// Make our storage of the timeout this amount smaller than it actually is, to give us a margin on long | ||
70 | /// running database operations. | ||
71 | /// </summary> | ||
72 | private long m_waitTimeoutLeeway = 60 * TimeSpan.TicksPerSecond; | ||
73 | |||
74 | /// <summary> | ||
75 | /// Holds the last tick time that the connection was used. | ||
76 | /// </summary> | ||
77 | private long m_lastConnectionUse; | ||
78 | |||
79 | private DataSet m_dataSet; | ||
80 | private MySqlDataAdapter m_primDataAdapter; | ||
81 | private MySqlDataAdapter m_shapeDataAdapter; | ||
82 | private MySqlDataAdapter m_itemsDataAdapter; | ||
83 | private MySqlDataAdapter m_terrainDataAdapter; | ||
84 | private MySqlDataAdapter m_landDataAdapter; | ||
85 | private MySqlDataAdapter m_landAccessListDataAdapter; | ||
86 | private MySqlDataAdapter m_regionSettingsDataAdapter; | ||
87 | |||
88 | private DataTable m_primTable; | ||
89 | private DataTable m_shapeTable; | ||
90 | private DataTable m_itemsTable; | ||
91 | private DataTable m_terrainTable; | ||
92 | private DataTable m_landTable; | ||
93 | private DataTable m_landAccessListTable; | ||
94 | private DataTable m_regionSettingsTable; | ||
95 | |||
96 | /*********************************************************************** | ||
97 | * | ||
98 | * Public Interface Functions | ||
99 | * | ||
100 | **********************************************************************/ | ||
101 | 54 | ||
102 | /// <summary> | ||
103 | /// see IRegionDataStore | ||
104 | /// </summary> | ||
105 | /// <param name="connectionstring"></param> | ||
106 | public void Initialise(string connectionString) | 55 | public void Initialise(string connectionString) |
107 | { | 56 | { |
108 | m_connectionString = connectionString; | 57 | m_ConnectionString = connectionString; |
109 | 58 | ||
110 | m_dataSet = new DataSet(); | 59 | m_Connection = new MySqlConnection(m_ConnectionString); |
111 | 60 | ||
112 | int passPosition = 0; | 61 | m_Connection.Open(); |
113 | int passEndPosition = 0; | ||
114 | string displayConnectionString = null; | ||
115 | |||
116 | try | ||
117 | { // hide the password in the connection string | ||
118 | passPosition = m_connectionString.IndexOf("password", StringComparison.OrdinalIgnoreCase); | ||
119 | passPosition = m_connectionString.IndexOf("=", passPosition); | ||
120 | if (passPosition < m_connectionString.Length) | ||
121 | passPosition += 1; | ||
122 | passEndPosition = m_connectionString.IndexOf(";", passPosition); | ||
123 | |||
124 | displayConnectionString = m_connectionString.Substring(0, passPosition); | ||
125 | displayConnectionString += "***"; | ||
126 | displayConnectionString += m_connectionString.Substring(passEndPosition, m_connectionString.Length - passEndPosition); | ||
127 | } | ||
128 | catch (Exception e ) | ||
129 | { | ||
130 | m_log.Debug("Exception: password not found in connection string\n" + e.ToString()); | ||
131 | } | ||
132 | 62 | ||
133 | m_log.Info("[REGION DB]: MySql - connecting: " + displayConnectionString); | 63 | // Apply new Migrations |
134 | m_connection = new MySqlConnection(m_connectionString); | 64 | // |
135 | m_connection.Open(); | ||
136 | |||
137 | GetWaitTimeout(); | ||
138 | |||
139 | // This actually does the roll forward assembly stuff | ||
140 | Assembly assem = GetType().Assembly; | 65 | Assembly assem = GetType().Assembly; |
141 | Migration m = new Migration(m_connection, assem, "RegionStore"); | 66 | Migration m = new Migration(m_Connection, assem, "RegionStore"); |
142 | m.Update(); | 67 | m.Update(); |
143 | 68 | ||
144 | 69 | // Clean dropped attachments | |
145 | MySqlCommand primSelectCmd = new MySqlCommand(m_primSelect, m_connection); | 70 | // |
146 | m_primDataAdapter = new MySqlDataAdapter(primSelectCmd); | 71 | MySqlCommand cmd = m_Connection.CreateCommand(); |
147 | 72 | cmd.CommandText = "delete from prims, primshapes using prims " + | |
148 | MySqlCommand shapeSelectCmd = new MySqlCommand(m_shapeSelect, m_connection); | 73 | "left join primshapes on prims.uuid = primshapes.uuid " + |
149 | m_shapeDataAdapter = new MySqlDataAdapter(shapeSelectCmd); | 74 | "where PCode = 9 and State <> 0"; |
150 | 75 | ExecuteNonQuery(cmd); | |
151 | MySqlCommand itemsSelectCmd = new MySqlCommand(m_itemsSelect, m_connection); | ||
152 | m_itemsDataAdapter = new MySqlDataAdapter(itemsSelectCmd); | ||
153 | |||
154 | MySqlCommand terrainSelectCmd = new MySqlCommand(m_terrainSelect, m_connection); | ||
155 | m_terrainDataAdapter = new MySqlDataAdapter(terrainSelectCmd); | ||
156 | |||
157 | MySqlCommand landSelectCmd = new MySqlCommand(m_landSelect, m_connection); | ||
158 | m_landDataAdapter = new MySqlDataAdapter(landSelectCmd); | ||
159 | |||
160 | MySqlCommand landAccessListSelectCmd = new MySqlCommand(m_landAccessListSelect, m_connection); | ||
161 | m_landAccessListDataAdapter = new MySqlDataAdapter(landAccessListSelectCmd); | ||
162 | |||
163 | MySqlCommand regionSettingsSelectCmd = new MySqlCommand(m_regionSettingsSelect, m_connection); | ||
164 | m_regionSettingsDataAdapter = new MySqlDataAdapter(regionSettingsSelectCmd); | ||
165 | |||
166 | // TODO: move out the ADO.NET pieces here and just go to the db directly | ||
167 | lock (m_dataSet) | ||
168 | { | ||
169 | m_primTable = createPrimTable(); | ||
170 | m_dataSet.Tables.Add(m_primTable); | ||
171 | SetupPrimCommands(m_primDataAdapter, m_connection); | ||
172 | m_primDataAdapter.Fill(m_primTable); | ||
173 | |||
174 | m_shapeTable = createShapeTable(); | ||
175 | m_dataSet.Tables.Add(m_shapeTable); | ||
176 | SetupShapeCommands(m_shapeDataAdapter, m_connection); | ||
177 | m_shapeDataAdapter.Fill(m_shapeTable); | ||
178 | |||
179 | m_itemsTable = createItemsTable(); | ||
180 | m_dataSet.Tables.Add(m_itemsTable); | ||
181 | SetupItemsCommands(m_itemsDataAdapter, m_connection); | ||
182 | m_itemsDataAdapter.Fill(m_itemsTable); | ||
183 | |||
184 | m_terrainTable = createTerrainTable(); | ||
185 | m_dataSet.Tables.Add(m_terrainTable); | ||
186 | SetupTerrainCommands(m_terrainDataAdapter, m_connection); | ||
187 | m_terrainDataAdapter.Fill(m_terrainTable); | ||
188 | |||
189 | m_landTable = createLandTable(); | ||
190 | m_dataSet.Tables.Add(m_landTable); | ||
191 | setupLandCommands(m_landDataAdapter, m_connection); | ||
192 | m_landDataAdapter.Fill(m_landTable); | ||
193 | |||
194 | m_landAccessListTable = createLandAccessListTable(); | ||
195 | m_dataSet.Tables.Add(m_landAccessListTable); | ||
196 | setupLandAccessCommands(m_landAccessListDataAdapter, m_connection); | ||
197 | m_landAccessListDataAdapter.Fill(m_landAccessListTable); | ||
198 | |||
199 | m_regionSettingsTable = createRegionSettingsTable(); | ||
200 | m_dataSet.Tables.Add(m_regionSettingsTable); | ||
201 | SetupRegionSettingsCommands(m_regionSettingsDataAdapter, m_connection); | ||
202 | m_regionSettingsDataAdapter.Fill(m_regionSettingsTable); | ||
203 | } | ||
204 | } | 76 | } |
205 | 77 | ||
206 | public void Dispose() {} | 78 | private IDataReader ExecuteReader(MySqlCommand c) |
207 | |||
208 | /// <summary> | ||
209 | /// Get the wait_timeout value for our connection | ||
210 | /// </summary> | ||
211 | protected void GetWaitTimeout() | ||
212 | { | 79 | { |
213 | MySqlCommand cmd = new MySqlCommand(m_waitTimeoutSelect, m_connection); | 80 | IDataReader r = null; |
81 | bool errorSeen = false; | ||
214 | 82 | ||
215 | lock (m_dataSet) | 83 | while (true) |
216 | { | 84 | { |
217 | MySqlDataReader dbReader = cmd.ExecuteReader(CommandBehavior.SingleRow); | ||
218 | try | 85 | try |
219 | { | 86 | { |
220 | if (dbReader.Read()) | 87 | r = c.ExecuteReader(); |
221 | { | ||
222 | m_waitTimeout | ||
223 | = Convert.ToInt32(dbReader["@@wait_timeout"]) * TimeSpan.TicksPerSecond + m_waitTimeoutLeeway; | ||
224 | } | ||
225 | |||
226 | cmd.Dispose(); | ||
227 | } | 88 | } |
228 | finally | 89 | catch (MySqlException) |
229 | { | 90 | { |
230 | dbReader.Close(); | 91 | System.Threading.Thread.Sleep(500); |
92 | |||
93 | m_Connection.Close(); | ||
94 | m_Connection.Open(); | ||
95 | |||
96 | if (!errorSeen) | ||
97 | { | ||
98 | errorSeen = true; | ||
99 | continue; | ||
100 | continue; | ||
101 | } | ||
102 | throw; | ||
231 | } | 103 | } |
232 | } | ||
233 | 104 | ||
234 | m_lastConnectionUse = System.DateTime.Now.Ticks; | 105 | break; |
106 | } | ||
235 | 107 | ||
236 | m_log.DebugFormat( | 108 | return r; |
237 | "[REGION DB]: Connection wait timeout {0} seconds", m_waitTimeout / TimeSpan.TicksPerSecond); | ||
238 | } | 109 | } |
239 | 110 | ||
240 | /// <summary> | 111 | private void ExecuteNonQuery(MySqlCommand c) |
241 | /// Should be called before any db operation. This checks to see if the connection has not timed out | ||
242 | /// </summary> | ||
243 | protected void CheckConnection() | ||
244 | { | 112 | { |
245 | //m_log.Debug("[REGION DB]: Checking connection"); | 113 | bool errorSeen = false; |
246 | 114 | ||
247 | long timeNow = System.DateTime.Now.Ticks; | 115 | while (true) |
248 | if (timeNow - m_lastConnectionUse > m_waitTimeout || m_connection.State != ConnectionState.Open) | ||
249 | { | 116 | { |
250 | m_log.DebugFormat("[REGION DB]: Database connection has gone away - reconnecting"); | 117 | try |
251 | |||
252 | lock (m_connection) | ||
253 | { | 118 | { |
254 | m_connection.Close(); | 119 | c.ExecuteNonQuery(); |
255 | m_connection = new MySqlConnection(m_connectionString); | ||
256 | m_connection.Open(); | ||
257 | } | 120 | } |
258 | } | 121 | catch (MySqlException) |
259 | 122 | { | |
260 | // Strictly, we should set this after the actual db operation. But it's more convenient to set here rather | 123 | System.Threading.Thread.Sleep(500); |
261 | // than require the code to call another method - the timeout leeway should be large enough to cover the | ||
262 | // inaccuracy. | ||
263 | m_lastConnectionUse = timeNow; | ||
264 | } | ||
265 | |||
266 | /// <summary> | ||
267 | /// Execute a SQL statement stored in a resource, as a string | ||
268 | /// </summary> | ||
269 | /// <param name="name">the ressource name</param> | ||
270 | /// <param name="dbcon">The database connection handler</param> | ||
271 | public void ExecuteResourceSql(string name, MySqlConnection dbcon) | ||
272 | { | ||
273 | MySqlCommand cmd = new MySqlCommand(getResourceString(name), dbcon); | ||
274 | cmd.ExecuteNonQuery(); | ||
275 | } | ||
276 | 124 | ||
277 | /// <summary> | 125 | m_Connection.Close(); |
278 | /// Extract a named string resource from the embedded resources | 126 | m_Connection.Open(); |
279 | /// </summary> | ||
280 | /// <param name="name">name of embedded resource</param> | ||
281 | /// <returns>string contained within the embedded resource</returns> | ||
282 | private string getResourceString(string name) | ||
283 | { | ||
284 | Assembly assem = GetType().Assembly; | ||
285 | string[] names = assem.GetManifestResourceNames(); | ||
286 | 127 | ||
287 | foreach (string s in names) | 128 | if (!errorSeen) |
288 | { | ||
289 | if (s.EndsWith(name)) | ||
290 | { | ||
291 | using (Stream resource = assem.GetManifestResourceStream(s)) | ||
292 | { | 129 | { |
293 | using (StreamReader resourceReader = new StreamReader(resource)) | 130 | errorSeen = true; |
294 | { | 131 | continue; |
295 | string resourceString = resourceReader.ReadToEnd(); | ||
296 | return resourceString; | ||
297 | } | ||
298 | } | 132 | } |
133 | throw; | ||
299 | } | 134 | } |
135 | |||
136 | break; | ||
300 | } | 137 | } |
301 | throw new Exception(string.Format("Resource '{0}' was not found", name)); | ||
302 | } | 138 | } |
303 | 139 | ||
304 | /// <summary> | 140 | public void Dispose() {} |
305 | /// Adds an object into region storage | 141 | |
306 | /// </summary> | ||
307 | /// <param name="obj">The object</param> | ||
308 | /// <param name="regionUUID">The region UUID</param> | ||
309 | public void StoreObject(SceneObjectGroup obj, UUID regionUUID) | 142 | public void StoreObject(SceneObjectGroup obj, UUID regionUUID) |
310 | { | 143 | { |
311 | lock (m_dataSet) | 144 | uint flags = obj.RootPart.GetEffectiveObjectFlags(); |
145 | |||
146 | // Eligibility check | ||
147 | // | ||
148 | if ((flags & (uint)PrimFlags.Temporary) != 0) | ||
149 | return; | ||
150 | if ((flags & (uint)PrimFlags.TemporaryOnRez) != 0) | ||
151 | return; | ||
152 | |||
153 | lock (m_Connection) | ||
312 | { | 154 | { |
155 | MySqlCommand cmd = m_Connection.CreateCommand(); | ||
156 | |||
313 | foreach (SceneObjectPart prim in obj.Children.Values) | 157 | foreach (SceneObjectPart prim in obj.Children.Values) |
314 | { | 158 | { |
315 | if ((prim.GetEffectiveObjectFlags() & (uint)PrimFlags.Temporary) == 0 | 159 | cmd.Parameters.Clear(); |
316 | && (prim.GetEffectiveObjectFlags() & (uint)PrimFlags.TemporaryOnRez) == 0) | 160 | |
317 | { | 161 | cmd.CommandText = "replace into prims ("+ |
318 | //m_log.Info("[REGION DB]: Adding obj: " + obj.UUID + " to region: " + regionUUID); | 162 | "UUID, ParentID, CreationDate, "+ |
319 | addPrim(prim, obj.UUID, regionUUID); | 163 | "Name, Text, Description, "+ |
320 | } | 164 | "SitName, TouchName, ObjectFlags, "+ |
321 | else | 165 | "OwnerMask, NextOwnerMask, GroupMask, "+ |
322 | { | 166 | "EveryoneMask, BaseMask, PositionX, "+ |
323 | // m_log.Info("[DATASTORE]: Ignoring Physical obj: " + obj.UUID + " in region: " + regionUUID); | 167 | "PositionY, PositionZ, GroupPositionX, "+ |
324 | } | 168 | "GroupPositionY, GroupPositionZ, VelocityX, "+ |
169 | "VelocityY, VelocityZ, AngularVelocityX, "+ | ||
170 | "AngularVelocityY, AngularVelocityZ, "+ | ||
171 | "AccelerationX, AccelerationY, "+ | ||
172 | "AccelerationZ, RotationX, "+ | ||
173 | "RotationY, RotationZ, "+ | ||
174 | "RotationW, SitTargetOffsetX, "+ | ||
175 | "SitTargetOffsetY, SitTargetOffsetZ, "+ | ||
176 | "SitTargetOrientW, SitTargetOrientX, "+ | ||
177 | "SitTargetOrientY, SitTargetOrientZ, "+ | ||
178 | "RegionUUID, CreatorID, "+ | ||
179 | "OwnerID, GroupID, "+ | ||
180 | "LastOwnerID, SceneGroupID, "+ | ||
181 | "PayPrice, PayButton1, "+ | ||
182 | "PayButton2, PayButton3, "+ | ||
183 | "PayButton4, LoopedSound, "+ | ||
184 | "LoopedSoundGain, TextureAnimation, "+ | ||
185 | "OmegaX, OmegaY, OmegaZ, "+ | ||
186 | "CameraEyeOffsetX, CameraEyeOffsetY, "+ | ||
187 | "CameraEyeOffsetZ, CameraAtOffsetX, "+ | ||
188 | "CameraAtOffsetY, CameraAtOffsetZ, "+ | ||
189 | "ForceMouselook, ScriptAccessPin, "+ | ||
190 | "AllowedDrop, DieAtEdge, "+ | ||
191 | "SalePrice, SaleType, "+ | ||
192 | "ColorR, ColorG, ColorB, ColorA, "+ | ||
193 | "ParticleSystem, ClickAction, Material, "+ | ||
194 | "CollisionSound, CollisionSoundVolume, "+ | ||
195 | "LinkNumber) values (" + "?UUID, ?ParentID, "+ | ||
196 | "?CreationDate, ?Name, ?Text, "+ | ||
197 | "?Description, ?SitName, ?TouchName, "+ | ||
198 | "?ObjectFlags, ?OwnerMask, ?NextOwnerMask, "+ | ||
199 | "?GroupMask, ?EveryoneMask, ?BaseMask, "+ | ||
200 | "?PositionX, ?PositionY, ?PositionZ, "+ | ||
201 | "?GroupPositionX, ?GroupPositionY, "+ | ||
202 | "?GroupPositionZ, ?VelocityX, "+ | ||
203 | "?VelocityY, ?VelocityZ, ?AngularVelocityX, "+ | ||
204 | "?AngularVelocityY, ?AngularVelocityZ, "+ | ||
205 | "?AccelerationX, ?AccelerationY, "+ | ||
206 | "?AccelerationZ, ?RotationX, "+ | ||
207 | "?RotationY, ?RotationZ, "+ | ||
208 | "?RotationW, ?SitTargetOffsetX, "+ | ||
209 | "?SitTargetOffsetY, ?SitTargetOffsetZ, "+ | ||
210 | "?SitTargetOrientW, ?SitTargetOrientX, "+ | ||
211 | "?SitTargetOrientY, ?SitTargetOrientZ, "+ | ||
212 | "?RegionUUID, ?CreatorID, ?OwnerID, "+ | ||
213 | "?GroupID, ?LastOwnerID, ?SceneGroupID, "+ | ||
214 | "?PayPrice, ?PayButton1, ?PayButton2, "+ | ||
215 | "?PayButton3, ?PayButton4, ?LoopedSound, "+ | ||
216 | "?LoopedSoundGain, ?TextureAnimation, "+ | ||
217 | "?OmegaX, ?OmegaY, ?OmegaZ, "+ | ||
218 | "?CameraEyeOffsetX, ?CameraEyeOffsetY, "+ | ||
219 | "?CameraEyeOffsetZ, ?CameraAtOffsetX, "+ | ||
220 | "?CameraAtOffsetY, ?CameraAtOffsetZ, "+ | ||
221 | "?ForceMouselook, ?ScriptAccessPin, "+ | ||
222 | "?AllowedDrop, ?DieAtEdge, ?SalePrice, "+ | ||
223 | "?SaleType, ?ColorR, ?ColorG, "+ | ||
224 | "?ColorB, ?ColorA, ?ParticleSystem, "+ | ||
225 | "?ClickAction, ?Material, ?CollisionSound, "+ | ||
226 | "?CollisionSoundVolume, ?LinkNumber)"; | ||
227 | |||
228 | FillPrimCommand(cmd, prim, obj.UUID, regionUUID); | ||
229 | |||
230 | ExecuteNonQuery(cmd); | ||
231 | |||
232 | cmd.Parameters.Clear(); | ||
233 | |||
234 | cmd.CommandText = "replace into primshapes ("+ | ||
235 | "UUID, Shape, ScaleX, ScaleY, "+ | ||
236 | "ScaleZ, PCode, PathBegin, PathEnd, "+ | ||
237 | "PathScaleX, PathScaleY, PathShearX, "+ | ||
238 | "PathShearY, PathSkew, PathCurve, "+ | ||
239 | "PathRadiusOffset, PathRevolutions, "+ | ||
240 | "PathTaperX, PathTaperY, PathTwist, "+ | ||
241 | "PathTwistBegin, ProfileBegin, ProfileEnd, "+ | ||
242 | "ProfileCurve, ProfileHollow, Texture, "+ | ||
243 | "ExtraParams, State) values (?UUID, "+ | ||
244 | "?Shape, ?ScaleX, ?ScaleY, ?ScaleZ, "+ | ||
245 | "?PCode, ?PathBegin, ?PathEnd, "+ | ||
246 | "?PathScaleX, ?PathScaleY, "+ | ||
247 | "?PathShearX, ?PathShearY, "+ | ||
248 | "?PathSkew, ?PathCurve, ?PathRadiusOffset, "+ | ||
249 | "?PathRevolutions, ?PathTaperX, "+ | ||
250 | "?PathTaperY, ?PathTwist, "+ | ||
251 | "?PathTwistBegin, ?ProfileBegin, "+ | ||
252 | "?ProfileEnd, ?ProfileCurve, "+ | ||
253 | "?ProfileHollow, ?Texture, ?ExtraParams, "+ | ||
254 | "?State)"; | ||
255 | |||
256 | FillShapeCommand(cmd, prim); | ||
257 | |||
258 | ExecuteNonQuery(cmd); | ||
325 | } | 259 | } |
326 | Commit(); | ||
327 | } | 260 | } |
328 | } | 261 | } |
329 | 262 | ||
330 | /// <summary> | ||
331 | /// removes an object from region storage | ||
332 | /// </summary> | ||
333 | /// <param name="obj">The object</param> | ||
334 | /// <param name="regionUUID">The Region UUID</param> | ||
335 | public void RemoveObject(UUID obj, UUID regionUUID) | 263 | public void RemoveObject(UUID obj, UUID regionUUID) |
336 | { | 264 | { |
337 | m_log.InfoFormat("[REGION DB]: Removing obj: {0} from region: {1}", obj, regionUUID); | 265 | // Formerly, this used to check the region UUID. |
266 | // That makes no sense, as we remove the contents of a prim | ||
267 | // unconditionally, but the prim dependent on the region ID. | ||
268 | // So, we would destroy an object and cause hard to detect | ||
269 | // issues if we delete the contents only. Deleting it all may | ||
270 | // cause the loss of a prim, but is cleaner. | ||
271 | // It's also faster because it uses the primary key. | ||
272 | // | ||
273 | lock (m_Connection) | ||
274 | { | ||
275 | MySqlCommand cmd = m_Connection.CreateCommand(); | ||
338 | 276 | ||
339 | DataTable prims = m_primTable; | 277 | cmd.CommandText = "select UUID from prims where "+ |
340 | DataTable shapes = m_shapeTable; | 278 | "SceneGroupID= ?UUID"; |
341 | 279 | ||
342 | string selectExp = "SceneGroupID = '" + Util.ToRawUuidString(obj) + "' and RegionUUID = '" + Util.ToRawUuidString(regionUUID) + "'"; | 280 | cmd.Parameters.AddWithValue("UUID", Util.ToRawUuidString(obj)); |
343 | lock (m_dataSet) | 281 | |
344 | { | 282 | List<UUID> uuids = new List<UUID>(); |
345 | DataRow[] primRows = prims.Select(selectExp); | 283 | |
346 | foreach (DataRow row in primRows) | 284 | IDataReader reader = ExecuteReader(cmd); |
285 | |||
286 | try | ||
347 | { | 287 | { |
348 | // Remove shapes row | 288 | while(reader.Read()) |
349 | UUID uuid = new UUID((string) row["UUID"]); | ||
350 | DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(uuid)); | ||
351 | if (shapeRow != null) | ||
352 | { | 289 | { |
353 | shapeRow.Delete(); | 290 | uuids.Add(new UUID(reader["UUID"].ToString())); |
354 | } | 291 | } |
292 | } | ||
293 | finally | ||
294 | { | ||
295 | reader.Close(); | ||
296 | } | ||
355 | 297 | ||
298 | foreach (UUID uuid in uuids) | ||
356 | RemoveItems(uuid); | 299 | RemoveItems(uuid); |
357 | 300 | ||
358 | // Remove prim row | 301 | cmd.CommandText = "delete from prims where SceneGroupID= ?UUID"; |
359 | row.Delete(); | 302 | |
360 | } | 303 | ExecuteNonQuery(cmd); |
361 | Commit(); | 304 | |
305 | cmd.CommandText = "delete from primshapes where UUID = ?UUID"; | ||
306 | |||
307 | ExecuteNonQuery(cmd); | ||
362 | } | 308 | } |
363 | } | 309 | } |
364 | 310 | ||
365 | /// <summary> | ||
366 | /// Remove all persisted items of the given prim. | ||
367 | /// The caller must acquire the necessrary synchronization locks and commit or rollback changes. | ||
368 | /// </summary> | ||
369 | /// <param name="uuid">the Item UUID</param> | ||
370 | private void RemoveItems(UUID uuid) | 311 | private void RemoveItems(UUID uuid) |
371 | { | 312 | { |
372 | String sql = String.Format("primID = '{0}'", uuid); | 313 | lock (m_Connection) |
373 | DataRow[] itemRows = m_itemsTable.Select(sql); | ||
374 | |||
375 | foreach (DataRow itemRow in itemRows) | ||
376 | { | 314 | { |
377 | itemRow.Delete(); | 315 | MySqlCommand cmd = m_Connection.CreateCommand(); |
316 | |||
317 | cmd.CommandText = "delete from primitems where " + | ||
318 | "PrimID = ?PrimID"; | ||
319 | |||
320 | cmd.Parameters.AddWithValue("PrimID", uuid.ToString()); | ||
321 | |||
322 | ExecuteNonQuery(cmd); | ||
378 | } | 323 | } |
379 | } | 324 | } |
380 | 325 | ||
381 | /// <summary> | ||
382 | /// Load persisted objects from region storage. | ||
383 | /// </summary> | ||
384 | /// <param name="regionUUID">the Region UUID</param> | ||
385 | /// <returns>List of loaded groups</returns> | ||
386 | public List<SceneObjectGroup> LoadObjects(UUID regionUUID) | 326 | public List<SceneObjectGroup> LoadObjects(UUID regionUUID) |
387 | { | 327 | { |
388 | Dictionary<UUID, SceneObjectGroup> createdObjects = new Dictionary<UUID, SceneObjectGroup>(); | 328 | UUID lastGroupID = UUID.Zero; |
389 | 329 | List<SceneObjectGroup> objects = new List<SceneObjectGroup>(); | |
390 | List<SceneObjectGroup> retvals = new List<SceneObjectGroup>(); | 330 | List<SceneObjectPart> prims = new List<SceneObjectPart>(); |
391 | 331 | SceneObjectGroup grp = null; | |
392 | DataTable prims = m_primTable; | ||
393 | DataTable shapes = m_shapeTable; | ||
394 | 332 | ||
395 | string byRegion = "RegionUUID = '" + Util.ToRawUuidString(regionUUID) + "'"; | 333 | lock (m_Connection) |
396 | string orderByParent = "ParentID ASC"; | ||
397 | |||
398 | lock (m_dataSet) | ||
399 | { | 334 | { |
400 | CheckConnection(); | 335 | MySqlCommand cmd = m_Connection.CreateCommand(); |
401 | DataRow[] primsForRegion = prims.Select(byRegion, orderByParent); | 336 | |
402 | m_log.Info("[REGION DB]: " + | 337 | cmd.CommandText = "select *, " + |
403 | "Loaded " + primsForRegion.Length + " prims for region: " + regionUUID); | 338 | "case when prims.UUID = SceneGroupID " + |
339 | "then 0 else 1 end as sort from prims " + | ||
340 | "left join primshapes on prims.UUID = primshapes.UUID "+ | ||
341 | "where RegionUUID = ?RegionUUID " + | ||
342 | "order by SceneGroupID asc, sort asc, LinkNumber asc"; | ||
404 | 343 | ||
405 | // First, create all groups | 344 | cmd.Parameters.AddWithValue("RegionUUID", |
406 | foreach (DataRow primRow in primsForRegion) | 345 | Util.ToRawUuidString(regionUUID)); |
346 | |||
347 | IDataReader reader = ExecuteReader(cmd); | ||
348 | |||
349 | try | ||
407 | { | 350 | { |
408 | try | 351 | while (reader.Read()) |
409 | { | 352 | { |
410 | string uuid = (string) primRow["UUID"]; | 353 | SceneObjectPart prim = BuildPrim(reader); |
411 | string objID = (string) primRow["SceneGroupID"]; | 354 | if (reader["Shape"] is DBNull) |
355 | prim.Shape = PrimitiveBaseShape.Default; | ||
356 | else | ||
357 | prim.Shape = BuildShape(reader); | ||
412 | 358 | ||
413 | SceneObjectPart prim = buildPrim(primRow); | 359 | prim.FolderID = prim.UUID; // A relic from when we |
360 | // we thought prims contained | ||
361 | // folder objects. In | ||
362 | // reality, prim == folder | ||
363 | prims.Add(prim); | ||
414 | 364 | ||
415 | if (uuid == objID) //is new SceneObjectGroup ? | 365 | UUID groupID = new UUID(reader["SceneGroupID"].ToString()); |
416 | { | ||
417 | SceneObjectGroup group = new SceneObjectGroup(); | ||
418 | 366 | ||
419 | DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(prim.UUID)); | 367 | if (groupID != lastGroupID) // New SOG |
420 | if (shapeRow != null) | ||
421 | { | ||
422 | prim.Shape = buildShape(shapeRow); | ||
423 | } | ||
424 | else | ||
425 | { | ||
426 | m_log.Info( | ||
427 | "No shape found for prim in storage, so setting default box shape"); | ||
428 | prim.Shape = PrimitiveBaseShape.Default; | ||
429 | } | ||
430 | |||
431 | group.SetRootPart(prim); | ||
432 | createdObjects.Add(group.UUID, group); | ||
433 | retvals.Add(group); | ||
434 | LoadItems(prim); | ||
435 | } | ||
436 | } | ||
437 | catch (Exception e) | ||
438 | { | ||
439 | m_log.Error("[REGION DB]: Failed create prim object, exception and data follows"); | ||
440 | m_log.Info("[REGION DB]: " + e.ToString()); | ||
441 | foreach (DataColumn col in prims.Columns) | ||
442 | { | 368 | { |
443 | m_log.Info("[REGION DB]: Col: " + col.ColumnName + " => " + primRow[col]); | 369 | if (grp != null) |
444 | } | 370 | objects.Add(grp); |
445 | } | ||
446 | } | ||
447 | |||
448 | // Now fill the groups with part data | ||
449 | foreach (DataRow primRow in primsForRegion) | ||
450 | { | ||
451 | try | ||
452 | { | ||
453 | string uuid = (string) primRow["UUID"]; | ||
454 | string objID = (string) primRow["SceneGroupID"]; | ||
455 | 371 | ||
456 | SceneObjectPart prim = buildPrim(primRow); | 372 | lastGroupID = groupID; |
457 | 373 | ||
458 | if (uuid != objID) //is new SceneObjectGroup ? | 374 | grp = new SceneObjectGroup(prim); |
459 | { | ||
460 | DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(prim.UUID)); | ||
461 | if (shapeRow != null) | ||
462 | { | ||
463 | prim.Shape = buildShape(shapeRow); | ||
464 | } | ||
465 | else | ||
466 | { | ||
467 | m_log.Info( | ||
468 | "No shape found for prim in storage, so setting default box shape"); | ||
469 | prim.Shape = PrimitiveBaseShape.Default; | ||
470 | } | ||
471 | createdObjects[new UUID(objID)].AddPart(prim); | ||
472 | LoadItems(prim); | ||
473 | } | 375 | } |
474 | } | 376 | else |
475 | catch (Exception e) | ||
476 | { | ||
477 | m_log.Error("[REGION DB]: Failed create prim object, exception and data follows"); | ||
478 | m_log.Info("[REGION DB]: " + e.ToString()); | ||
479 | foreach (DataColumn col in prims.Columns) | ||
480 | { | 377 | { |
481 | m_log.Info("[REGION DB]: Col: " + col.ColumnName + " => " + primRow[col]); | 378 | // Black magic to preserve link numbers |
379 | // | ||
380 | int link = prim.LinkNum; | ||
381 | |||
382 | grp.AddPart(prim); | ||
383 | |||
384 | if (link != 0) | ||
385 | prim.LinkNum = link; | ||
482 | } | 386 | } |
483 | } | 387 | } |
484 | } | 388 | } |
389 | finally | ||
390 | { | ||
391 | reader.Close(); | ||
392 | } | ||
393 | |||
394 | if (grp != null) | ||
395 | objects.Add(grp); | ||
485 | } | 396 | } |
486 | return retvals; | 397 | |
398 | foreach (SceneObjectPart part in prims) | ||
399 | LoadItems(part); | ||
400 | |||
401 | m_log.DebugFormat("[DATABASE] Loaded {0} objects using {1} prims", objects.Count, prims.Count); | ||
402 | |||
403 | return objects; | ||
487 | } | 404 | } |
488 | 405 | ||
489 | /// <summary> | ||
490 | /// Load in a prim's persisted inventory. | ||
491 | /// </summary> | ||
492 | /// <param name="prim">The prim</param> | ||
493 | private void LoadItems(SceneObjectPart prim) | 406 | private void LoadItems(SceneObjectPart prim) |
494 | { | 407 | { |
495 | lock (m_dataSet) | 408 | lock (m_Connection) |
496 | { | 409 | { |
497 | CheckConnection(); | 410 | MySqlCommand cmd = m_Connection.CreateCommand(); |
498 | //m_log.InfoFormat("[DATASTORE]: Loading inventory for {0}, {1}", prim.Name, prim.UUID); | ||
499 | 411 | ||
500 | DataTable dbItems = m_itemsTable; | 412 | cmd.CommandText = "select * from primitems where "+ |
413 | "PrimID = ?PrimID"; | ||
501 | 414 | ||
502 | String sql = String.Format("primID = '{0}'", prim.UUID.ToString()); | 415 | cmd.Parameters.AddWithValue("PrimID", prim.UUID.ToString()); |
503 | DataRow[] dbItemRows = dbItems.Select(sql); | ||
504 | IList<TaskInventoryItem> inventory = new List<TaskInventoryItem>(); | ||
505 | 416 | ||
506 | foreach (DataRow row in dbItemRows) | 417 | IDataReader reader = ExecuteReader(cmd); |
418 | List<TaskInventoryItem> inventory = | ||
419 | new List<TaskInventoryItem>(); | ||
420 | |||
421 | try | ||
507 | { | 422 | { |
508 | TaskInventoryItem item = buildItem(row); | 423 | while (reader.Read()) |
509 | inventory.Add(item); | 424 | { |
425 | TaskInventoryItem item = BuildItem(reader); | ||
510 | 426 | ||
511 | //m_log.DebugFormat("[DATASTORE]: Restored item {0}, {1}", item.Name, item.ItemID); | 427 | item.ParentID = prim.UUID; // Values in database are |
428 | // often wrong | ||
429 | inventory.Add(item); | ||
430 | } | ||
512 | } | 431 | } |
513 | 432 | finally | |
514 | prim.Inventory.RestoreInventoryItems(inventory); | ||
515 | |||
516 | // XXX A nasty little hack to recover the folder id for the prim (which is currently stored in | ||
517 | // every item). This data should really be stored in the prim table itself. | ||
518 | if (dbItemRows.Length > 0) | ||
519 | { | 433 | { |
520 | prim.FolderID = inventory[0].ParentID; | 434 | reader.Close(); |
521 | } | 435 | } |
436 | |||
437 | prim.Inventory.RestoreInventoryItems(inventory); | ||
522 | } | 438 | } |
523 | } | 439 | } |
524 | 440 | ||
525 | /// <summary> | ||
526 | /// Store a terrain revision in region storage | ||
527 | /// </summary> | ||
528 | /// <param name="ter">HeightField data</param> | ||
529 | /// <param name="regionID">region UUID</param> | ||
530 | public void StoreTerrain(double[,] ter, UUID regionID) | 441 | public void StoreTerrain(double[,] ter, UUID regionID) |
531 | { | 442 | { |
532 | int revision = 1; | 443 | m_log.Info("[REGION DB]: Storing terrain"); |
533 | m_log.Info("[REGION DB]: Storing terrain revision r" + revision.ToString()); | ||
534 | 444 | ||
535 | lock (m_dataSet) | 445 | lock (m_Connection) |
536 | { | 446 | { |
537 | MySqlCommand delete = new MySqlCommand("delete from terrain where RegionUUID=?RegionUUID", m_connection); | 447 | MySqlCommand cmd = m_Connection.CreateCommand(); |
538 | MySqlCommand cmd = new MySqlCommand("insert into terrain(RegionUUID, Revision, Heightfield)" + | ||
539 | " values(?RegionUUID, ?Revision, ?Heightfield)", m_connection); | ||
540 | using (cmd) | ||
541 | { | ||
542 | delete.Parameters.Add(new MySqlParameter("?RegionUUID", Util.ToRawUuidString(regionID))); | ||
543 | 448 | ||
544 | CheckConnection(); | 449 | cmd.CommandText = "delete from terrain where " + |
545 | delete.ExecuteNonQuery(); | 450 | "RegionUUID = ?RegionUUID"; |
451 | cmd.Parameters.AddWithValue("RegionUUID", | ||
452 | Util.ToRawUuidString(regionID)); | ||
546 | 453 | ||
547 | cmd.Parameters.Add(new MySqlParameter("?RegionUUID", Util.ToRawUuidString(regionID))); | 454 | ExecuteNonQuery(cmd); |
548 | cmd.Parameters.Add(new MySqlParameter("?Revision", revision)); | 455 | |
549 | cmd.Parameters.Add(new MySqlParameter("?Heightfield", serializeTerrain(ter))); | 456 | cmd.CommandText = "insert into terrain (RegionUUID, " + |
550 | cmd.ExecuteNonQuery(); | 457 | "Revision, Heightfield) values (?RegionUUID, " + |
551 | } | 458 | "1, ?Heightfield)"; |
459 | |||
460 | cmd.Parameters.AddWithValue("Heightfield", | ||
461 | SerializeTerrain(ter)); | ||
462 | |||
463 | ExecuteNonQuery(cmd); | ||
552 | } | 464 | } |
553 | } | 465 | } |
554 | 466 | ||
555 | /// <summary> | ||
556 | /// Load the latest terrain revision from region storage | ||
557 | /// </summary> | ||
558 | /// <param name="regionID">the region UUID</param> | ||
559 | /// <returns>Heightfield data</returns> | ||
560 | public double[,] LoadTerrain(UUID regionID) | 467 | public double[,] LoadTerrain(UUID regionID) |
561 | { | 468 | { |
562 | double[,] terret = new double[256,256]; | 469 | double[,] terrain = new double[256,256]; |
563 | terret.Initialize(); | 470 | terrain.Initialize(); |
564 | 471 | ||
565 | MySqlCommand cmd = new MySqlCommand( | 472 | lock (m_Connection) |
566 | @"select RegionUUID, Revision, Heightfield from terrain | ||
567 | where RegionUUID=?RegionUUID order by Revision desc limit 1" | ||
568 | , m_connection); | ||
569 | |||
570 | // MySqlParameter param = new MySqlParameter(); | ||
571 | cmd.Parameters.Add(new MySqlParameter("?RegionUUID", Util.ToRawUuidString(regionID))); | ||
572 | |||
573 | if (m_connection.State != ConnectionState.Open) | ||
574 | { | 473 | { |
575 | m_connection.Open(); | 474 | MySqlCommand cmd = m_Connection.CreateCommand(); |
576 | } | 475 | cmd.CommandText = "select RegionUUID, Revision, Heightfield " + |
476 | "from terrain where RegionUUID = ?RegionUUID "+ | ||
477 | "order by Revision desc limit 1"; | ||
478 | cmd.Parameters.AddWithValue("RegionUUID", Util.ToRawUuidString(regionID)); | ||
479 | |||
480 | IDataReader reader = ExecuteReader(cmd); | ||
577 | 481 | ||
578 | lock (m_dataSet) | ||
579 | { | ||
580 | CheckConnection(); | ||
581 | MySqlDataReader row = cmd.ExecuteReader(); | ||
582 | try | 482 | try |
583 | { | 483 | { |
584 | int rev = 0; | 484 | while (reader.Read()) |
585 | if (row.Read()) | ||
586 | { | 485 | { |
587 | MemoryStream str = new MemoryStream((byte[]) row["Heightfield"]); | 486 | MemoryStream mstr = new MemoryStream((byte[]) reader["Heightfield"]); |
588 | BinaryReader br = new BinaryReader(str); | 487 | int rev = 0; |
488 | |||
489 | BinaryReader br = new BinaryReader(mstr); | ||
589 | for (int x = 0; x < 256; x++) | 490 | for (int x = 0; x < 256; x++) |
590 | { | 491 | { |
591 | for (int y = 0; y < 256; y++) | 492 | for (int y = 0; y < 256; y++) |
592 | { | 493 | { |
593 | terret[x, y] = br.ReadDouble(); | 494 | terrain[x, y] = br.ReadDouble(); |
594 | } | 495 | } |
496 | rev = Convert.ToInt32(reader["Revision"]); | ||
595 | } | 497 | } |
596 | rev = (int) row["Revision"]; | 498 | m_log.InfoFormat("[REGION DB]: Loaded terrain " + |
597 | } | 499 | "revision r{0}", rev); |
598 | else | ||
599 | { | ||
600 | m_log.Info("[REGION DB]: No terrain found for region"); | ||
601 | return null; | ||
602 | } | ||
603 | 500 | ||
604 | m_log.Info("[REGION DB]: Loaded terrain revision r" + rev.ToString()); | 501 | return terrain; |
502 | } | ||
605 | } | 503 | } |
606 | finally | 504 | finally |
607 | { | 505 | { |
608 | row.Close(); | 506 | reader.Close(); |
609 | } | 507 | } |
610 | } | 508 | } |
611 | return terret; | 509 | |
510 | return terrain; | ||
612 | } | 511 | } |
613 | 512 | ||
614 | /// <summary> | ||
615 | /// <list type="bullet"> | ||
616 | /// <item>delete from land where UUID=globalID</item> | ||
617 | /// <item>delete from landaccesslist where LandUUID=globalID</item> | ||
618 | /// </list> | ||
619 | /// </summary> | ||
620 | /// <param name="globalID"></param> | ||
621 | public void RemoveLandObject(UUID globalID) | 513 | public void RemoveLandObject(UUID globalID) |
622 | { | 514 | { |
623 | lock (m_dataSet) | 515 | lock (m_Connection) |
624 | { | 516 | { |
625 | CheckConnection(); | 517 | MySqlCommand cmd = m_Connection.CreateCommand(); |
626 | using (MySqlCommand cmd = new MySqlCommand("delete from land where UUID=?UUID", m_connection)) | ||
627 | { | ||
628 | cmd.Parameters.Add(new MySqlParameter("?UUID", Util.ToRawUuidString(globalID))); | ||
629 | cmd.ExecuteNonQuery(); | ||
630 | } | ||
631 | 518 | ||
632 | using ( | 519 | cmd.CommandText = "delete from land where UUID = ?UUID"; |
633 | MySqlCommand cmd = new MySqlCommand("delete from landaccesslist where LandUUID=?UUID", m_connection) | 520 | |
634 | ) | 521 | cmd.Parameters.AddWithValue("UUID", Util.ToRawUuidString(globalID)); |
635 | { | 522 | |
636 | cmd.Parameters.Add(new MySqlParameter("?UUID", Util.ToRawUuidString(globalID))); | 523 | ExecuteNonQuery(cmd); |
637 | cmd.ExecuteNonQuery(); | ||
638 | } | ||
639 | } | 524 | } |
640 | } | 525 | } |
641 | 526 | ||
642 | /// <summary> | ||
643 | /// </summary> | ||
644 | /// <param name="parcel"></param> | ||
645 | public void StoreLandObject(ILandObject parcel) | 527 | public void StoreLandObject(ILandObject parcel) |
646 | { | 528 | { |
647 | lock (m_dataSet) | 529 | lock (m_Connection) |
648 | { | 530 | { |
649 | CheckConnection(); | 531 | MySqlCommand cmd = m_Connection.CreateCommand(); |
650 | DataTable land = m_landTable; | 532 | |
651 | DataTable landaccesslist = m_landAccessListTable; | 533 | cmd.CommandText = "replace into land (UUID, RegionUUID, " + |
652 | 534 | "LocalLandID, Bitmap, Name, Description, " + | |
653 | DataRow landRow = land.Rows.Find(Util.ToRawUuidString(parcel.landData.GlobalID)); | 535 | "OwnerUUID, IsGroupOwned, Area, AuctionID, " + |
654 | if (landRow == null) | 536 | "Category, ClaimDate, ClaimPrice, GroupUUID, " + |
655 | { | 537 | "SalePrice, LandStatus, LandFlags, LandingType, " + |
656 | landRow = land.NewRow(); | 538 | "MediaAutoScale, MediaTextureUUID, MediaURL, " + |
657 | fillLandRow(landRow, parcel.landData, parcel.regionUUID); | 539 | "MusicURL, PassHours, PassPrice, SnapshotUUID, " + |
658 | land.Rows.Add(landRow); | 540 | "UserLocationX, UserLocationY, UserLocationZ, " + |
659 | } | 541 | "UserLookAtX, UserLookAtY, UserLookAtZ, " + |
660 | else | 542 | "AuthbuyerID, OtherCleanTime, Dwell) values (" + |
661 | { | 543 | "?UUID, ?RegionUUID, " + |
662 | fillLandRow(landRow, parcel.landData, parcel.regionUUID); | 544 | "?LocalLandID, ?Bitmap, ?Name, ?Description, " + |
663 | } | 545 | "?OwnerUUID, ?IsGroupOwned, ?Area, ?AuctionID, " + |
664 | 546 | "?Category, ?ClaimDate, ?ClaimPrice, ?GroupUUID, " + | |
665 | using ( | 547 | "?SalePrice, ?LandStatus, ?LandFlags, ?LandingType, " + |
666 | MySqlCommand cmd = | 548 | "?MediaAutoScale, ?MediaTextureUUID, ?MediaURL, " + |
667 | new MySqlCommand("delete from landaccesslist where LandUUID=?LandUUID", m_connection)) | 549 | "?MusicURL, ?PassHours, ?PassPrice, ?SnapshotUUID, " + |
550 | "?UserLocationX, ?UserLocationY, ?UserLocationZ, " + | ||
551 | "?UserLookAtX, ?UserLookAtY, ?UserLookAtZ, " + | ||
552 | "?AuthbuyerID, ?OtherCleanTime, ?Dwell)"; | ||
553 | |||
554 | FillLandCommand(cmd, parcel.landData, parcel.regionUUID); | ||
555 | |||
556 | ExecuteNonQuery(cmd); | ||
557 | |||
558 | cmd.CommandText = "delete from landaccesslist where " + | ||
559 | "LandUUID = ?UUID"; | ||
560 | |||
561 | ExecuteNonQuery(cmd); | ||
562 | |||
563 | cmd.Parameters.Clear(); | ||
564 | cmd.CommandText = "insert into landaccesslist (LandUUID, " + | ||
565 | "AccessUUID, Flags) values (?LandUUID, ?AccessUUID, " + | ||
566 | "?Flags)"; | ||
567 | |||
568 | foreach (ParcelManager.ParcelAccessEntry entry in | ||
569 | parcel.landData.ParcelAccessList) | ||
668 | { | 570 | { |
669 | cmd.Parameters.Add(new MySqlParameter("?LandUUID", Util.ToRawUuidString(parcel.landData.GlobalID))); | 571 | FillLandAccessCommand(cmd, entry, parcel.landData.GlobalID); |
670 | cmd.ExecuteNonQuery(); | 572 | ExecuteNonQuery(cmd); |
573 | cmd.Parameters.Clear(); | ||
671 | } | 574 | } |
672 | |||
673 | foreach (ParcelManager.ParcelAccessEntry entry in parcel.landData.ParcelAccessList) | ||
674 | { | ||
675 | DataRow newAccessRow = landaccesslist.NewRow(); | ||
676 | fillLandAccessRow(newAccessRow, entry, parcel.landData.GlobalID); | ||
677 | landaccesslist.Rows.Add(newAccessRow); | ||
678 | } | ||
679 | |||
680 | Commit(); | ||
681 | } | 575 | } |
682 | } | 576 | } |
683 | 577 | ||
684 | public RegionSettings LoadRegionSettings(UUID regionUUID) | 578 | public RegionSettings LoadRegionSettings(UUID regionUUID) |
685 | { | 579 | { |
686 | lock (m_dataSet) | 580 | RegionSettings rs = null; |
687 | { | ||
688 | CheckConnection(); | ||
689 | DataTable regionsettings = m_regionSettingsTable; | ||
690 | string searchExp = "regionUUID = '" + regionUUID.ToString() + "'"; | ||
691 | DataRow[] rawsettings = regionsettings.Select(searchExp); | ||
692 | if (rawsettings.Length == 0) | ||
693 | { | ||
694 | RegionSettings rs = new RegionSettings(); | ||
695 | rs.RegionUUID = regionUUID; | ||
696 | rs.OnSave += StoreRegionSettings; | ||
697 | |||
698 | StoreRegionSettings(rs); | ||
699 | 581 | ||
700 | return rs; | 582 | lock (m_Connection) |
701 | } | ||
702 | DataRow row = rawsettings[0]; | ||
703 | |||
704 | RegionSettings newSettings = buildRegionSettings(row); | ||
705 | newSettings.OnSave += StoreRegionSettings; | ||
706 | |||
707 | return newSettings; | ||
708 | } | ||
709 | } | ||
710 | |||
711 | public void StoreRegionSettings(RegionSettings rs) | ||
712 | { | ||
713 | lock (m_dataSet) | ||
714 | { | 583 | { |
715 | CheckConnection(); | 584 | MySqlCommand cmd = m_Connection.CreateCommand(); |
716 | DataTable regionsettings = m_dataSet.Tables["regionsettings"]; | ||
717 | 585 | ||
718 | DataRow settingsRow = regionsettings.Rows.Find(rs.RegionUUID.ToString()); | 586 | cmd.CommandText = "select * from regionsettings where " + |
719 | if (settingsRow == null) | 587 | "regionUUID = ?RegionUUID"; |
720 | { | 588 | cmd.Parameters.AddWithValue("regionUUID", regionUUID); |
721 | settingsRow = regionsettings.NewRow(); | ||
722 | fillRegionSettingsRow(settingsRow, rs); | ||
723 | regionsettings.Rows.Add(settingsRow); | ||
724 | } | ||
725 | else | ||
726 | { | ||
727 | fillRegionSettingsRow(settingsRow, rs); | ||
728 | } | ||
729 | 589 | ||
730 | Commit(); | 590 | IDataReader reader = ExecuteReader(cmd); |
731 | } | ||
732 | } | ||
733 | 591 | ||
734 | /// <summary> | 592 | try |
735 | /// | ||
736 | /// </summary> | ||
737 | /// <param name="regionUUID"></param> | ||
738 | /// <returns></returns> | ||
739 | public List<LandData> LoadLandObjects(UUID regionUUID) | ||
740 | { | ||
741 | List<LandData> landDataForRegion = new List<LandData>(); | ||
742 | lock (m_dataSet) | ||
743 | { | ||
744 | CheckConnection(); | ||
745 | DataTable land = m_landTable; | ||
746 | DataTable landaccesslist = m_landAccessListTable; | ||
747 | string searchExp = "RegionUUID = '" + Util.ToRawUuidString(regionUUID) + "'"; | ||
748 | DataRow[] rawDataForRegion = land.Select(searchExp); | ||
749 | foreach (DataRow rawDataLand in rawDataForRegion) | ||
750 | { | 593 | { |
751 | LandData newLand = buildLandData(rawDataLand); | 594 | if (reader.Read()) |
752 | string accessListSearchExp = "LandUUID = '" + Util.ToRawUuidString(newLand.GlobalID) + "'"; | ||
753 | DataRow[] rawDataForLandAccessList = landaccesslist.Select(accessListSearchExp); | ||
754 | foreach (DataRow rawDataLandAccess in rawDataForLandAccessList) | ||
755 | { | 595 | { |
756 | newLand.ParcelAccessList.Add(buildLandAccessData(rawDataLandAccess)); | 596 | rs = BuildRegionSettings(reader); |
597 | rs.OnSave += StoreRegionSettings; | ||
757 | } | 598 | } |
599 | else | ||
600 | { | ||
601 | rs = new RegionSettings(); | ||
602 | rs.RegionUUID = regionUUID; | ||
603 | rs.OnSave += StoreRegionSettings; | ||
758 | 604 | ||
759 | landDataForRegion.Add(newLand); | 605 | StoreRegionSettings(rs); |
606 | } | ||
607 | } | ||
608 | finally | ||
609 | { | ||
610 | reader.Close(); | ||
760 | } | 611 | } |
761 | } | 612 | } |
762 | return landDataForRegion; | 613 | |
614 | return rs; | ||
763 | } | 615 | } |
764 | 616 | ||
765 | /// <summary> | 617 | public void StoreRegionSettings(RegionSettings rs) |
766 | /// | ||
767 | /// </summary> | ||
768 | public void Commit() | ||
769 | { | 618 | { |
770 | lock (m_dataSet) | 619 | lock (m_Connection) |
771 | { | 620 | { |
772 | CheckConnection(); | 621 | MySqlCommand cmd = m_Connection.CreateCommand(); |
773 | // DisplayDataSet(m_dataSet, "Region DataSet"); | 622 | |
774 | 623 | cmd.CommandText = "replace into regionsettings (regionUUID, " + | |
775 | m_primDataAdapter.Update(m_primTable); | 624 | "block_terraform, block_fly, allow_damage, " + |
776 | m_shapeDataAdapter.Update(m_shapeTable); | 625 | "restrict_pushing, allow_land_resell, " + |
777 | 626 | "allow_land_join_divide, block_show_in_search, " + | |
778 | m_itemsDataAdapter.Update(m_itemsTable); | 627 | "agent_limit, object_bonus, maturity, " + |
779 | 628 | "disable_scripts, disable_collisions, " + | |
780 | m_terrainDataAdapter.Update(m_terrainTable); | 629 | "disable_physics, terrain_texture_1, " + |
781 | m_landDataAdapter.Update(m_landTable); | 630 | "terrain_texture_2, terrain_texture_3, " + |
782 | m_landAccessListDataAdapter.Update(m_landAccessListTable); | 631 | "terrain_texture_4, elevation_1_nw, " + |
783 | m_regionSettingsDataAdapter.Update(m_regionSettingsTable); | 632 | "elevation_2_nw, elevation_1_ne, " + |
784 | 633 | "elevation_2_ne, elevation_1_se, "+ | |
785 | m_dataSet.AcceptChanges(); | 634 | "elevation_2_se, elevation_1_sw, "+ |
635 | "elevation_2_sw, water_height, " + | ||
636 | "terrain_raise_limit, terrain_lower_limit, " + | ||
637 | "use_estate_sun, fixed_sun, sun_position, " + | ||
638 | "covenant, Sandbox, sunvectorx, sunvectory, " + | ||
639 | "sunvectorz) values ( ?RegionUUID, ?BlockTerraform, " + | ||
640 | "?BlockFly, ?AllowDamage, ?RestrictPushing, " + | ||
641 | "?AllowLandResell, ?AllowLandJoinDivide, " + | ||
642 | "?BlockShowInSearch, ?AgentLimit, ?ObjectBonus, " + | ||
643 | "?Maturity, ?DisableScripts, ?DisableCollisions, " + | ||
644 | "?DisablePhysics, ?TerrainTexture1, " + | ||
645 | "?TerrainTexture2, ?TerrainTexture3, " + | ||
646 | "?TerrainTexture4, ?Elevation1NW, ?Elevation2NW, " + | ||
647 | "?Elevation1NE, ?Elevation2NE, ?Elevation1SE, " + | ||
648 | "?Elevation2SE, ?Elevation1SW, ?Elevation2SW, " + | ||
649 | "?WaterHeight, ?TerrainRaiseLimit, " + | ||
650 | "?TerrainLowerLimit, ?UseEstateSun, ?FixedSun, " + | ||
651 | "?SunPosition, ?Covenant, ?Sandbox, " + | ||
652 | "?SunVectorX, ?SunVectorY, ?SunVectorZ)"; | ||
653 | |||
654 | FillRegionSettingsCommand(cmd, rs); | ||
655 | |||
656 | ExecuteNonQuery(cmd); | ||
786 | } | 657 | } |
787 | } | 658 | } |
788 | 659 | ||
789 | /// <summary> | 660 | public List<LandData> LoadLandObjects(UUID regionUUID) |
790 | /// See <see cref="Commit"/> | ||
791 | /// </summary> | ||
792 | public void Shutdown() | ||
793 | { | ||
794 | Commit(); | ||
795 | } | ||
796 | |||
797 | /*********************************************************************** | ||
798 | * | ||
799 | * Database Definition Functions | ||
800 | * | ||
801 | * This should be db agnostic as we define them in ADO.NET terms | ||
802 | * | ||
803 | **********************************************************************/ | ||
804 | |||
805 | /// <summary> | ||
806 | /// | ||
807 | /// </summary> | ||
808 | /// <param name="dt"></param> | ||
809 | /// <param name="name"></param> | ||
810 | /// <param name="type"></param> | ||
811 | /// <returns></returns> | ||
812 | private static DataColumn createCol(DataTable dt, string name, Type type) | ||
813 | { | ||
814 | DataColumn col = new DataColumn(name, type); | ||
815 | dt.Columns.Add(col); | ||
816 | return col; | ||
817 | } | ||
818 | |||
819 | /// <summary> | ||
820 | /// Create the "terrain" table | ||
821 | /// </summary> | ||
822 | /// <returns></returns> | ||
823 | private static DataTable createTerrainTable() | ||
824 | { | ||
825 | DataTable terrain = new DataTable("terrain"); | ||
826 | |||
827 | createCol(terrain, "RegionUUID", typeof (String)); | ||
828 | createCol(terrain, "Revision", typeof (Int32)); | ||
829 | createCol(terrain, "Heightfield", typeof (Byte[])); | ||
830 | return terrain; | ||
831 | } | ||
832 | |||
833 | /// <summary> | ||
834 | /// Create the "regionsettings" table | ||
835 | /// </summary> | ||
836 | /// <returns></returns> | ||
837 | private static DataTable createRegionSettingsTable() | ||
838 | { | ||
839 | DataTable regionsettings = new DataTable("regionsettings"); | ||
840 | createCol(regionsettings, "regionUUID", typeof(String)); | ||
841 | createCol(regionsettings, "block_terraform", typeof (Int32)); | ||
842 | createCol(regionsettings, "block_fly", typeof (Int32)); | ||
843 | createCol(regionsettings, "allow_damage", typeof (Int32)); | ||
844 | createCol(regionsettings, "restrict_pushing", typeof (Int32)); | ||
845 | createCol(regionsettings, "allow_land_resell", typeof (Int32)); | ||
846 | createCol(regionsettings, "allow_land_join_divide", typeof (Int32)); | ||
847 | createCol(regionsettings, "block_show_in_search", typeof (Int32)); | ||
848 | createCol(regionsettings, "agent_limit", typeof (Int32)); | ||
849 | createCol(regionsettings, "object_bonus", typeof (Double)); | ||
850 | createCol(regionsettings, "maturity", typeof (Int32)); | ||
851 | createCol(regionsettings, "disable_scripts", typeof (Int32)); | ||
852 | createCol(regionsettings, "disable_collisions", typeof (Int32)); | ||
853 | createCol(regionsettings, "disable_physics", typeof (Int32)); | ||
854 | createCol(regionsettings, "terrain_texture_1", typeof(String)); | ||
855 | createCol(regionsettings, "terrain_texture_2", typeof(String)); | ||
856 | createCol(regionsettings, "terrain_texture_3", typeof(String)); | ||
857 | createCol(regionsettings, "terrain_texture_4", typeof(String)); | ||
858 | createCol(regionsettings, "elevation_1_nw", typeof (Double)); | ||
859 | createCol(regionsettings, "elevation_2_nw", typeof (Double)); | ||
860 | createCol(regionsettings, "elevation_1_ne", typeof (Double)); | ||
861 | createCol(regionsettings, "elevation_2_ne", typeof (Double)); | ||
862 | createCol(regionsettings, "elevation_1_se", typeof (Double)); | ||
863 | createCol(regionsettings, "elevation_2_se", typeof (Double)); | ||
864 | createCol(regionsettings, "elevation_1_sw", typeof (Double)); | ||
865 | createCol(regionsettings, "elevation_2_sw", typeof (Double)); | ||
866 | createCol(regionsettings, "water_height", typeof (Double)); | ||
867 | createCol(regionsettings, "terrain_raise_limit", typeof (Double)); | ||
868 | createCol(regionsettings, "terrain_lower_limit", typeof (Double)); | ||
869 | createCol(regionsettings, "use_estate_sun", typeof (Int32)); | ||
870 | createCol(regionsettings, "sandbox", typeof (Int32)); | ||
871 | createCol(regionsettings, "sunvectorx",typeof (Double)); | ||
872 | createCol(regionsettings, "sunvectory",typeof (Double)); | ||
873 | createCol(regionsettings, "sunvectorz",typeof (Double)); | ||
874 | createCol(regionsettings, "fixed_sun", typeof (Int32)); | ||
875 | createCol(regionsettings, "sun_position", typeof (Double)); | ||
876 | createCol(regionsettings, "covenant", typeof(String)); | ||
877 | |||
878 | regionsettings.PrimaryKey = new DataColumn[] {regionsettings.Columns["RegionUUID"]}; | ||
879 | |||
880 | return regionsettings; | ||
881 | } | ||
882 | |||
883 | /// <summary> | ||
884 | /// Create the "prims" table | ||
885 | /// </summary> | ||
886 | /// <returns></returns> | ||
887 | private static DataTable createPrimTable() | ||
888 | { | 661 | { |
889 | DataTable prims = new DataTable("prims"); | 662 | List<LandData> landData = new List<LandData>(); |
890 | |||
891 | createCol(prims, "UUID", typeof (String)); | ||
892 | createCol(prims, "RegionUUID", typeof (String)); | ||
893 | createCol(prims, "ParentID", typeof (Int32)); | ||
894 | createCol(prims, "CreationDate", typeof (Int32)); | ||
895 | createCol(prims, "Name", typeof (String)); | ||
896 | createCol(prims, "SceneGroupID", typeof (String)); | ||
897 | // various text fields | ||
898 | createCol(prims, "Text", typeof (String)); | ||
899 | createCol(prims, "ColorR", typeof (Int32)); | ||
900 | createCol(prims, "ColorG", typeof (Int32)); | ||
901 | createCol(prims, "ColorB", typeof (Int32)); | ||
902 | createCol(prims, "ColorA", typeof (Int32)); | ||
903 | createCol(prims, "Description", typeof (String)); | ||
904 | createCol(prims, "SitName", typeof (String)); | ||
905 | createCol(prims, "TouchName", typeof (String)); | ||
906 | // permissions | ||
907 | createCol(prims, "ObjectFlags", typeof (Int32)); | ||
908 | createCol(prims, "CreatorID", typeof (String)); | ||
909 | createCol(prims, "OwnerID", typeof (String)); | ||
910 | createCol(prims, "GroupID", typeof (String)); | ||
911 | createCol(prims, "LastOwnerID", typeof (String)); | ||
912 | createCol(prims, "OwnerMask", typeof (Int32)); | ||
913 | createCol(prims, "NextOwnerMask", typeof (Int32)); | ||
914 | createCol(prims, "GroupMask", typeof (Int32)); | ||
915 | createCol(prims, "EveryoneMask", typeof (Int32)); | ||
916 | createCol(prims, "BaseMask", typeof (Int32)); | ||
917 | // vectors | ||
918 | createCol(prims, "PositionX", typeof (Double)); | ||
919 | createCol(prims, "PositionY", typeof (Double)); | ||
920 | createCol(prims, "PositionZ", typeof (Double)); | ||
921 | createCol(prims, "GroupPositionX", typeof (Double)); | ||
922 | createCol(prims, "GroupPositionY", typeof (Double)); | ||
923 | createCol(prims, "GroupPositionZ", typeof (Double)); | ||
924 | createCol(prims, "VelocityX", typeof (Double)); | ||
925 | createCol(prims, "VelocityY", typeof (Double)); | ||
926 | createCol(prims, "VelocityZ", typeof (Double)); | ||
927 | createCol(prims, "AngularVelocityX", typeof (Double)); | ||
928 | createCol(prims, "AngularVelocityY", typeof (Double)); | ||
929 | createCol(prims, "AngularVelocityZ", typeof (Double)); | ||
930 | createCol(prims, "AccelerationX", typeof (Double)); | ||
931 | createCol(prims, "AccelerationY", typeof (Double)); | ||
932 | createCol(prims, "AccelerationZ", typeof (Double)); | ||
933 | // quaternions | ||
934 | createCol(prims, "RotationX", typeof (Double)); | ||
935 | createCol(prims, "RotationY", typeof (Double)); | ||
936 | createCol(prims, "RotationZ", typeof (Double)); | ||
937 | createCol(prims, "RotationW", typeof (Double)); | ||
938 | // sit target | ||
939 | createCol(prims, "SitTargetOffsetX", typeof (Double)); | ||
940 | createCol(prims, "SitTargetOffsetY", typeof (Double)); | ||
941 | createCol(prims, "SitTargetOffsetZ", typeof (Double)); | ||
942 | |||
943 | createCol(prims, "SitTargetOrientW", typeof (Double)); | ||
944 | createCol(prims, "SitTargetOrientX", typeof (Double)); | ||
945 | createCol(prims, "SitTargetOrientY", typeof (Double)); | ||
946 | createCol(prims, "SitTargetOrientZ", typeof (Double)); | ||
947 | |||
948 | createCol(prims, "PayPrice", typeof(Int32)); | ||
949 | createCol(prims, "PayButton1", typeof(Int32)); | ||
950 | createCol(prims, "PayButton2", typeof(Int32)); | ||
951 | createCol(prims, "PayButton3", typeof(Int32)); | ||
952 | createCol(prims, "PayButton4", typeof(Int32)); | ||
953 | |||
954 | createCol(prims, "LoopedSound", typeof(String)); | ||
955 | createCol(prims, "LoopedSoundGain", typeof(Double)); | ||
956 | createCol(prims, "TextureAnimation", typeof(Byte[])); | ||
957 | createCol(prims, "ParticleSystem", typeof(Byte[])); | ||
958 | |||
959 | createCol(prims, "OmegaX", typeof (Double)); | ||
960 | createCol(prims, "OmegaY", typeof (Double)); | ||
961 | createCol(prims, "OmegaZ", typeof (Double)); | ||
962 | |||
963 | createCol(prims, "CameraEyeOffsetX", typeof (Double)); | ||
964 | createCol(prims, "CameraEyeOffsetY", typeof (Double)); | ||
965 | createCol(prims, "CameraEyeOffsetZ", typeof (Double)); | ||
966 | 663 | ||
967 | createCol(prims, "CameraAtOffsetX", typeof (Double)); | 664 | lock (m_Connection) |
968 | createCol(prims, "CameraAtOffsetY", typeof (Double)); | 665 | { |
969 | createCol(prims, "CameraAtOffsetZ", typeof (Double)); | 666 | MySqlCommand cmd = m_Connection.CreateCommand(); |
970 | |||
971 | createCol(prims, "ForceMouselook", typeof (Int16)); | ||
972 | |||
973 | createCol(prims, "ScriptAccessPin", typeof(Int32)); | ||
974 | |||
975 | createCol(prims, "AllowedDrop", typeof (Int16)); | ||
976 | createCol(prims, "DieAtEdge", typeof (Int16)); | ||
977 | |||
978 | createCol(prims, "SalePrice", typeof(Int32)); | ||
979 | createCol(prims, "SaleType", typeof (Int16)); | ||
980 | |||
981 | createCol(prims, "ClickAction", typeof (Byte)); | ||
982 | createCol(prims, "Material", typeof (Byte)); | ||
983 | 667 | ||
984 | createCol(prims, "CollisionSound", typeof(String)); | 668 | cmd.CommandText = "select * from land where " + |
985 | createCol(prims, "CollisionSoundVolume", typeof(Double)); | 669 | "RegionUUID = ?RegionUUID"; |
986 | 670 | ||
987 | // Add in contraints | 671 | cmd.Parameters.AddWithValue("RegionUUID", |
988 | prims.PrimaryKey = new DataColumn[] {prims.Columns["UUID"]}; | 672 | Util.ToRawUuidString(regionUUID)); |
989 | 673 | ||
990 | return prims; | 674 | IDataReader reader = ExecuteReader(cmd); |
991 | } | ||
992 | 675 | ||
993 | /// <summary> | 676 | try |
994 | /// Create the "land" table | 677 | { |
995 | /// </summary> | 678 | while (reader.Read()) |
996 | /// <returns></returns> | 679 | { |
997 | private static DataTable createLandTable() | 680 | LandData newLand = BuildLandData(reader); |
998 | { | 681 | landData.Add(newLand); |
999 | DataTable land = new DataTable("land"); | 682 | } |
1000 | createCol(land, "UUID", typeof (String)); | 683 | } |
1001 | createCol(land, "RegionUUID", typeof (String)); | 684 | finally |
1002 | createCol(land, "LocalLandID", typeof (Int32)); | 685 | { |
686 | reader.Close(); | ||
687 | } | ||
1003 | 688 | ||
1004 | // Bitmap is a byte[512] | 689 | foreach (LandData land in landData) |
1005 | createCol(land, "Bitmap", typeof (Byte[])); | 690 | { |
1006 | 691 | cmd.Parameters.Clear(); | |
1007 | createCol(land, "Name", typeof (String)); | ||
1008 | createCol(land, "Description", typeof (String)); | ||
1009 | createCol(land, "OwnerUUID", typeof (String)); | ||
1010 | createCol(land, "IsGroupOwned", typeof (Int32)); | ||
1011 | createCol(land, "Area", typeof (Int32)); | ||
1012 | createCol(land, "AuctionID", typeof (Int32)); //Unemplemented | ||
1013 | createCol(land, "Category", typeof (Int32)); //Enum libsecondlife.Parcel.ParcelCategory | ||
1014 | createCol(land, "ClaimDate", typeof (Int32)); | ||
1015 | createCol(land, "ClaimPrice", typeof (Int32)); | ||
1016 | createCol(land, "GroupUUID", typeof (String)); | ||
1017 | createCol(land, "SalePrice", typeof (Int32)); | ||
1018 | createCol(land, "LandStatus", typeof (Int32)); //Enum. libsecondlife.Parcel.ParcelStatus | ||
1019 | createCol(land, "LandFlags", typeof (UInt32)); | ||
1020 | createCol(land, "LandingType", typeof (Int32)); | ||
1021 | createCol(land, "MediaAutoScale", typeof (Int32)); | ||
1022 | createCol(land, "MediaTextureUUID", typeof (String)); | ||
1023 | createCol(land, "MediaURL", typeof (String)); | ||
1024 | createCol(land, "MusicURL", typeof (String)); | ||
1025 | createCol(land, "PassHours", typeof (Double)); | ||
1026 | createCol(land, "PassPrice", typeof (Int32)); | ||
1027 | createCol(land, "SnapshotUUID", typeof (String)); | ||
1028 | createCol(land, "UserLocationX", typeof (Double)); | ||
1029 | createCol(land, "UserLocationY", typeof (Double)); | ||
1030 | createCol(land, "UserLocationZ", typeof (Double)); | ||
1031 | createCol(land, "UserLookAtX", typeof (Double)); | ||
1032 | createCol(land, "UserLookAtY", typeof (Double)); | ||
1033 | createCol(land, "UserLookAtZ", typeof (Double)); | ||
1034 | createCol(land, "AuthBuyerID", typeof (String)); | ||
1035 | createCol(land, "OtherCleanTime", typeof(Int32)); | ||
1036 | createCol(land, "Dwell", typeof(Int32)); | ||
1037 | |||
1038 | land.PrimaryKey = new DataColumn[] {land.Columns["UUID"]}; | ||
1039 | |||
1040 | return land; | ||
1041 | } | ||
1042 | 692 | ||
1043 | /// <summary> | 693 | cmd.CommandText = "select * from landaccesslist " + |
1044 | /// Create the "landaccesslist" table | 694 | "where LandUUID = ?LandUUID"; |
1045 | /// </summary> | ||
1046 | /// <returns></returns> | ||
1047 | private static DataTable createLandAccessListTable() | ||
1048 | { | ||
1049 | DataTable landaccess = new DataTable("landaccesslist"); | ||
1050 | createCol(landaccess, "LandUUID", typeof (String)); | ||
1051 | createCol(landaccess, "AccessUUID", typeof (String)); | ||
1052 | createCol(landaccess, "Flags", typeof (Int32)); | ||
1053 | 695 | ||
1054 | return landaccess; | 696 | cmd.Parameters.AddWithValue("LandUUID", |
1055 | } | 697 | Util.ToRawUuidString(land.GlobalID)); |
1056 | 698 | ||
1057 | /// <summary> | 699 | reader = ExecuteReader(cmd); |
1058 | /// Create the "primshapes" table | ||
1059 | /// </summary> | ||
1060 | /// <returns></returns> | ||
1061 | private static DataTable createShapeTable() | ||
1062 | { | ||
1063 | DataTable shapes = new DataTable("primshapes"); | ||
1064 | createCol(shapes, "UUID", typeof (String)); | ||
1065 | // shape is an enum | ||
1066 | createCol(shapes, "Shape", typeof (Int32)); | ||
1067 | // vectors | ||
1068 | createCol(shapes, "ScaleX", typeof (Double)); | ||
1069 | createCol(shapes, "ScaleY", typeof (Double)); | ||
1070 | createCol(shapes, "ScaleZ", typeof (Double)); | ||
1071 | // paths | ||
1072 | createCol(shapes, "PCode", typeof (Int32)); | ||
1073 | createCol(shapes, "PathBegin", typeof (Int32)); | ||
1074 | createCol(shapes, "PathEnd", typeof (Int32)); | ||
1075 | createCol(shapes, "PathScaleX", typeof (Int32)); | ||
1076 | createCol(shapes, "PathScaleY", typeof (Int32)); | ||
1077 | createCol(shapes, "PathShearX", typeof (Int32)); | ||
1078 | createCol(shapes, "PathShearY", typeof (Int32)); | ||
1079 | createCol(shapes, "PathSkew", typeof (Int32)); | ||
1080 | createCol(shapes, "PathCurve", typeof (Int32)); | ||
1081 | createCol(shapes, "PathRadiusOffset", typeof (Int32)); | ||
1082 | createCol(shapes, "PathRevolutions", typeof (Int32)); | ||
1083 | createCol(shapes, "PathTaperX", typeof (Int32)); | ||
1084 | createCol(shapes, "PathTaperY", typeof (Int32)); | ||
1085 | createCol(shapes, "PathTwist", typeof (Int32)); | ||
1086 | createCol(shapes, "PathTwistBegin", typeof (Int32)); | ||
1087 | // profile | ||
1088 | createCol(shapes, "ProfileBegin", typeof (Int32)); | ||
1089 | createCol(shapes, "ProfileEnd", typeof (Int32)); | ||
1090 | createCol(shapes, "ProfileCurve", typeof (Int32)); | ||
1091 | createCol(shapes, "ProfileHollow", typeof (Int32)); | ||
1092 | createCol(shapes, "State", typeof(Int32)); | ||
1093 | createCol(shapes, "Texture", typeof (Byte[])); | ||
1094 | createCol(shapes, "ExtraParams", typeof (Byte[])); | ||
1095 | 700 | ||
1096 | shapes.PrimaryKey = new DataColumn[] {shapes.Columns["UUID"]}; | 701 | try |
702 | { | ||
703 | while (reader.Read()) | ||
704 | { | ||
705 | land.ParcelAccessList.Add(BuildLandAccessData(reader)); | ||
706 | } | ||
707 | } | ||
708 | finally | ||
709 | { | ||
710 | reader.Close(); | ||
711 | } | ||
712 | } | ||
713 | } | ||
1097 | 714 | ||
1098 | return shapes; | 715 | return landData; |
1099 | } | 716 | } |
1100 | 717 | ||
1101 | /// <summary> | 718 | public void Shutdown() |
1102 | /// Create the "primitems" table | ||
1103 | /// </summary> | ||
1104 | /// <returns></returns> | ||
1105 | private static DataTable createItemsTable() | ||
1106 | { | 719 | { |
1107 | DataTable items = new DataTable("primitems"); | ||
1108 | |||
1109 | createCol(items, "itemID", typeof (String)); | ||
1110 | createCol(items, "primID", typeof (String)); | ||
1111 | createCol(items, "assetID", typeof (String)); | ||
1112 | createCol(items, "parentFolderID", typeof (String)); | ||
1113 | |||
1114 | createCol(items, "invType", typeof (Int32)); | ||
1115 | createCol(items, "assetType", typeof (Int32)); | ||
1116 | |||
1117 | createCol(items, "name", typeof (String)); | ||
1118 | createCol(items, "description", typeof (String)); | ||
1119 | |||
1120 | createCol(items, "creationDate", typeof (Int64)); | ||
1121 | createCol(items, "creatorID", typeof (String)); | ||
1122 | createCol(items, "ownerID", typeof (String)); | ||
1123 | createCol(items, "lastOwnerID", typeof (String)); | ||
1124 | createCol(items, "groupID", typeof (String)); | ||
1125 | |||
1126 | createCol(items, "nextPermissions", typeof (Int32)); | ||
1127 | createCol(items, "currentPermissions", typeof (Int32)); | ||
1128 | createCol(items, "basePermissions", typeof (Int32)); | ||
1129 | createCol(items, "everyonePermissions", typeof (Int32)); | ||
1130 | createCol(items, "groupPermissions", typeof (Int32)); | ||
1131 | createCol(items, "flags", typeof (Int32)); | ||
1132 | |||
1133 | items.PrimaryKey = new DataColumn[] {items.Columns["itemID"]}; | ||
1134 | |||
1135 | return items; | ||
1136 | } | 720 | } |
1137 | 721 | ||
1138 | /*********************************************************************** | 722 | private SceneObjectPart BuildPrim(IDataReader row) |
1139 | * | ||
1140 | * Convert between ADO.NET <=> OpenSim Objects | ||
1141 | * | ||
1142 | * These should be database independant | ||
1143 | * | ||
1144 | **********************************************************************/ | ||
1145 | |||
1146 | /// <summary> | ||
1147 | /// | ||
1148 | /// </summary> | ||
1149 | /// <param name="row"></param> | ||
1150 | /// <returns></returns> | ||
1151 | private SceneObjectPart buildPrim(DataRow row) | ||
1152 | { | 723 | { |
1153 | SceneObjectPart prim = new SceneObjectPart(); | 724 | SceneObjectPart prim = new SceneObjectPart(); |
1154 | prim.UUID = new UUID((String) row["UUID"]); | 725 | prim.UUID = new UUID((String) row["UUID"]); |
@@ -1232,9 +803,9 @@ namespace OpenSim.Data.MySQL | |||
1232 | prim.SoundGain = Convert.ToSingle(row["LoopedSoundGain"]); | 803 | prim.SoundGain = Convert.ToSingle(row["LoopedSoundGain"]); |
1233 | prim.SoundFlags = 1; // If it's persisted at all, it's looped | 804 | prim.SoundFlags = 1; // If it's persisted at all, it's looped |
1234 | 805 | ||
1235 | if (!row.IsNull("TextureAnimation")) | 806 | if (!(row["TextureAnimation"] is DBNull)) |
1236 | prim.TextureAnimation = (Byte[])row["TextureAnimation"]; | 807 | prim.TextureAnimation = (Byte[])row["TextureAnimation"]; |
1237 | if (!row.IsNull("ParticleSystem")) | 808 | if (!(row["ParticleSystem"] is DBNull)) |
1238 | prim.ParticleSystem = (Byte[])row["ParticleSystem"]; | 809 | prim.ParticleSystem = (Byte[])row["ParticleSystem"]; |
1239 | 810 | ||
1240 | prim.RotationalVelocity = new Vector3( | 811 | prim.RotationalVelocity = new Vector3( |
@@ -1271,11 +842,12 @@ namespace OpenSim.Data.MySQL | |||
1271 | 842 | ||
1272 | prim.Material = Convert.ToByte(row["Material"]); | 843 | prim.Material = Convert.ToByte(row["Material"]); |
1273 | 844 | ||
1274 | if (!row.IsNull("ClickAction")) | 845 | if (!(row["ClickAction"] is DBNull)) |
1275 | prim.ClickAction = Convert.ToByte(row["ClickAction"]); | 846 | prim.ClickAction = (byte)Convert.ToByte(row["ClickAction"]); |
1276 | 847 | ||
1277 | prim.CollisionSound = new UUID(row["CollisionSound"].ToString()); | 848 | prim.CollisionSound = new UUID(row["CollisionSound"].ToString()); |
1278 | prim.CollisionSoundVolume = Convert.ToSingle(row["CollisionSoundVolume"]); | 849 | prim.CollisionSoundVolume = Convert.ToSingle(row["CollisionSoundVolume"]); |
850 | prim.LinkNum = Convert.ToInt32(row["LinkNumber"]); | ||
1279 | 851 | ||
1280 | return prim; | 852 | return prim; |
1281 | } | 853 | } |
@@ -1286,7 +858,7 @@ namespace OpenSim.Data.MySQL | |||
1286 | /// </summary> | 858 | /// </summary> |
1287 | /// <param name="row"></param> | 859 | /// <param name="row"></param> |
1288 | /// <returns></returns> | 860 | /// <returns></returns> |
1289 | private static TaskInventoryItem buildItem(DataRow row) | 861 | private static TaskInventoryItem BuildItem(IDataReader row) |
1290 | { | 862 | { |
1291 | TaskInventoryItem taskItem = new TaskInventoryItem(); | 863 | TaskInventoryItem taskItem = new TaskInventoryItem(); |
1292 | 864 | ||
@@ -1316,7 +888,7 @@ namespace OpenSim.Data.MySQL | |||
1316 | return taskItem; | 888 | return taskItem; |
1317 | } | 889 | } |
1318 | 890 | ||
1319 | private static RegionSettings buildRegionSettings(DataRow row) | 891 | private static RegionSettings BuildRegionSettings(IDataReader row) |
1320 | { | 892 | { |
1321 | RegionSettings newSettings = new RegionSettings(); | 893 | RegionSettings newSettings = new RegionSettings(); |
1322 | 894 | ||
@@ -1368,7 +940,7 @@ namespace OpenSim.Data.MySQL | |||
1368 | /// </summary> | 940 | /// </summary> |
1369 | /// <param name="row"></param> | 941 | /// <param name="row"></param> |
1370 | /// <returns></returns> | 942 | /// <returns></returns> |
1371 | private static LandData buildLandData(DataRow row) | 943 | private static LandData BuildLandData(IDataReader row) |
1372 | { | 944 | { |
1373 | LandData newData = new LandData(); | 945 | LandData newData = new LandData(); |
1374 | 946 | ||
@@ -1436,7 +1008,7 @@ namespace OpenSim.Data.MySQL | |||
1436 | /// </summary> | 1008 | /// </summary> |
1437 | /// <param name="row"></param> | 1009 | /// <param name="row"></param> |
1438 | /// <returns></returns> | 1010 | /// <returns></returns> |
1439 | private static ParcelManager.ParcelAccessEntry buildLandAccessData(DataRow row) | 1011 | private static ParcelManager.ParcelAccessEntry BuildLandAccessData(IDataReader row) |
1440 | { | 1012 | { |
1441 | ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry(); | 1013 | ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry(); |
1442 | entry.AgentID = new UUID((string) row["AccessUUID"]); | 1014 | entry.AgentID = new UUID((string) row["AccessUUID"]); |
@@ -1450,7 +1022,7 @@ namespace OpenSim.Data.MySQL | |||
1450 | /// </summary> | 1022 | /// </summary> |
1451 | /// <param name="val"></param> | 1023 | /// <param name="val"></param> |
1452 | /// <returns></returns> | 1024 | /// <returns></returns> |
1453 | private static Array serializeTerrain(double[,] val) | 1025 | private static Array SerializeTerrain(double[,] val) |
1454 | { | 1026 | { |
1455 | MemoryStream str = new MemoryStream(65536*sizeof (double)); | 1027 | MemoryStream str = new MemoryStream(65536*sizeof (double)); |
1456 | BinaryWriter bw = new BinaryWriter(str); | 1028 | BinaryWriter bw = new BinaryWriter(str); |
@@ -1476,128 +1048,129 @@ namespace OpenSim.Data.MySQL | |||
1476 | /// <param name="prim"></param> | 1048 | /// <param name="prim"></param> |
1477 | /// <param name="sceneGroupID"></param> | 1049 | /// <param name="sceneGroupID"></param> |
1478 | /// <param name="regionUUID"></param> | 1050 | /// <param name="regionUUID"></param> |
1479 | private void fillPrimRow(DataRow row, SceneObjectPart prim, UUID sceneGroupID, UUID regionUUID) | 1051 | private void FillPrimCommand(MySqlCommand cmd, SceneObjectPart prim, UUID sceneGroupID, UUID regionUUID) |
1480 | { | 1052 | { |
1481 | row["UUID"] = Util.ToRawUuidString(prim.UUID); | 1053 | cmd.Parameters.AddWithValue("UUID", Util.ToRawUuidString(prim.UUID)); |
1482 | row["RegionUUID"] = Util.ToRawUuidString(regionUUID); | 1054 | cmd.Parameters.AddWithValue("RegionUUID", Util.ToRawUuidString(regionUUID)); |
1483 | row["ParentID"] = prim.ParentID; | 1055 | cmd.Parameters.AddWithValue("ParentID", prim.ParentID); |
1484 | row["CreationDate"] = prim.CreationDate; | 1056 | cmd.Parameters.AddWithValue("CreationDate", prim.CreationDate); |
1485 | row["Name"] = prim.Name; | 1057 | cmd.Parameters.AddWithValue("Name", prim.Name); |
1486 | row["SceneGroupID"] = Util.ToRawUuidString(sceneGroupID); | 1058 | cmd.Parameters.AddWithValue("SceneGroupID", Util.ToRawUuidString(sceneGroupID)); |
1487 | // the UUID of the root part for this SceneObjectGroup | 1059 | // the UUID of the root part for this SceneObjectGroup |
1488 | // various text fields | 1060 | // various text fields |
1489 | row["Text"] = prim.Text; | 1061 | cmd.Parameters.AddWithValue("Text", prim.Text); |
1490 | row["ColorR"] = prim.Color.R; | 1062 | cmd.Parameters.AddWithValue("ColorR", prim.Color.R); |
1491 | row["ColorG"] = prim.Color.G; | 1063 | cmd.Parameters.AddWithValue("ColorG", prim.Color.G); |
1492 | row["ColorB"] = prim.Color.B; | 1064 | cmd.Parameters.AddWithValue("ColorB", prim.Color.B); |
1493 | row["ColorA"] = prim.Color.A; | 1065 | cmd.Parameters.AddWithValue("ColorA", prim.Color.A); |
1494 | row["Description"] = prim.Description; | 1066 | cmd.Parameters.AddWithValue("Description", prim.Description); |
1495 | row["SitName"] = prim.SitName; | 1067 | cmd.Parameters.AddWithValue("SitName", prim.SitName); |
1496 | row["TouchName"] = prim.TouchName; | 1068 | cmd.Parameters.AddWithValue("TouchName", prim.TouchName); |
1497 | // permissions | 1069 | // permissions |
1498 | row["ObjectFlags"] = prim.ObjectFlags; | 1070 | cmd.Parameters.AddWithValue("ObjectFlags", prim.ObjectFlags); |
1499 | row["CreatorID"] = Util.ToRawUuidString(prim.CreatorID); | 1071 | cmd.Parameters.AddWithValue("CreatorID", Util.ToRawUuidString(prim.CreatorID)); |
1500 | row["OwnerID"] = Util.ToRawUuidString(prim.OwnerID); | 1072 | cmd.Parameters.AddWithValue("OwnerID", Util.ToRawUuidString(prim.OwnerID)); |
1501 | row["GroupID"] = Util.ToRawUuidString(prim.GroupID); | 1073 | cmd.Parameters.AddWithValue("GroupID", Util.ToRawUuidString(prim.GroupID)); |
1502 | row["LastOwnerID"] = Util.ToRawUuidString(prim.LastOwnerID); | 1074 | cmd.Parameters.AddWithValue("LastOwnerID", Util.ToRawUuidString(prim.LastOwnerID)); |
1503 | row["OwnerMask"] = prim.OwnerMask; | 1075 | cmd.Parameters.AddWithValue("OwnerMask", prim.OwnerMask); |
1504 | row["NextOwnerMask"] = prim.NextOwnerMask; | 1076 | cmd.Parameters.AddWithValue("NextOwnerMask", prim.NextOwnerMask); |
1505 | row["GroupMask"] = prim.GroupMask; | 1077 | cmd.Parameters.AddWithValue("GroupMask", prim.GroupMask); |
1506 | row["EveryoneMask"] = prim.EveryoneMask; | 1078 | cmd.Parameters.AddWithValue("EveryoneMask", prim.EveryoneMask); |
1507 | row["BaseMask"] = prim.BaseMask; | 1079 | cmd.Parameters.AddWithValue("BaseMask", prim.BaseMask); |
1508 | // vectors | 1080 | // vectors |
1509 | row["PositionX"] = prim.OffsetPosition.X; | 1081 | cmd.Parameters.AddWithValue("PositionX", prim.OffsetPosition.X); |
1510 | row["PositionY"] = prim.OffsetPosition.Y; | 1082 | cmd.Parameters.AddWithValue("PositionY", prim.OffsetPosition.Y); |
1511 | row["PositionZ"] = prim.OffsetPosition.Z; | 1083 | cmd.Parameters.AddWithValue("PositionZ", prim.OffsetPosition.Z); |
1512 | row["GroupPositionX"] = prim.GroupPosition.X; | 1084 | cmd.Parameters.AddWithValue("GroupPositionX", prim.GroupPosition.X); |
1513 | row["GroupPositionY"] = prim.GroupPosition.Y; | 1085 | cmd.Parameters.AddWithValue("GroupPositionY", prim.GroupPosition.Y); |
1514 | row["GroupPositionZ"] = prim.GroupPosition.Z; | 1086 | cmd.Parameters.AddWithValue("GroupPositionZ", prim.GroupPosition.Z); |
1515 | row["VelocityX"] = prim.Velocity.X; | 1087 | cmd.Parameters.AddWithValue("VelocityX", prim.Velocity.X); |
1516 | row["VelocityY"] = prim.Velocity.Y; | 1088 | cmd.Parameters.AddWithValue("VelocityY", prim.Velocity.Y); |
1517 | row["VelocityZ"] = prim.Velocity.Z; | 1089 | cmd.Parameters.AddWithValue("VelocityZ", prim.Velocity.Z); |
1518 | row["AngularVelocityX"] = prim.AngularVelocity.X; | 1090 | cmd.Parameters.AddWithValue("AngularVelocityX", prim.AngularVelocity.X); |
1519 | row["AngularVelocityY"] = prim.AngularVelocity.Y; | 1091 | cmd.Parameters.AddWithValue("AngularVelocityY", prim.AngularVelocity.Y); |
1520 | row["AngularVelocityZ"] = prim.AngularVelocity.Z; | 1092 | cmd.Parameters.AddWithValue("AngularVelocityZ", prim.AngularVelocity.Z); |
1521 | row["AccelerationX"] = prim.Acceleration.X; | 1093 | cmd.Parameters.AddWithValue("AccelerationX", prim.Acceleration.X); |
1522 | row["AccelerationY"] = prim.Acceleration.Y; | 1094 | cmd.Parameters.AddWithValue("AccelerationY", prim.Acceleration.Y); |
1523 | row["AccelerationZ"] = prim.Acceleration.Z; | 1095 | cmd.Parameters.AddWithValue("AccelerationZ", prim.Acceleration.Z); |
1524 | // quaternions | 1096 | // quaternions |
1525 | row["RotationX"] = prim.RotationOffset.X; | 1097 | cmd.Parameters.AddWithValue("RotationX", prim.RotationOffset.X); |
1526 | row["RotationY"] = prim.RotationOffset.Y; | 1098 | cmd.Parameters.AddWithValue("RotationY", prim.RotationOffset.Y); |
1527 | row["RotationZ"] = prim.RotationOffset.Z; | 1099 | cmd.Parameters.AddWithValue("RotationZ", prim.RotationOffset.Z); |
1528 | row["RotationW"] = prim.RotationOffset.W; | 1100 | cmd.Parameters.AddWithValue("RotationW", prim.RotationOffset.W); |
1529 | 1101 | ||
1530 | // Sit target | 1102 | // Sit target |
1531 | Vector3 sitTargetPos = prim.SitTargetPositionLL; | 1103 | Vector3 sitTargetPos = prim.SitTargetPositionLL; |
1532 | row["SitTargetOffsetX"] = sitTargetPos.X; | 1104 | cmd.Parameters.AddWithValue("SitTargetOffsetX", sitTargetPos.X); |
1533 | row["SitTargetOffsetY"] = sitTargetPos.Y; | 1105 | cmd.Parameters.AddWithValue("SitTargetOffsetY", sitTargetPos.Y); |
1534 | row["SitTargetOffsetZ"] = sitTargetPos.Z; | 1106 | cmd.Parameters.AddWithValue("SitTargetOffsetZ", sitTargetPos.Z); |
1535 | 1107 | ||
1536 | Quaternion sitTargetOrient = prim.SitTargetOrientationLL; | 1108 | Quaternion sitTargetOrient = prim.SitTargetOrientationLL; |
1537 | row["SitTargetOrientW"] = sitTargetOrient.W; | 1109 | cmd.Parameters.AddWithValue("SitTargetOrientW", sitTargetOrient.W); |
1538 | row["SitTargetOrientX"] = sitTargetOrient.X; | 1110 | cmd.Parameters.AddWithValue("SitTargetOrientX", sitTargetOrient.X); |
1539 | row["SitTargetOrientY"] = sitTargetOrient.Y; | 1111 | cmd.Parameters.AddWithValue("SitTargetOrientY", sitTargetOrient.Y); |
1540 | row["SitTargetOrientZ"] = sitTargetOrient.Z; | 1112 | cmd.Parameters.AddWithValue("SitTargetOrientZ", sitTargetOrient.Z); |
1541 | 1113 | ||
1542 | row["PayPrice"] = prim.PayPrice[0]; | 1114 | cmd.Parameters.AddWithValue("PayPrice", prim.PayPrice[0]); |
1543 | row["PayButton1"] = prim.PayPrice[1]; | 1115 | cmd.Parameters.AddWithValue("PayButton1", prim.PayPrice[1]); |
1544 | row["PayButton2"] = prim.PayPrice[2]; | 1116 | cmd.Parameters.AddWithValue("PayButton2", prim.PayPrice[2]); |
1545 | row["PayButton3"] = prim.PayPrice[3]; | 1117 | cmd.Parameters.AddWithValue("PayButton3", prim.PayPrice[3]); |
1546 | row["PayButton4"] = prim.PayPrice[4]; | 1118 | cmd.Parameters.AddWithValue("PayButton4", prim.PayPrice[4]); |
1547 | 1119 | ||
1548 | if ((prim.SoundFlags & 1) != 0) // Looped | 1120 | if ((prim.SoundFlags & 1) != 0) // Looped |
1549 | { | 1121 | { |
1550 | row["LoopedSound"] = prim.Sound.ToString(); | 1122 | cmd.Parameters.AddWithValue("LoopedSound", prim.Sound.ToString()); |
1551 | row["LoopedSoundGain"] = prim.SoundGain; | 1123 | cmd.Parameters.AddWithValue("LoopedSoundGain", prim.SoundGain); |
1552 | } | 1124 | } |
1553 | else | 1125 | else |
1554 | { | 1126 | { |
1555 | row["LoopedSound"] = UUID.Zero; | 1127 | cmd.Parameters.AddWithValue("LoopedSound", UUID.Zero); |
1556 | row["LoopedSoundGain"] = 0.0f; | 1128 | cmd.Parameters.AddWithValue("LoopedSoundGain", 0.0f); |
1557 | } | 1129 | } |
1558 | 1130 | ||
1559 | row["TextureAnimation"] = prim.TextureAnimation; | 1131 | cmd.Parameters.AddWithValue("TextureAnimation", prim.TextureAnimation); |
1560 | row["ParticleSystem"] = prim.ParticleSystem; | 1132 | cmd.Parameters.AddWithValue("ParticleSystem", prim.ParticleSystem); |
1561 | 1133 | ||
1562 | row["OmegaX"] = prim.RotationalVelocity.X; | 1134 | cmd.Parameters.AddWithValue("OmegaX", prim.RotationalVelocity.X); |
1563 | row["OmegaY"] = prim.RotationalVelocity.Y; | 1135 | cmd.Parameters.AddWithValue("OmegaY", prim.RotationalVelocity.Y); |
1564 | row["OmegaZ"] = prim.RotationalVelocity.Z; | 1136 | cmd.Parameters.AddWithValue("OmegaZ", prim.RotationalVelocity.Z); |
1565 | 1137 | ||
1566 | row["CameraEyeOffsetX"] = prim.GetCameraEyeOffset().X; | 1138 | cmd.Parameters.AddWithValue("CameraEyeOffsetX", prim.GetCameraEyeOffset().X); |
1567 | row["CameraEyeOffsetY"] = prim.GetCameraEyeOffset().Y; | 1139 | cmd.Parameters.AddWithValue("CameraEyeOffsetY", prim.GetCameraEyeOffset().Y); |
1568 | row["CameraEyeOffsetZ"] = prim.GetCameraEyeOffset().Z; | 1140 | cmd.Parameters.AddWithValue("CameraEyeOffsetZ", prim.GetCameraEyeOffset().Z); |
1569 | 1141 | ||
1570 | row["CameraAtOffsetX"] = prim.GetCameraAtOffset().X; | 1142 | cmd.Parameters.AddWithValue("CameraAtOffsetX", prim.GetCameraAtOffset().X); |
1571 | row["CameraAtOffsetY"] = prim.GetCameraAtOffset().Y; | 1143 | cmd.Parameters.AddWithValue("CameraAtOffsetY", prim.GetCameraAtOffset().Y); |
1572 | row["CameraAtOffsetZ"] = prim.GetCameraAtOffset().Z; | 1144 | cmd.Parameters.AddWithValue("CameraAtOffsetZ", prim.GetCameraAtOffset().Z); |
1573 | 1145 | ||
1574 | if (prim.GetForceMouselook()) | 1146 | if (prim.GetForceMouselook()) |
1575 | row["ForceMouselook"] = 1; | 1147 | cmd.Parameters.AddWithValue("ForceMouselook", 1); |
1576 | else | 1148 | else |
1577 | row["ForceMouselook"] = 0; | 1149 | cmd.Parameters.AddWithValue("ForceMouselook", 0); |
1578 | 1150 | ||
1579 | row["ScriptAccessPin"] = prim.ScriptAccessPin; | 1151 | cmd.Parameters.AddWithValue("ScriptAccessPin", prim.ScriptAccessPin); |
1580 | 1152 | ||
1581 | if (prim.AllowedDrop) | 1153 | if (prim.AllowedDrop) |
1582 | row["AllowedDrop"] = 1; | 1154 | cmd.Parameters.AddWithValue("AllowedDrop", 1); |
1583 | else | 1155 | else |
1584 | row["AllowedDrop"] = 0; | 1156 | cmd.Parameters.AddWithValue("AllowedDrop", 0); |
1585 | 1157 | ||
1586 | if (prim.DIE_AT_EDGE) | 1158 | if (prim.DIE_AT_EDGE) |
1587 | row["DieAtEdge"] = 1; | 1159 | cmd.Parameters.AddWithValue("DieAtEdge", 1); |
1588 | else | 1160 | else |
1589 | row["DieAtEdge"] = 0; | 1161 | cmd.Parameters.AddWithValue("DieAtEdge", 0); |
1590 | 1162 | ||
1591 | row["SalePrice"] = prim.SalePrice; | 1163 | cmd.Parameters.AddWithValue("SalePrice", prim.SalePrice); |
1592 | row["SaleType"] = Convert.ToInt16(prim.ObjectSaleType); | 1164 | cmd.Parameters.AddWithValue("SaleType", Convert.ToInt16(prim.ObjectSaleType)); |
1593 | 1165 | ||
1594 | byte clickAction = prim.ClickAction; | 1166 | byte clickAction = prim.ClickAction; |
1595 | row["ClickAction"] = clickAction; | 1167 | cmd.Parameters.AddWithValue("ClickAction", clickAction); |
1596 | 1168 | ||
1597 | row["Material"] = prim.Material; | 1169 | cmd.Parameters.AddWithValue("Material", prim.Material); |
1598 | 1170 | ||
1599 | row["CollisionSound"] = prim.CollisionSound.ToString(); | 1171 | cmd.Parameters.AddWithValue("CollisionSound", prim.CollisionSound.ToString()); |
1600 | row["CollisionSoundVolume"] = prim.CollisionSoundVolume; | 1172 | cmd.Parameters.AddWithValue("CollisionSoundVolume", prim.CollisionSoundVolume); |
1173 | cmd.Parameters.AddWithValue("LinkNumber", prim.LinkNum); | ||
1601 | } | 1174 | } |
1602 | 1175 | ||
1603 | /// <summary> | 1176 | /// <summary> |
@@ -1605,73 +1178,73 @@ namespace OpenSim.Data.MySQL | |||
1605 | /// </summary> | 1178 | /// </summary> |
1606 | /// <param name="row"></param> | 1179 | /// <param name="row"></param> |
1607 | /// <param name="taskItem"></param> | 1180 | /// <param name="taskItem"></param> |
1608 | private static void fillItemRow(DataRow row, TaskInventoryItem taskItem) | 1181 | private static void FillItemCommand(MySqlCommand cmd, TaskInventoryItem taskItem) |
1609 | { | 1182 | { |
1610 | row["itemID"] = taskItem.ItemID; | 1183 | cmd.Parameters.AddWithValue("itemID", taskItem.ItemID); |
1611 | row["primID"] = taskItem.ParentPartID; | 1184 | cmd.Parameters.AddWithValue("primID", taskItem.ParentPartID); |
1612 | row["assetID"] = taskItem.AssetID; | 1185 | cmd.Parameters.AddWithValue("assetID", taskItem.AssetID); |
1613 | row["parentFolderID"] = taskItem.ParentID; | 1186 | cmd.Parameters.AddWithValue("parentFolderID", taskItem.ParentID); |
1614 | 1187 | ||
1615 | row["invType"] = taskItem.InvType; | 1188 | cmd.Parameters.AddWithValue("invType", taskItem.InvType); |
1616 | row["assetType"] = taskItem.Type; | 1189 | cmd.Parameters.AddWithValue("assetType", taskItem.Type); |
1617 | 1190 | ||
1618 | row["name"] = taskItem.Name; | 1191 | cmd.Parameters.AddWithValue("name", taskItem.Name); |
1619 | row["description"] = taskItem.Description; | 1192 | cmd.Parameters.AddWithValue("description", taskItem.Description); |
1620 | row["creationDate"] = taskItem.CreationDate; | 1193 | cmd.Parameters.AddWithValue("creationDate", taskItem.CreationDate); |
1621 | row["creatorID"] = taskItem.CreatorID; | 1194 | cmd.Parameters.AddWithValue("creatorID", taskItem.CreatorID); |
1622 | row["ownerID"] = taskItem.OwnerID; | 1195 | cmd.Parameters.AddWithValue("ownerID", taskItem.OwnerID); |
1623 | row["lastOwnerID"] = taskItem.LastOwnerID; | 1196 | cmd.Parameters.AddWithValue("lastOwnerID", taskItem.LastOwnerID); |
1624 | row["groupID"] = taskItem.GroupID; | 1197 | cmd.Parameters.AddWithValue("groupID", taskItem.GroupID); |
1625 | row["nextPermissions"] = taskItem.NextPermissions; | 1198 | cmd.Parameters.AddWithValue("nextPermissions", taskItem.NextPermissions); |
1626 | row["currentPermissions"] = taskItem.CurrentPermissions; | 1199 | cmd.Parameters.AddWithValue("currentPermissions", taskItem.CurrentPermissions); |
1627 | row["basePermissions"] = taskItem.BasePermissions; | 1200 | cmd.Parameters.AddWithValue("basePermissions", taskItem.BasePermissions); |
1628 | row["everyonePermissions"] = taskItem.EveryonePermissions; | 1201 | cmd.Parameters.AddWithValue("everyonePermissions", taskItem.EveryonePermissions); |
1629 | row["groupPermissions"] = taskItem.GroupPermissions; | 1202 | cmd.Parameters.AddWithValue("groupPermissions", taskItem.GroupPermissions); |
1630 | row["flags"] = taskItem.Flags; | 1203 | cmd.Parameters.AddWithValue("flags", taskItem.Flags); |
1631 | } | 1204 | } |
1632 | 1205 | ||
1633 | /// <summary> | 1206 | /// <summary> |
1634 | /// | 1207 | /// |
1635 | /// </summary> | 1208 | /// </summary> |
1636 | private static void fillRegionSettingsRow(DataRow row, RegionSettings settings) | 1209 | private static void FillRegionSettingsCommand(MySqlCommand cmd, RegionSettings settings) |
1637 | { | 1210 | { |
1638 | row["regionUUID"] = settings.RegionUUID.ToString(); | 1211 | cmd.Parameters.AddWithValue("RegionUUID", settings.RegionUUID.ToString()); |
1639 | row["block_terraform"] = settings.BlockTerraform; | 1212 | cmd.Parameters.AddWithValue("BlockTerraform", settings.BlockTerraform); |
1640 | row["block_fly"] = settings.BlockFly; | 1213 | cmd.Parameters.AddWithValue("BlockFly", settings.BlockFly); |
1641 | row["allow_damage"] = settings.AllowDamage; | 1214 | cmd.Parameters.AddWithValue("AllowDamage", settings.AllowDamage); |
1642 | row["restrict_pushing"] = settings.RestrictPushing; | 1215 | cmd.Parameters.AddWithValue("RestrictPushing", settings.RestrictPushing); |
1643 | row["allow_land_resell"] = settings.AllowLandResell; | 1216 | cmd.Parameters.AddWithValue("AllowLandResell", settings.AllowLandResell); |
1644 | row["allow_land_join_divide"] = settings.AllowLandJoinDivide; | 1217 | cmd.Parameters.AddWithValue("AllowLandJoinDivide", settings.AllowLandJoinDivide); |
1645 | row["block_show_in_search"] = settings.BlockShowInSearch; | 1218 | cmd.Parameters.AddWithValue("BlockShowInSearch", settings.BlockShowInSearch); |
1646 | row["agent_limit"] = settings.AgentLimit; | 1219 | cmd.Parameters.AddWithValue("AgentLimit", settings.AgentLimit); |
1647 | row["object_bonus"] = settings.ObjectBonus; | 1220 | cmd.Parameters.AddWithValue("ObjectBonus", settings.ObjectBonus); |
1648 | row["maturity"] = settings.Maturity; | 1221 | cmd.Parameters.AddWithValue("Maturity", settings.Maturity); |
1649 | row["disable_scripts"] = settings.DisableScripts; | 1222 | cmd.Parameters.AddWithValue("DisableScripts", settings.DisableScripts); |
1650 | row["disable_collisions"] = settings.DisableCollisions; | 1223 | cmd.Parameters.AddWithValue("DisableCollisions", settings.DisableCollisions); |
1651 | row["disable_physics"] = settings.DisablePhysics; | 1224 | cmd.Parameters.AddWithValue("DisablePhysics", settings.DisablePhysics); |
1652 | row["terrain_texture_1"] = settings.TerrainTexture1.ToString(); | 1225 | cmd.Parameters.AddWithValue("TerrainTexture1", settings.TerrainTexture1.ToString()); |
1653 | row["terrain_texture_2"] = settings.TerrainTexture2.ToString(); | 1226 | cmd.Parameters.AddWithValue("TerrainTexture2", settings.TerrainTexture2.ToString()); |
1654 | row["terrain_texture_3"] = settings.TerrainTexture3.ToString(); | 1227 | cmd.Parameters.AddWithValue("TerrainTexture3", settings.TerrainTexture3.ToString()); |
1655 | row["terrain_texture_4"] = settings.TerrainTexture4.ToString(); | 1228 | cmd.Parameters.AddWithValue("TerrainTexture4", settings.TerrainTexture4.ToString()); |
1656 | row["elevation_1_nw"] = settings.Elevation1NW; | 1229 | cmd.Parameters.AddWithValue("Elevation1NW", settings.Elevation1NW); |
1657 | row["elevation_2_nw"] = settings.Elevation2NW; | 1230 | cmd.Parameters.AddWithValue("Elevation2NW", settings.Elevation2NW); |
1658 | row["elevation_1_ne"] = settings.Elevation1NE; | 1231 | cmd.Parameters.AddWithValue("Elevation1NE", settings.Elevation1NE); |
1659 | row["elevation_2_ne"] = settings.Elevation2NE; | 1232 | cmd.Parameters.AddWithValue("Elevation2NE", settings.Elevation2NE); |
1660 | row["elevation_1_se"] = settings.Elevation1SE; | 1233 | cmd.Parameters.AddWithValue("Elevation1SE", settings.Elevation1SE); |
1661 | row["elevation_2_se"] = settings.Elevation2SE; | 1234 | cmd.Parameters.AddWithValue("Elevation2SE", settings.Elevation2SE); |
1662 | row["elevation_1_sw"] = settings.Elevation1SW; | 1235 | cmd.Parameters.AddWithValue("Elevation1SW", settings.Elevation1SW); |
1663 | row["elevation_2_sw"] = settings.Elevation2SW; | 1236 | cmd.Parameters.AddWithValue("Elevation2SW", settings.Elevation2SW); |
1664 | row["water_height"] = settings.WaterHeight; | 1237 | cmd.Parameters.AddWithValue("WaterHeight", settings.WaterHeight); |
1665 | row["terrain_raise_limit"] = settings.TerrainRaiseLimit; | 1238 | cmd.Parameters.AddWithValue("TerrainRaiseLimit", settings.TerrainRaiseLimit); |
1666 | row["terrain_lower_limit"] = settings.TerrainLowerLimit; | 1239 | cmd.Parameters.AddWithValue("TerrainLowerLimit", settings.TerrainLowerLimit); |
1667 | row["use_estate_sun"] = settings.UseEstateSun; | 1240 | cmd.Parameters.AddWithValue("UseEstateSun", settings.UseEstateSun); |
1668 | row["sandbox"] = settings.Sandbox; | 1241 | cmd.Parameters.AddWithValue("Sandbox", settings.Sandbox); |
1669 | row["sunvectorx"] = settings.SunVector.X; | 1242 | cmd.Parameters.AddWithValue("SunVectorX", settings.SunVector.X); |
1670 | row["sunvectory"] = settings.SunVector.Y; | 1243 | cmd.Parameters.AddWithValue("SunVectorY", settings.SunVector.Y); |
1671 | row["sunvectorz"] = settings.SunVector.Z; | 1244 | cmd.Parameters.AddWithValue("SunVectorZ", settings.SunVector.Z); |
1672 | row["fixed_sun"] = settings.FixedSun; | 1245 | cmd.Parameters.AddWithValue("FixedSun", settings.FixedSun); |
1673 | row["sun_position"] = settings.SunPosition; | 1246 | cmd.Parameters.AddWithValue("SunPosition", settings.SunPosition); |
1674 | row["covenant"] = settings.Covenant.ToString(); | 1247 | cmd.Parameters.AddWithValue("Covenant", settings.Covenant.ToString()); |
1675 | } | 1248 | } |
1676 | 1249 | ||
1677 | /// <summary> | 1250 | /// <summary> |
@@ -1680,45 +1253,45 @@ namespace OpenSim.Data.MySQL | |||
1680 | /// <param name="row"></param> | 1253 | /// <param name="row"></param> |
1681 | /// <param name="land"></param> | 1254 | /// <param name="land"></param> |
1682 | /// <param name="regionUUID"></param> | 1255 | /// <param name="regionUUID"></param> |
1683 | private static void fillLandRow(DataRow row, LandData land, UUID regionUUID) | 1256 | private static void FillLandCommand(MySqlCommand cmd, LandData land, UUID regionUUID) |
1684 | { | 1257 | { |
1685 | row["UUID"] = Util.ToRawUuidString(land.GlobalID); | 1258 | cmd.Parameters.AddWithValue("UUID", Util.ToRawUuidString(land.GlobalID)); |
1686 | row["RegionUUID"] = Util.ToRawUuidString(regionUUID); | 1259 | cmd.Parameters.AddWithValue("RegionUUID", Util.ToRawUuidString(regionUUID)); |
1687 | row["LocalLandID"] = land.LocalID; | 1260 | cmd.Parameters.AddWithValue("LocalLandID", land.LocalID); |
1688 | 1261 | ||
1689 | // Bitmap is a byte[512] | 1262 | // Bitmap is a byte[512] |
1690 | row["Bitmap"] = land.Bitmap; | 1263 | cmd.Parameters.AddWithValue("Bitmap", land.Bitmap); |
1691 | 1264 | ||
1692 | row["Name"] = land.Name; | 1265 | cmd.Parameters.AddWithValue("Name", land.Name); |
1693 | row["Description"] = land.Description; | 1266 | cmd.Parameters.AddWithValue("Description", land.Description); |
1694 | row["OwnerUUID"] = Util.ToRawUuidString(land.OwnerID); | 1267 | cmd.Parameters.AddWithValue("OwnerUUID", Util.ToRawUuidString(land.OwnerID)); |
1695 | row["IsGroupOwned"] = land.IsGroupOwned; | 1268 | cmd.Parameters.AddWithValue("IsGroupOwned", land.IsGroupOwned); |
1696 | row["Area"] = land.Area; | 1269 | cmd.Parameters.AddWithValue("Area", land.Area); |
1697 | row["AuctionID"] = land.AuctionID; //Unemplemented | 1270 | cmd.Parameters.AddWithValue("AuctionID", land.AuctionID); //Unemplemented |
1698 | row["Category"] = land.Category; //Enum libsecondlife.Parcel.ParcelCategory | 1271 | cmd.Parameters.AddWithValue("Category", land.Category); //Enum libsecondlife.Parcel.ParcelCategory |
1699 | row["ClaimDate"] = land.ClaimDate; | 1272 | cmd.Parameters.AddWithValue("ClaimDate", land.ClaimDate); |
1700 | row["ClaimPrice"] = land.ClaimPrice; | 1273 | cmd.Parameters.AddWithValue("ClaimPrice", land.ClaimPrice); |
1701 | row["GroupUUID"] = Util.ToRawUuidString(land.GroupID); | 1274 | cmd.Parameters.AddWithValue("GroupUUID", Util.ToRawUuidString(land.GroupID)); |
1702 | row["SalePrice"] = land.SalePrice; | 1275 | cmd.Parameters.AddWithValue("SalePrice", land.SalePrice); |
1703 | row["LandStatus"] = land.Status; //Enum. libsecondlife.Parcel.ParcelStatus | 1276 | cmd.Parameters.AddWithValue("LandStatus", land.Status); //Enum. libsecondlife.Parcel.ParcelStatus |
1704 | row["LandFlags"] = land.Flags; | 1277 | cmd.Parameters.AddWithValue("LandFlags", land.Flags); |
1705 | row["LandingType"] = land.LandingType; | 1278 | cmd.Parameters.AddWithValue("LandingType", land.LandingType); |
1706 | row["MediaAutoScale"] = land.MediaAutoScale; | 1279 | cmd.Parameters.AddWithValue("MediaAutoScale", land.MediaAutoScale); |
1707 | row["MediaTextureUUID"] = Util.ToRawUuidString(land.MediaID); | 1280 | cmd.Parameters.AddWithValue("MediaTextureUUID", Util.ToRawUuidString(land.MediaID)); |
1708 | row["MediaURL"] = land.MediaURL; | 1281 | cmd.Parameters.AddWithValue("MediaURL", land.MediaURL); |
1709 | row["MusicURL"] = land.MusicURL; | 1282 | cmd.Parameters.AddWithValue("MusicURL", land.MusicURL); |
1710 | row["PassHours"] = land.PassHours; | 1283 | cmd.Parameters.AddWithValue("PassHours", land.PassHours); |
1711 | row["PassPrice"] = land.PassPrice; | 1284 | cmd.Parameters.AddWithValue("PassPrice", land.PassPrice); |
1712 | row["SnapshotUUID"] = Util.ToRawUuidString(land.SnapshotID); | 1285 | cmd.Parameters.AddWithValue("SnapshotUUID", Util.ToRawUuidString(land.SnapshotID)); |
1713 | row["UserLocationX"] = land.UserLocation.X; | 1286 | cmd.Parameters.AddWithValue("UserLocationX", land.UserLocation.X); |
1714 | row["UserLocationY"] = land.UserLocation.Y; | 1287 | cmd.Parameters.AddWithValue("UserLocationY", land.UserLocation.Y); |
1715 | row["UserLocationZ"] = land.UserLocation.Z; | 1288 | cmd.Parameters.AddWithValue("UserLocationZ", land.UserLocation.Z); |
1716 | row["UserLookAtX"] = land.UserLookAt.X; | 1289 | cmd.Parameters.AddWithValue("UserLookAtX", land.UserLookAt.X); |
1717 | row["UserLookAtY"] = land.UserLookAt.Y; | 1290 | cmd.Parameters.AddWithValue("UserLookAtY", land.UserLookAt.Y); |
1718 | row["UserLookAtZ"] = land.UserLookAt.Z; | 1291 | cmd.Parameters.AddWithValue("UserLookAtZ", land.UserLookAt.Z); |
1719 | row["AuthBuyerID"] = land.AuthBuyerID; | 1292 | cmd.Parameters.AddWithValue("AuthBuyerID", land.AuthBuyerID); |
1720 | row["OtherCleanTime"] = land.OtherCleanTime; | 1293 | cmd.Parameters.AddWithValue("OtherCleanTime", land.OtherCleanTime); |
1721 | row["Dwell"] = land.Dwell; | 1294 | cmd.Parameters.AddWithValue("Dwell", land.Dwell); |
1722 | } | 1295 | } |
1723 | 1296 | ||
1724 | /// <summary> | 1297 | /// <summary> |
@@ -1727,11 +1300,11 @@ namespace OpenSim.Data.MySQL | |||
1727 | /// <param name="row"></param> | 1300 | /// <param name="row"></param> |
1728 | /// <param name="entry"></param> | 1301 | /// <param name="entry"></param> |
1729 | /// <param name="parcelID"></param> | 1302 | /// <param name="parcelID"></param> |
1730 | private static void fillLandAccessRow(DataRow row, ParcelManager.ParcelAccessEntry entry, UUID parcelID) | 1303 | private static void FillLandAccessCommand(MySqlCommand cmd, ParcelManager.ParcelAccessEntry entry, UUID parcelID) |
1731 | { | 1304 | { |
1732 | row["LandUUID"] = Util.ToRawUuidString(parcelID); | 1305 | cmd.Parameters.AddWithValue("LandUUID", Util.ToRawUuidString(parcelID)); |
1733 | row["AccessUUID"] = Util.ToRawUuidString(entry.AgentID); | 1306 | cmd.Parameters.AddWithValue("AccessUUID", Util.ToRawUuidString(entry.AgentID)); |
1734 | row["Flags"] = entry.Flags; | 1307 | cmd.Parameters.AddWithValue("Flags", entry.Flags); |
1735 | } | 1308 | } |
1736 | 1309 | ||
1737 | /// <summary> | 1310 | /// <summary> |
@@ -1739,7 +1312,7 @@ namespace OpenSim.Data.MySQL | |||
1739 | /// </summary> | 1312 | /// </summary> |
1740 | /// <param name="row"></param> | 1313 | /// <param name="row"></param> |
1741 | /// <returns></returns> | 1314 | /// <returns></returns> |
1742 | private PrimitiveBaseShape buildShape(DataRow row) | 1315 | private PrimitiveBaseShape BuildShape(IDataReader row) |
1743 | { | 1316 | { |
1744 | PrimitiveBaseShape s = new PrimitiveBaseShape(); | 1317 | PrimitiveBaseShape s = new PrimitiveBaseShape(); |
1745 | s.Scale = new Vector3( | 1318 | s.Scale = new Vector3( |
@@ -1768,8 +1341,7 @@ namespace OpenSim.Data.MySQL | |||
1768 | s.ProfileEnd = Convert.ToUInt16(row["ProfileEnd"]); | 1341 | s.ProfileEnd = Convert.ToUInt16(row["ProfileEnd"]); |
1769 | s.ProfileCurve = Convert.ToByte(row["ProfileCurve"]); | 1342 | s.ProfileCurve = Convert.ToByte(row["ProfileCurve"]); |
1770 | s.ProfileHollow = Convert.ToUInt16(row["ProfileHollow"]); | 1343 | s.ProfileHollow = Convert.ToUInt16(row["ProfileHollow"]); |
1771 | 1344 | byte[] textureEntry = (byte[]) row["Texture"]; | |
1772 | byte[] textureEntry = (byte[]) row["Texture"]; | ||
1773 | s.TextureEntry = textureEntry; | 1345 | s.TextureEntry = textureEntry; |
1774 | 1346 | ||
1775 | s.ExtraParams = (byte[]) row["ExtraParams"]; | 1347 | s.ExtraParams = (byte[]) row["ExtraParams"]; |
@@ -1784,382 +1356,78 @@ namespace OpenSim.Data.MySQL | |||
1784 | /// </summary> | 1356 | /// </summary> |
1785 | /// <param name="row"></param> | 1357 | /// <param name="row"></param> |
1786 | /// <param name="prim"></param> | 1358 | /// <param name="prim"></param> |
1787 | private void fillShapeRow(DataRow row, SceneObjectPart prim) | 1359 | private void FillShapeCommand(MySqlCommand cmd, SceneObjectPart prim) |
1788 | { | 1360 | { |
1789 | PrimitiveBaseShape s = prim.Shape; | 1361 | PrimitiveBaseShape s = prim.Shape; |
1790 | row["UUID"] = Util.ToRawUuidString(prim.UUID); | 1362 | cmd.Parameters.AddWithValue("UUID", Util.ToRawUuidString(prim.UUID)); |
1791 | // shape is an enum | 1363 | // shape is an enum |
1792 | row["Shape"] = 0; | 1364 | cmd.Parameters.AddWithValue("Shape", 0); |
1793 | // vectors | 1365 | // vectors |
1794 | row["ScaleX"] = s.Scale.X; | 1366 | cmd.Parameters.AddWithValue("ScaleX", s.Scale.X); |
1795 | row["ScaleY"] = s.Scale.Y; | 1367 | cmd.Parameters.AddWithValue("ScaleY", s.Scale.Y); |
1796 | row["ScaleZ"] = s.Scale.Z; | 1368 | cmd.Parameters.AddWithValue("ScaleZ", s.Scale.Z); |
1797 | // paths | 1369 | // paths |
1798 | row["PCode"] = s.PCode; | 1370 | cmd.Parameters.AddWithValue("PCode", s.PCode); |
1799 | row["PathBegin"] = s.PathBegin; | 1371 | cmd.Parameters.AddWithValue("PathBegin", s.PathBegin); |
1800 | row["PathEnd"] = s.PathEnd; | 1372 | cmd.Parameters.AddWithValue("PathEnd", s.PathEnd); |
1801 | row["PathScaleX"] = s.PathScaleX; | 1373 | cmd.Parameters.AddWithValue("PathScaleX", s.PathScaleX); |
1802 | row["PathScaleY"] = s.PathScaleY; | 1374 | cmd.Parameters.AddWithValue("PathScaleY", s.PathScaleY); |
1803 | row["PathShearX"] = s.PathShearX; | 1375 | cmd.Parameters.AddWithValue("PathShearX", s.PathShearX); |
1804 | row["PathShearY"] = s.PathShearY; | 1376 | cmd.Parameters.AddWithValue("PathShearY", s.PathShearY); |
1805 | row["PathSkew"] = s.PathSkew; | 1377 | cmd.Parameters.AddWithValue("PathSkew", s.PathSkew); |
1806 | row["PathCurve"] = s.PathCurve; | 1378 | cmd.Parameters.AddWithValue("PathCurve", s.PathCurve); |
1807 | row["PathRadiusOffset"] = s.PathRadiusOffset; | 1379 | cmd.Parameters.AddWithValue("PathRadiusOffset", s.PathRadiusOffset); |
1808 | row["PathRevolutions"] = s.PathRevolutions; | 1380 | cmd.Parameters.AddWithValue("PathRevolutions", s.PathRevolutions); |
1809 | row["PathTaperX"] = s.PathTaperX; | 1381 | cmd.Parameters.AddWithValue("PathTaperX", s.PathTaperX); |
1810 | row["PathTaperY"] = s.PathTaperY; | 1382 | cmd.Parameters.AddWithValue("PathTaperY", s.PathTaperY); |
1811 | row["PathTwist"] = s.PathTwist; | 1383 | cmd.Parameters.AddWithValue("PathTwist", s.PathTwist); |
1812 | row["PathTwistBegin"] = s.PathTwistBegin; | 1384 | cmd.Parameters.AddWithValue("PathTwistBegin", s.PathTwistBegin); |
1813 | // profile | 1385 | // profile |
1814 | row["ProfileBegin"] = s.ProfileBegin; | 1386 | cmd.Parameters.AddWithValue("ProfileBegin", s.ProfileBegin); |
1815 | row["ProfileEnd"] = s.ProfileEnd; | 1387 | cmd.Parameters.AddWithValue("ProfileEnd", s.ProfileEnd); |
1816 | row["ProfileCurve"] = s.ProfileCurve; | 1388 | cmd.Parameters.AddWithValue("ProfileCurve", s.ProfileCurve); |
1817 | row["ProfileHollow"] = s.ProfileHollow; | 1389 | cmd.Parameters.AddWithValue("ProfileHollow", s.ProfileHollow); |
1818 | row["Texture"] = s.TextureEntry; | 1390 | cmd.Parameters.AddWithValue("Texture", s.TextureEntry); |
1819 | row["ExtraParams"] = s.ExtraParams; | 1391 | cmd.Parameters.AddWithValue("ExtraParams", s.ExtraParams); |
1820 | row["State"] = s.State; | 1392 | cmd.Parameters.AddWithValue("State", s.State); |
1821 | } | 1393 | } |
1822 | 1394 | ||
1823 | /// <summary> | ||
1824 | /// | ||
1825 | /// </summary> | ||
1826 | /// <param name="prim"></param> | ||
1827 | /// <param name="sceneGroupID"></param> | ||
1828 | /// <param name="regionUUID"></param> | ||
1829 | private void addPrim(SceneObjectPart prim, UUID sceneGroupID, UUID regionUUID) | ||
1830 | { | ||
1831 | lock (m_dataSet) | ||
1832 | { | ||
1833 | DataTable prims = m_dataSet.Tables["prims"]; | ||
1834 | DataTable shapes = m_dataSet.Tables["primshapes"]; | ||
1835 | |||
1836 | DataRow primRow = prims.Rows.Find(Util.ToRawUuidString(prim.UUID)); | ||
1837 | if (primRow == null) | ||
1838 | { | ||
1839 | primRow = prims.NewRow(); | ||
1840 | fillPrimRow(primRow, prim, sceneGroupID, regionUUID); | ||
1841 | prims.Rows.Add(primRow); | ||
1842 | } | ||
1843 | else | ||
1844 | { | ||
1845 | fillPrimRow(primRow, prim, sceneGroupID, regionUUID); | ||
1846 | } | ||
1847 | |||
1848 | DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(prim.UUID)); | ||
1849 | if (shapeRow == null) | ||
1850 | { | ||
1851 | shapeRow = shapes.NewRow(); | ||
1852 | fillShapeRow(shapeRow, prim); | ||
1853 | shapes.Rows.Add(shapeRow); | ||
1854 | } | ||
1855 | else | ||
1856 | { | ||
1857 | fillShapeRow(shapeRow, prim); | ||
1858 | } | ||
1859 | } | ||
1860 | } | ||
1861 | |||
1862 | /// <summary> | ||
1863 | /// see IRegionDatastore | ||
1864 | /// </summary> | ||
1865 | /// <param name="primID"></param> | ||
1866 | /// <param name="items"></param> | ||
1867 | public void StorePrimInventory(UUID primID, ICollection<TaskInventoryItem> items) | 1395 | public void StorePrimInventory(UUID primID, ICollection<TaskInventoryItem> items) |
1868 | { | 1396 | { |
1869 | //m_log.InfoFormat("[REGION DB]: Persisting Prim Inventory with prim ID {0}", primID); | 1397 | lock (m_Connection) |
1870 | |||
1871 | // For now, we're just going to crudely remove all the previous inventory items | ||
1872 | // no matter whether they have changed or not, and replace them with the current set. | ||
1873 | lock (m_dataSet) | ||
1874 | { | 1398 | { |
1875 | RemoveItems(primID); | 1399 | RemoveItems(primID); |
1876 | 1400 | ||
1877 | // repalce with current inventory details | 1401 | MySqlCommand cmd = m_Connection.CreateCommand(); |
1878 | foreach (TaskInventoryItem newItem in items) | 1402 | |
1403 | if (items.Count == 0) | ||
1404 | return; | ||
1405 | |||
1406 | cmd.CommandText = "insert into primitems ("+ | ||
1407 | "invType, assetType, name, "+ | ||
1408 | "description, creationDate, nextPermissions, "+ | ||
1409 | "currentPermissions, basePermissions, "+ | ||
1410 | "everyonePermissions, groupPermissions, "+ | ||
1411 | "flags, itemID, primID, assetID, "+ | ||
1412 | "parentFolderID, creatorID, ownerID, "+ | ||
1413 | "groupID, lastOwnerID) values (?invType, "+ | ||
1414 | "?assetType, ?name, ?description, "+ | ||
1415 | "?creationDate, ?nextPermissions, "+ | ||
1416 | "?currentPermissions, ?basePermissions, "+ | ||
1417 | "?everyonePermissions, ?groupPermissions, "+ | ||
1418 | "?flags, ?itemID, ?primID, ?assetID, "+ | ||
1419 | "?parentFolderID, ?creatorID, ?ownerID, "+ | ||
1420 | "?groupID, ?lastOwnerID)"; | ||
1421 | |||
1422 | foreach (TaskInventoryItem item in items) | ||
1879 | { | 1423 | { |
1880 | // m_log.InfoFormat( | 1424 | cmd.Parameters.Clear(); |
1881 | // "[REGION DB]: " + | ||
1882 | // "Adding item {0}, {1} to prim ID {2}", | ||
1883 | // newItem.Name, newItem.ItemID, newItem.ParentPartID); | ||
1884 | |||
1885 | DataRow newItemRow = m_itemsTable.NewRow(); | ||
1886 | fillItemRow(newItemRow, newItem); | ||
1887 | m_itemsTable.Rows.Add(newItemRow); | ||
1888 | } | ||
1889 | } | ||
1890 | |||
1891 | Commit(); | ||
1892 | } | ||
1893 | |||
1894 | /*********************************************************************** | ||
1895 | * | ||
1896 | * SQL Statement Creation Functions | ||
1897 | * | ||
1898 | * These functions create SQL statements for update, insert, and create. | ||
1899 | * They can probably be factored later to have a db independant | ||
1900 | * portion and a db specific portion | ||
1901 | * | ||
1902 | **********************************************************************/ | ||
1903 | |||
1904 | /// <summary> | ||
1905 | /// Create a MySQL insert command | ||
1906 | /// </summary> | ||
1907 | /// <param name="table"></param> | ||
1908 | /// <param name="dt"></param> | ||
1909 | /// <returns></returns> | ||
1910 | /// <remarks> | ||
1911 | /// This is subtle enough to deserve some commentary. | ||
1912 | /// Instead of doing *lots* and *lots of hardcoded strings | ||
1913 | /// for database definitions we'll use the fact that | ||
1914 | /// realistically all insert statements look like "insert | ||
1915 | /// into A(b, c) values(:b, :c) on the parameterized query | ||
1916 | /// front. If we just have a list of b, c, etc... we can | ||
1917 | /// generate these strings instead of typing them out. | ||
1918 | /// </remarks> | ||
1919 | private static MySqlCommand createInsertCommand(string table, DataTable dt) | ||
1920 | { | ||
1921 | 1425 | ||
1922 | string[] cols = new string[dt.Columns.Count]; | 1426 | FillItemCommand(cmd, item); |
1923 | for (int i = 0; i < dt.Columns.Count; i++) | ||
1924 | { | ||
1925 | DataColumn col = dt.Columns[i]; | ||
1926 | cols[i] = col.ColumnName; | ||
1927 | } | ||
1928 | 1427 | ||
1929 | string sql = "insert into " + table + "("; | 1428 | ExecuteNonQuery(cmd); |
1930 | sql += String.Join(", ", cols); | ||
1931 | // important, the first ':' needs to be here, the rest get added in the join | ||
1932 | sql += ") values (?"; | ||
1933 | sql += String.Join(", ?", cols); | ||
1934 | sql += ")"; | ||
1935 | MySqlCommand cmd = new MySqlCommand(sql); | ||
1936 | |||
1937 | // this provides the binding for all our parameters, so | ||
1938 | // much less code than it used to be | ||
1939 | foreach (DataColumn col in dt.Columns) | ||
1940 | { | ||
1941 | cmd.Parameters.Add(createMySqlParameter(col.ColumnName, col.DataType)); | ||
1942 | } | ||
1943 | return cmd; | ||
1944 | } | ||
1945 | |||
1946 | /// <summary> | ||
1947 | /// Create a MySQL update command | ||
1948 | /// </summary> | ||
1949 | /// <param name="table"></param> | ||
1950 | /// <param name="pk"></param> | ||
1951 | /// <param name="dt"></param> | ||
1952 | /// <returns></returns> | ||
1953 | private static MySqlCommand createUpdateCommand(string table, string pk, DataTable dt) | ||
1954 | { | ||
1955 | string sql = "update " + table + " set "; | ||
1956 | string subsql = String.Empty; | ||
1957 | foreach (DataColumn col in dt.Columns) | ||
1958 | { | ||
1959 | if (subsql.Length > 0) | ||
1960 | { | ||
1961 | // a map function would rock so much here | ||
1962 | subsql += ", "; | ||
1963 | } | 1429 | } |
1964 | subsql += col.ColumnName + "=?" + col.ColumnName; | ||
1965 | } | ||
1966 | sql += subsql; | ||
1967 | sql += " where " + pk; | ||
1968 | MySqlCommand cmd = new MySqlCommand(sql); | ||
1969 | |||
1970 | // this provides the binding for all our parameters, so | ||
1971 | // much less code than it used to be | ||
1972 | |||
1973 | foreach (DataColumn col in dt.Columns) | ||
1974 | { | ||
1975 | cmd.Parameters.Add(createMySqlParameter(col.ColumnName, col.DataType)); | ||
1976 | } | ||
1977 | return cmd; | ||
1978 | } | ||
1979 | |||
1980 | /*********************************************************************** | ||
1981 | * | ||
1982 | * Database Binding functions | ||
1983 | * | ||
1984 | * These will be db specific due to typing, and minor differences | ||
1985 | * in databases. | ||
1986 | * | ||
1987 | **********************************************************************/ | ||
1988 | |||
1989 | ///<summary> | ||
1990 | /// <para>This is a convenience function that collapses 5 repetitive | ||
1991 | /// lines for defining MySqlParameters to 2 parameters: | ||
1992 | /// column name and database type. | ||
1993 | /// </para> | ||
1994 | /// <para> | ||
1995 | /// It assumes certain conventions like ?param as the param | ||
1996 | /// name to replace in parametrized queries, and that source | ||
1997 | /// version is always current version, both of which are fine | ||
1998 | /// for us. | ||
1999 | /// </para> | ||
2000 | /// </summary> | ||
2001 | /// <returns>a built MySql parameter</returns> | ||
2002 | private static MySqlParameter createMySqlParameter(string name, Type type) | ||
2003 | { | ||
2004 | MySqlParameter param = new MySqlParameter(); | ||
2005 | param.ParameterName = "?" + name; | ||
2006 | param.DbType = dbtypeFromType(type); | ||
2007 | param.SourceColumn = name; | ||
2008 | param.SourceVersion = DataRowVersion.Current; | ||
2009 | return param; | ||
2010 | } | ||
2011 | |||
2012 | /// <summary> | ||
2013 | /// | ||
2014 | /// </summary> | ||
2015 | /// <param name="da"></param> | ||
2016 | /// <param name="conn"></param> | ||
2017 | private void SetupPrimCommands(MySqlDataAdapter da, MySqlConnection conn) | ||
2018 | { | ||
2019 | MySqlCommand insertCommand = createInsertCommand("prims", m_primTable); | ||
2020 | insertCommand.Connection = conn; | ||
2021 | da.InsertCommand = insertCommand; | ||
2022 | |||
2023 | MySqlCommand updateCommand = createUpdateCommand("prims", "UUID=?UUID", m_primTable); | ||
2024 | updateCommand.Connection = conn; | ||
2025 | da.UpdateCommand = updateCommand; | ||
2026 | |||
2027 | MySqlCommand delete = new MySqlCommand("delete from prims where UUID=?UUID"); | ||
2028 | delete.Parameters.Add(createMySqlParameter("UUID", typeof (String))); | ||
2029 | delete.Connection = conn; | ||
2030 | da.DeleteCommand = delete; | ||
2031 | } | ||
2032 | |||
2033 | /// <summary> | ||
2034 | /// | ||
2035 | /// </summary> | ||
2036 | /// <param name="da"></param> | ||
2037 | /// <param name="conn"></param> | ||
2038 | private void SetupItemsCommands(MySqlDataAdapter da, MySqlConnection conn) | ||
2039 | { | ||
2040 | da.InsertCommand = createInsertCommand("primitems", m_itemsTable); | ||
2041 | da.InsertCommand.Connection = conn; | ||
2042 | |||
2043 | da.UpdateCommand = createUpdateCommand("primitems", "itemID = ?itemID", m_itemsTable); | ||
2044 | da.UpdateCommand.Connection = conn; | ||
2045 | |||
2046 | MySqlCommand delete = new MySqlCommand("delete from primitems where itemID = ?itemID"); | ||
2047 | delete.Parameters.Add(createMySqlParameter("itemID", typeof (String))); | ||
2048 | delete.Connection = conn; | ||
2049 | da.DeleteCommand = delete; | ||
2050 | } | ||
2051 | |||
2052 | private void SetupRegionSettingsCommands(MySqlDataAdapter da, MySqlConnection conn) | ||
2053 | { | ||
2054 | da.InsertCommand = createInsertCommand("regionsettings", m_regionSettingsTable); | ||
2055 | da.InsertCommand.Connection = conn; | ||
2056 | |||
2057 | da.UpdateCommand = createUpdateCommand("regionsettings", "regionUUID = ?regionUUID", m_regionSettingsTable); | ||
2058 | da.UpdateCommand.Connection = conn; | ||
2059 | |||
2060 | MySqlCommand delete = new MySqlCommand("delete from regionsettings where regionUUID = ?regionUUID"); | ||
2061 | delete.Parameters.Add(createMySqlParameter("regionUUID", typeof(String))); | ||
2062 | delete.Connection = conn; | ||
2063 | da.DeleteCommand = delete; | ||
2064 | } | ||
2065 | |||
2066 | /// <summary> | ||
2067 | /// | ||
2068 | /// </summary> | ||
2069 | /// <param name="da"></param> | ||
2070 | /// <param name="conn"></param> | ||
2071 | private void SetupTerrainCommands(MySqlDataAdapter da, MySqlConnection conn) | ||
2072 | { | ||
2073 | da.InsertCommand = createInsertCommand("terrain", m_dataSet.Tables["terrain"]); | ||
2074 | da.InsertCommand.Connection = conn; | ||
2075 | } | ||
2076 | |||
2077 | /// <summary> | ||
2078 | /// | ||
2079 | /// </summary> | ||
2080 | /// <param name="da"></param> | ||
2081 | /// <param name="conn"></param> | ||
2082 | private void setupLandCommands(MySqlDataAdapter da, MySqlConnection conn) | ||
2083 | { | ||
2084 | da.InsertCommand = createInsertCommand("land", m_dataSet.Tables["land"]); | ||
2085 | da.InsertCommand.Connection = conn; | ||
2086 | |||
2087 | da.UpdateCommand = createUpdateCommand("land", "UUID=?UUID", m_dataSet.Tables["land"]); | ||
2088 | da.UpdateCommand.Connection = conn; | ||
2089 | } | ||
2090 | |||
2091 | /// <summary> | ||
2092 | /// | ||
2093 | /// </summary> | ||
2094 | /// <param name="da"></param> | ||
2095 | /// <param name="conn"></param> | ||
2096 | private void setupLandAccessCommands(MySqlDataAdapter da, MySqlConnection conn) | ||
2097 | { | ||
2098 | da.InsertCommand = createInsertCommand("landaccesslist", m_dataSet.Tables["landaccesslist"]); | ||
2099 | da.InsertCommand.Connection = conn; | ||
2100 | } | ||
2101 | |||
2102 | /// <summary> | ||
2103 | /// | ||
2104 | /// </summary> | ||
2105 | /// <param name="da"></param> | ||
2106 | /// <param name="conn"></param> | ||
2107 | private void SetupShapeCommands(MySqlDataAdapter da, MySqlConnection conn) | ||
2108 | { | ||
2109 | da.InsertCommand = createInsertCommand("primshapes", m_dataSet.Tables["primshapes"]); | ||
2110 | da.InsertCommand.Connection = conn; | ||
2111 | |||
2112 | da.UpdateCommand = createUpdateCommand("primshapes", "UUID=?UUID", m_dataSet.Tables["primshapes"]); | ||
2113 | da.UpdateCommand.Connection = conn; | ||
2114 | |||
2115 | MySqlCommand delete = new MySqlCommand("delete from primshapes where UUID = ?UUID"); | ||
2116 | delete.Parameters.Add(createMySqlParameter("UUID", typeof (String))); | ||
2117 | delete.Connection = conn; | ||
2118 | da.DeleteCommand = delete; | ||
2119 | } | ||
2120 | |||
2121 | /*********************************************************************** | ||
2122 | * | ||
2123 | * Type conversion functions | ||
2124 | * | ||
2125 | **********************************************************************/ | ||
2126 | |||
2127 | /// <summary> | ||
2128 | /// Type conversion functions | ||
2129 | /// </summary> | ||
2130 | /// <param name="type"></param> | ||
2131 | /// <returns></returns> | ||
2132 | private static DbType dbtypeFromType(Type type) | ||
2133 | { | ||
2134 | if (type == typeof (String)) | ||
2135 | { | ||
2136 | return DbType.String; | ||
2137 | } | ||
2138 | else if (type == typeof (Int32)) | ||
2139 | { | ||
2140 | return DbType.Int32; | ||
2141 | } | ||
2142 | else if (type == typeof (Double)) | ||
2143 | { | ||
2144 | return DbType.Double; | ||
2145 | } | ||
2146 | else if (type == typeof (Byte)) | ||
2147 | { | ||
2148 | return DbType.Byte; | ||
2149 | } | ||
2150 | else if (type == typeof (Double)) | ||
2151 | { | ||
2152 | return DbType.Double; | ||
2153 | } | ||
2154 | else if (type == typeof (Byte[])) | ||
2155 | { | ||
2156 | return DbType.Binary; | ||
2157 | } | ||
2158 | else | ||
2159 | { | ||
2160 | return DbType.String; | ||
2161 | } | 1430 | } |
2162 | } | 1431 | } |
2163 | |||
2164 | } | 1432 | } |
2165 | } | 1433 | } |
diff --git a/OpenSim/Data/MySQL/Resources/023_RegionStore.sql b/OpenSim/Data/MySQL/Resources/023_RegionStore.sql new file mode 100644 index 0000000..559591f --- /dev/null +++ b/OpenSim/Data/MySQL/Resources/023_RegionStore.sql | |||
@@ -0,0 +1,6 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE prims ADD COLUMN LinkNumber integer not null default 0; | ||
4 | |||
5 | COMMIT; | ||
6 | |||
diff --git a/OpenSim/Framework/TaskInventoryItem.cs b/OpenSim/Framework/TaskInventoryItem.cs index 1443e74..43d28e7 100644 --- a/OpenSim/Framework/TaskInventoryItem.cs +++ b/OpenSim/Framework/TaskInventoryItem.cs | |||
@@ -329,6 +329,7 @@ namespace OpenSim.Framework | |||
329 | { | 329 | { |
330 | _itemID = UUID.Random(); | 330 | _itemID = UUID.Random(); |
331 | _parentPartID = partID; | 331 | _parentPartID = partID; |
332 | _parentID = partID; | ||
332 | } | 333 | } |
333 | 334 | ||
334 | public TaskInventoryItem() | 335 | public TaskInventoryItem() |
diff --git a/OpenSim/Region/Environment/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Environment/Scenes/SceneObjectGroup.cs index 9839126..7bdcb5c 100644 --- a/OpenSim/Region/Environment/Scenes/SceneObjectGroup.cs +++ b/OpenSim/Region/Environment/Scenes/SceneObjectGroup.cs | |||
@@ -1336,6 +1336,8 @@ namespace OpenSim.Region.Environment.Scenes | |||
1336 | 1336 | ||
1337 | dupe.CopyRootPart(m_rootPart, OwnerID, GroupID, userExposed); | 1337 | dupe.CopyRootPart(m_rootPart, OwnerID, GroupID, userExposed); |
1338 | 1338 | ||
1339 | dupe.m_rootPart.LinkNum = m_rootPart.LinkNum; | ||
1340 | |||
1339 | if (userExposed) | 1341 | if (userExposed) |
1340 | dupe.m_rootPart.TrimPermissions(); | 1342 | dupe.m_rootPart.TrimPermissions(); |
1341 | 1343 | ||
@@ -1368,16 +1370,25 @@ namespace OpenSim.Region.Environment.Scenes | |||
1368 | } | 1370 | } |
1369 | 1371 | ||
1370 | List<SceneObjectPart> partList = new List<SceneObjectPart>(m_parts.Values); | 1372 | List<SceneObjectPart> partList = new List<SceneObjectPart>(m_parts.Values); |
1373 | partList.Sort(delegate(SceneObjectPart p1, SceneObjectPart p2) | ||
1374 | { | ||
1375 | return p1.LinkNum.CompareTo(p2.LinkNum); | ||
1376 | } | ||
1377 | ); | ||
1378 | |||
1371 | foreach (SceneObjectPart part in partList) | 1379 | foreach (SceneObjectPart part in partList) |
1372 | { | 1380 | { |
1373 | if (part.UUID != m_rootPart.UUID) | 1381 | if (part.UUID != m_rootPart.UUID) |
1374 | { | 1382 | { |
1375 | dupe.CopyPart(part, OwnerID, GroupID, userExposed); | 1383 | SceneObjectPart newPart = |
1384 | dupe.CopyPart(part, OwnerID, GroupID, userExposed); | ||
1385 | |||
1386 | newPart.LinkNum = part.LinkNum; | ||
1376 | 1387 | ||
1377 | if (userExposed) | 1388 | if (userExposed) |
1378 | { | 1389 | { |
1379 | SetPartOwner(part, cAgentID, cGroupID); | 1390 | SetPartOwner(newPart, cAgentID, cGroupID); |
1380 | part.ScheduleFullUpdate(); | 1391 | newPart.ScheduleFullUpdate(); |
1381 | } | 1392 | } |
1382 | } | 1393 | } |
1383 | } | 1394 | } |
@@ -1507,7 +1518,7 @@ namespace OpenSim.Region.Environment.Scenes | |||
1507 | /// <param name="part"></param> | 1518 | /// <param name="part"></param> |
1508 | /// <param name="cAgentID"></param> | 1519 | /// <param name="cAgentID"></param> |
1509 | /// <param name="cGroupID"></param> | 1520 | /// <param name="cGroupID"></param> |
1510 | public void CopyPart(SceneObjectPart part, UUID cAgentID, UUID cGroupID, bool userExposed) | 1521 | public SceneObjectPart CopyPart(SceneObjectPart part, UUID cAgentID, UUID cGroupID, bool userExposed) |
1511 | { | 1522 | { |
1512 | SceneObjectPart newPart = part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, m_parts.Count, userExposed); | 1523 | SceneObjectPart newPart = part.Copy(m_scene.AllocateLocalId(), OwnerID, GroupID, m_parts.Count, userExposed); |
1513 | newPart.SetParent(this); | 1524 | newPart.SetParent(this); |
@@ -1519,6 +1530,7 @@ namespace OpenSim.Region.Environment.Scenes | |||
1519 | 1530 | ||
1520 | SetPartAsNonRoot(newPart); | 1531 | SetPartAsNonRoot(newPart); |
1521 | 1532 | ||
1533 | return newPart; | ||
1522 | } | 1534 | } |
1523 | 1535 | ||
1524 | /// <summary> | 1536 | /// <summary> |
diff --git a/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs b/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs index e97b99f..5b494d3 100644 --- a/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs +++ b/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs | |||
@@ -1263,10 +1263,18 @@ if (m_shape != null) { | |||
1263 | dupe._category = _category; | 1263 | dupe._category = _category; |
1264 | dupe.m_rezzed = m_rezzed; | 1264 | dupe.m_rezzed = m_rezzed; |
1265 | 1265 | ||
1266 | dupe.m_inventory.Items = (TaskInventoryDictionary)dupe.m_inventory.Items.Clone(); | 1266 | dupe.m_inventory = new SceneObjectPartInventory(dupe); |
1267 | dupe.m_inventory.Items = (TaskInventoryDictionary)m_inventory.Items.Clone(); | ||
1267 | 1268 | ||
1268 | if (userExposed) | 1269 | if (userExposed) |
1270 | { | ||
1269 | dupe.ResetIDs(linkNum); | 1271 | dupe.ResetIDs(linkNum); |
1272 | dupe.m_inventory.HasInventoryChanged = true; | ||
1273 | } | ||
1274 | else | ||
1275 | { | ||
1276 | dupe.m_inventory.HasInventoryChanged = m_inventory.HasInventoryChanged; | ||
1277 | } | ||
1270 | 1278 | ||
1271 | // Move afterwards ResetIDs as it clears the localID | 1279 | // Move afterwards ResetIDs as it clears the localID |
1272 | dupe.LocalId = localID; | 1280 | dupe.LocalId = localID; |
diff --git a/OpenSim/Region/Environment/Scenes/SceneObjectPartInventory.cs b/OpenSim/Region/Environment/Scenes/SceneObjectPartInventory.cs index ae43c5e..3f94a7e 100644 --- a/OpenSim/Region/Environment/Scenes/SceneObjectPartInventory.cs +++ b/OpenSim/Region/Environment/Scenes/SceneObjectPartInventory.cs | |||
@@ -64,7 +64,7 @@ namespace OpenSim.Region.Environment.Scenes | |||
64 | /// <summary> | 64 | /// <summary> |
65 | /// Tracks whether inventory has changed since the last persistent backup | 65 | /// Tracks whether inventory has changed since the last persistent backup |
66 | /// </summary> | 66 | /// </summary> |
67 | protected bool HasInventoryChanged; | 67 | internal bool HasInventoryChanged; |
68 | 68 | ||
69 | /// <value> | 69 | /// <value> |
70 | /// Inventory serial number | 70 | /// Inventory serial number |
@@ -81,7 +81,11 @@ namespace OpenSim.Region.Environment.Scenes | |||
81 | protected internal TaskInventoryDictionary Items | 81 | protected internal TaskInventoryDictionary Items |
82 | { | 82 | { |
83 | get { return m_items; } | 83 | get { return m_items; } |
84 | set { m_items = value; } | 84 | set |
85 | { | ||
86 | m_items = value; | ||
87 | m_inventorySerial++; | ||
88 | } | ||
85 | } | 89 | } |
86 | 90 | ||
87 | /// <summary> | 91 | /// <summary> |