11 files changed, 465 insertions, 306 deletions

diff --git a/OpenSim/Data/SQLite/Properties/AssemblyInfo.cs b/OpenSim/Data/SQLite/Properties/AssemblyInfo.cs
index d45ab50..c9a8553 100644
--- a/OpenSim/Data/SQLite/Properties/AssemblyInfo.cs
+++ b/OpenSim/Data/SQLite/Properties/AssemblyInfo.cs
@@ -61,5 +61,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Revision and Build Numbers
 // by using the '*' as shown below:
 
-[assembly : AssemblyVersion("0.6.5.*")]
+[assembly : AssemblyVersion("0.7.5.*")]
 [assembly : AssemblyFileVersion("0.6.5.0")]
diff --git a/OpenSim/Data/SQLite/SQLiteAssetData.cs b/OpenSim/Data/SQLite/SQLiteAssetData.cs
index d0e24c3..61e7aaf 100644
--- a/OpenSim/Data/SQLite/SQLiteAssetData.cs
+++ b/OpenSim/Data/SQLite/SQLiteAssetData.cs
@@ -202,7 +202,8 @@ namespace OpenSim.Data.SQLite
         /// <returns>True if exist, or false.</returns>
         override public bool ExistsAsset(UUID uuid)
         {
-            lock (this) {
+            lock (this) 
+            {
                 using (SqliteCommand cmd = new SqliteCommand(SelectAssetSQL, m_conn))
                 {
                     cmd.Parameters.Add(new SqliteParameter(":UUID", uuid.ToString()));
@@ -353,12 +354,13 @@ namespace OpenSim.Data.SQLite
         {
             lock (this)
             {
-            using (SqliteCommand cmd = new SqliteCommand(DeleteAssetSQL, m_conn))
-            {
-                cmd.Parameters.Add(new SqliteParameter(":UUID", uuid.ToString()));
-                cmd.ExecuteNonQuery();
-            }
+                using (SqliteCommand cmd = new SqliteCommand(DeleteAssetSQL, m_conn))
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":UUID", uuid.ToString()));
+                    cmd.ExecuteNonQuery();
+                }
             }
+
             return true;
         }
 
diff --git a/OpenSim/Data/SQLite/SQLiteAuthenticationData.cs b/OpenSim/Data/SQLite/SQLiteAuthenticationData.cs
index 5120453..0428c11 100644
--- a/OpenSim/Data/SQLite/SQLiteAuthenticationData.cs
+++ b/OpenSim/Data/SQLite/SQLiteAuthenticationData.cs
@@ -82,11 +82,14 @@ namespace OpenSim.Data.SQLite
         {
             AuthenticationData ret = new AuthenticationData();
             ret.Data = new Dictionary<string, object>();
+            IDataReader result;
 
-            SqliteCommand cmd = new SqliteCommand("select * from `" + m_Realm + "` where UUID = :PrincipalID");
-            cmd.Parameters.Add(new SqliteParameter(":PrincipalID", principalID.ToString()));
+            using (SqliteCommand cmd = new SqliteCommand("select * from `" + m_Realm + "` where UUID = :PrincipalID"))
+            {
+                cmd.Parameters.Add(new SqliteParameter(":PrincipalID", principalID.ToString()));
 
-            IDataReader result = ExecuteReader(cmd, m_Connection);
+                result = ExecuteReader(cmd, m_Connection);
+            }
 
             try
             {
@@ -121,10 +124,6 @@ namespace OpenSim.Data.SQLite
             catch
             {
             }
-            finally
-            {
-                //CloseCommand(cmd);
-            }
 
             return null;
         }
@@ -140,84 +139,81 @@ namespace OpenSim.Data.SQLite
             foreach (object o in data.Data.Values)
                 values[i++] = o.ToString();
 
-            SqliteCommand cmd = new SqliteCommand();
-
-            if (Get(data.PrincipalID) != null)
+            using (SqliteCommand cmd = new SqliteCommand())
             {
+                if (Get(data.PrincipalID) != null)
+                {
 
 
-                string update = "update `" + m_Realm + "` set ";
-                bool first = true;
-                foreach (string field in fields)
-                {
-                    if (!first)
-                        update += ", ";
-                    update += "`" + field + "` = :" + field;
-                    cmd.Parameters.Add(new SqliteParameter(":" + field, data.Data[field]));
+                    string update = "update `" + m_Realm + "` set ";
+                    bool first = true;
+                    foreach (string field in fields)
+                    {
+                        if (!first)
+                            update += ", ";
+                        update += "`" + field + "` = :" + field;
+                        cmd.Parameters.Add(new SqliteParameter(":" + field, data.Data[field]));
 
-                    first = false;
-                }
+                        first = false;
+                    }
 
-                update += " where UUID = :UUID";
-                cmd.Parameters.Add(new SqliteParameter(":UUID", data.PrincipalID.ToString()));
+                    update += " where UUID = :UUID";
+                    cmd.Parameters.Add(new SqliteParameter(":UUID", data.PrincipalID.ToString()));
 
-                cmd.CommandText = update;
-                try
-                {
-                    if (ExecuteNonQuery(cmd, m_Connection) < 1)
+                    cmd.CommandText = update;
+                    try
+                    {
+                        if (ExecuteNonQuery(cmd, m_Connection) < 1)
+                        {
+                            //CloseCommand(cmd);
+                            return false;
+                        }
+                    }
+                    catch (Exception e)
                     {
+                        m_log.Error("[SQLITE]: Exception storing authentication data", e);
                         //CloseCommand(cmd);
                         return false;
                     }
                 }
-                catch (Exception e)
+                else
                 {
-                    m_log.Error("[SQLITE]: Exception storing authentication data", e);
-                    //CloseCommand(cmd);
-                    return false;
-                }
-            }
+                    string insert = "insert into `" + m_Realm + "` (`UUID`, `" +
+                            String.Join("`, `", fields) +
+                            "`) values (:UUID, :" + String.Join(", :", fields) + ")";
 
-            else
-            {
-                string insert = "insert into `" + m_Realm + "` (`UUID`, `" +
-                        String.Join("`, `", fields) +
-                        "`) values (:UUID, :" + String.Join(", :", fields) + ")";
-
-                cmd.Parameters.Add(new SqliteParameter(":UUID", data.PrincipalID.ToString()));
-                foreach (string field in fields)
-                    cmd.Parameters.Add(new SqliteParameter(":" + field, data.Data[field]));
+                    cmd.Parameters.Add(new SqliteParameter(":UUID", data.PrincipalID.ToString()));
+                    foreach (string field in fields)
+                        cmd.Parameters.Add(new SqliteParameter(":" + field, data.Data[field]));
 
-                cmd.CommandText = insert;
+                    cmd.CommandText = insert;
 
-                try
-                {
-                    if (ExecuteNonQuery(cmd, m_Connection) < 1)
+                    try
                     {
-                        //CloseCommand(cmd);
+                        if (ExecuteNonQuery(cmd, m_Connection) < 1)
+                        {
+                            return false;
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        Console.WriteLine(e.ToString());
                         return false;
                     }
                 }
-                catch (Exception e)
-                {
-                    Console.WriteLine(e.ToString());
-                    //CloseCommand(cmd);
-                    return false;
-                }
             }
 
-            //CloseCommand(cmd);
-
             return true;
         }
 
         public bool SetDataItem(UUID principalID, string item, string value)
         {
-            SqliteCommand cmd = new SqliteCommand("update `" + m_Realm +
-                    "` set `" + item + "` = " + value + " where UUID = '" + principalID.ToString() + "'");
-
-            if (ExecuteNonQuery(cmd, m_Connection) > 0)
-                return true;
+            using (SqliteCommand cmd = new SqliteCommand("update `" + m_Realm +
+                    "` set `" + item + "` = " + value + " where UUID = '" + principalID.ToString() + "'"))
+            {
+                if (ExecuteNonQuery(cmd, m_Connection) > 0)
+                    return true;
+            }
 
             return false;
         }
@@ -227,16 +223,13 @@ namespace OpenSim.Data.SQLite
             if (System.Environment.TickCount - m_LastExpire > 30000)
                 DoExpire();
 
-            SqliteCommand cmd = new SqliteCommand("insert into tokens (UUID, token, validity) values ('" + principalID.ToString() + 
-                "', '" + token + "', datetime('now', 'localtime', '+" + lifetime.ToString() + " minutes'))");
-
-            if (ExecuteNonQuery(cmd, m_Connection) > 0)
+            using (SqliteCommand cmd = new SqliteCommand("insert into tokens (UUID, token, validity) values ('" + principalID.ToString() + 
+                "', '" + token + "', datetime('now', 'localtime', '+" + lifetime.ToString() + " minutes'))"))
             {
-                cmd.Dispose();
-                return true;
+                if (ExecuteNonQuery(cmd, m_Connection) > 0)
+                    return true;
             }
 
-            cmd.Dispose();
             return false;
         }
 
@@ -245,28 +238,22 @@ namespace OpenSim.Data.SQLite
             if (System.Environment.TickCount - m_LastExpire > 30000)
                 DoExpire();
 
-            SqliteCommand cmd = new SqliteCommand("update tokens set validity = datetime('now', 'localtime', '+" + lifetime.ToString() + 
-                " minutes') where UUID = '" + principalID.ToString() + "' and token = '" + token + "' and validity > datetime('now', 'localtime')");
-
-            if (ExecuteNonQuery(cmd, m_Connection) > 0)
+            using (SqliteCommand cmd = new SqliteCommand("update tokens set validity = datetime('now', 'localtime', '+" + lifetime.ToString() + 
+                " minutes') where UUID = '" + principalID.ToString() + "' and token = '" + token + "' and validity > datetime('now', 'localtime')"))
             {
-                cmd.Dispose();
-                return true;
+                if (ExecuteNonQuery(cmd, m_Connection) > 0)
+                    return true;
             }
 
-            cmd.Dispose();
-
             return false;
         }
 
         private void DoExpire()
         {
-            SqliteCommand cmd = new SqliteCommand("delete from tokens where validity < datetime('now', 'localtime')");
-            ExecuteNonQuery(cmd, m_Connection);
-
-            cmd.Dispose();
+            using (SqliteCommand cmd = new SqliteCommand("delete from tokens where validity < datetime('now', 'localtime')"))
+                ExecuteNonQuery(cmd, m_Connection);
 
             m_LastExpire = System.Environment.TickCount;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Data/SQLite/SQLiteAvatarData.cs b/OpenSim/Data/SQLite/SQLiteAvatarData.cs
index faf34da..c6d615b 100644
--- a/OpenSim/Data/SQLite/SQLiteAvatarData.cs
+++ b/OpenSim/Data/SQLite/SQLiteAvatarData.cs
@@ -56,23 +56,17 @@ namespace OpenSim.Data.SQLite
 
         public bool Delete(UUID principalID, string name)
         {
-            SqliteCommand cmd = new SqliteCommand();
-
-            cmd.CommandText = String.Format("delete from {0} where `PrincipalID` = :PrincipalID and `Name` = :Name", m_Realm);
-            cmd.Parameters.AddWithValue(":PrincipalID", principalID.ToString());
-            cmd.Parameters.AddWithValue(":Name", name);
-
-            try
+            using (SqliteCommand cmd = new SqliteCommand())
             {
+                cmd.CommandText = String.Format("delete from {0} where `PrincipalID` = :PrincipalID and `Name` = :Name", m_Realm);
+                cmd.Parameters.AddWithValue(":PrincipalID", principalID.ToString());
+                cmd.Parameters.AddWithValue(":Name", name);
+
                 if (ExecuteNonQuery(cmd, m_Connection) > 0)
                     return true;
-
-                return false;
-            }
-            finally
-            {
-                //CloseCommand(cmd);
             }
+
+            return false;
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Data/SQLite/SQLiteEstateData.cs b/OpenSim/Data/SQLite/SQLiteEstateData.cs
index c042ba2..d51f2d4 100644
--- a/OpenSim/Data/SQLite/SQLiteEstateData.cs
+++ b/OpenSim/Data/SQLite/SQLiteEstateData.cs
@@ -104,12 +104,13 @@ namespace OpenSim.Data.SQLite
         {
             string sql = "select estate_settings."+String.Join(",estate_settings.", FieldList)+" from estate_map left join estate_settings on estate_map.EstateID = estate_settings.EstateID where estate_settings.EstateID is not null and RegionID = :RegionID";
 
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
-
-            cmd.CommandText = sql;
-            cmd.Parameters.AddWithValue(":RegionID", regionID.ToString());
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
+            {
+                cmd.CommandText = sql;
+                cmd.Parameters.AddWithValue(":RegionID", regionID.ToString());
 
-            return DoLoad(cmd, regionID, create);
+                return DoLoad(cmd, regionID, create);
+            }
         }
 
         private EstateSettings DoLoad(SqliteCommand cmd, UUID regionID, bool create)
@@ -186,37 +187,39 @@ namespace OpenSim.Data.SQLite
         {
             List<string> names = new List<string>(FieldList);
 
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
             IDataReader r = null;
 
-            names.Remove("EstateID");
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
+            {            
+                names.Remove("EstateID");
 
-            string sql = "insert into estate_settings ("+String.Join(",", names.ToArray())+") values ( :"+String.Join(", :", names.ToArray())+")";
+                string sql = "insert into estate_settings ("+String.Join(",", names.ToArray())+") values ( :"+String.Join(", :", names.ToArray())+")";
 
-            cmd.CommandText = sql;
-            cmd.Parameters.Clear();
+                cmd.CommandText = sql;
+                cmd.Parameters.Clear();
 
-            foreach (string name in FieldList)
-            {
-                if (m_FieldMap[name].GetValue(es) is bool)
+                foreach (string name in FieldList)
                 {
-                    if ((bool)m_FieldMap[name].GetValue(es))
-                        cmd.Parameters.AddWithValue(":"+name, "1");
+                    if (m_FieldMap[name].GetValue(es) is bool)
+                    {
+                        if ((bool)m_FieldMap[name].GetValue(es))
+                            cmd.Parameters.AddWithValue(":"+name, "1");
+                        else
+                            cmd.Parameters.AddWithValue(":"+name, "0");
+                    }
                     else
-                        cmd.Parameters.AddWithValue(":"+name, "0");
-                }
-                else
-                {
-                    cmd.Parameters.AddWithValue(":"+name, m_FieldMap[name].GetValue(es).ToString());
+                    {
+                        cmd.Parameters.AddWithValue(":"+name, m_FieldMap[name].GetValue(es).ToString());
+                    }
                 }
-            }
 
-            cmd.ExecuteNonQuery();
+                cmd.ExecuteNonQuery();
 
-            cmd.CommandText = "select LAST_INSERT_ROWID() as id";
-            cmd.Parameters.Clear();
+                cmd.CommandText = "select LAST_INSERT_ROWID() as id";
+                cmd.Parameters.Clear();
 
-            r = cmd.ExecuteReader();
+                r = cmd.ExecuteReader();
+            }
 
             r.Read();
 
@@ -239,26 +242,27 @@ namespace OpenSim.Data.SQLite
 
             string sql = "update estate_settings set "+String.Join(", ", terms.ToArray())+" where EstateID = :EstateID";
 
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
-
-            cmd.CommandText = sql;
-
-            foreach (string name in FieldList)
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
             {
-                if (m_FieldMap[name].GetValue(es) is bool)
+                cmd.CommandText = sql;
+
+                foreach (string name in FieldList)
                 {
-                    if ((bool)m_FieldMap[name].GetValue(es))
-                        cmd.Parameters.AddWithValue(":"+name, "1");
+                    if (m_FieldMap[name].GetValue(es) is bool)
+                    {
+                        if ((bool)m_FieldMap[name].GetValue(es))
+                            cmd.Parameters.AddWithValue(":"+name, "1");
+                        else
+                            cmd.Parameters.AddWithValue(":"+name, "0");
+                    }
                     else
-                        cmd.Parameters.AddWithValue(":"+name, "0");
-                }
-                else
-                {
-                    cmd.Parameters.AddWithValue(":"+name, m_FieldMap[name].GetValue(es).ToString());
+                    {
+                        cmd.Parameters.AddWithValue(":"+name, m_FieldMap[name].GetValue(es).ToString());
+                    }
                 }
-            }
 
-            cmd.ExecuteNonQuery();
+                cmd.ExecuteNonQuery();
+            }
 
             SaveBanList(es);
             SaveUUIDList(es.EstateID, "estate_managers", es.EstateManagers);
@@ -270,12 +274,15 @@ namespace OpenSim.Data.SQLite
         {
             es.ClearBans();
 
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
+            IDataReader r;
 
-            cmd.CommandText = "select bannedUUID from estateban where EstateID = :EstateID";
-            cmd.Parameters.AddWithValue(":EstateID", es.EstateID);
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
+            {
+                cmd.CommandText = "select bannedUUID from estateban where EstateID = :EstateID";
+                cmd.Parameters.AddWithValue(":EstateID", es.EstateID);
 
-            IDataReader r = cmd.ExecuteReader();
+                r = cmd.ExecuteReader();
+            }
 
             while (r.Read())
             {
@@ -294,60 +301,64 @@ namespace OpenSim.Data.SQLite
 
         private void SaveBanList(EstateSettings es)
         {
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
-
-            cmd.CommandText = "delete from estateban where EstateID = :EstateID";
-            cmd.Parameters.AddWithValue(":EstateID", es.EstateID.ToString());
-
-            cmd.ExecuteNonQuery();
-
-            cmd.Parameters.Clear();
-
-            cmd.CommandText = "insert into estateban (EstateID, bannedUUID, bannedIp, bannedIpHostMask, bannedNameMask) values ( :EstateID, :bannedUUID, '', '', '' )";
-
-            foreach (EstateBan b in es.EstateBans)
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
             {
+                cmd.CommandText = "delete from estateban where EstateID = :EstateID";
                 cmd.Parameters.AddWithValue(":EstateID", es.EstateID.ToString());
-                cmd.Parameters.AddWithValue(":bannedUUID", b.BannedUserID.ToString());
 
                 cmd.ExecuteNonQuery();
+
                 cmd.Parameters.Clear();
+
+                cmd.CommandText = "insert into estateban (EstateID, bannedUUID, bannedIp, bannedIpHostMask, bannedNameMask) values ( :EstateID, :bannedUUID, '', '', '' )";
+
+                foreach (EstateBan b in es.EstateBans)
+                {
+                    cmd.Parameters.AddWithValue(":EstateID", es.EstateID.ToString());
+                    cmd.Parameters.AddWithValue(":bannedUUID", b.BannedUserID.ToString());
+
+                    cmd.ExecuteNonQuery();
+                    cmd.Parameters.Clear();
+                }
             }
         }
 
         void SaveUUIDList(uint EstateID, string table, UUID[] data)
         {
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
-
-            cmd.CommandText = "delete from "+table+" where EstateID = :EstateID";
-            cmd.Parameters.AddWithValue(":EstateID", EstateID.ToString());
-
-            cmd.ExecuteNonQuery();
-
-            cmd.Parameters.Clear();
-
-            cmd.CommandText = "insert into "+table+" (EstateID, uuid) values ( :EstateID, :uuid )";
-
-            foreach (UUID uuid in data)
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
             {
+                cmd.CommandText = "delete from "+table+" where EstateID = :EstateID";
                 cmd.Parameters.AddWithValue(":EstateID", EstateID.ToString());
-                cmd.Parameters.AddWithValue(":uuid", uuid.ToString());
 
                 cmd.ExecuteNonQuery();
+
                 cmd.Parameters.Clear();
+
+                cmd.CommandText = "insert into "+table+" (EstateID, uuid) values ( :EstateID, :uuid )";
+
+                foreach (UUID uuid in data)
+                {
+                    cmd.Parameters.AddWithValue(":EstateID", EstateID.ToString());
+                    cmd.Parameters.AddWithValue(":uuid", uuid.ToString());
+
+                    cmd.ExecuteNonQuery();
+                    cmd.Parameters.Clear();
+                }
             }
         }
 
         UUID[] LoadUUIDList(uint EstateID, string table)
         {
             List<UUID> uuids = new List<UUID>();
+            IDataReader r;
 
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
-
-            cmd.CommandText = "select uuid from "+table+" where EstateID = :EstateID";
-            cmd.Parameters.AddWithValue(":EstateID", EstateID);
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
+            {
+                cmd.CommandText = "select uuid from "+table+" where EstateID = :EstateID";
+                cmd.Parameters.AddWithValue(":EstateID", EstateID);
 
-            IDataReader r = cmd.ExecuteReader();
+                r = cmd.ExecuteReader();
+            }
 
             while (r.Read())
             {
@@ -367,12 +378,13 @@ namespace OpenSim.Data.SQLite
         {
             string sql = "select estate_settings."+String.Join(",estate_settings.", FieldList)+" from estate_settings where estate_settings.EstateID = :EstateID";
 
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
-
-            cmd.CommandText = sql;
-            cmd.Parameters.AddWithValue(":EstateID", estateID.ToString());
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
+            {
+                cmd.CommandText = sql;
+                cmd.Parameters.AddWithValue(":EstateID", estateID.ToString());
 
-            return DoLoad(cmd, UUID.Zero, false);
+                return DoLoad(cmd, UUID.Zero, false);
+            }
         }
         
         public List<EstateSettings> LoadEstateSettingsAll()
@@ -391,13 +403,15 @@ namespace OpenSim.Data.SQLite
             List<int> result = new List<int>();
 
             string sql = "select EstateID from estate_settings where estate_settings.EstateName = :EstateName";
+            IDataReader r;
 
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
-
-            cmd.CommandText = sql;
-            cmd.Parameters.AddWithValue(":EstateName", search);
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
+            {
+                cmd.CommandText = sql;
+                cmd.Parameters.AddWithValue(":EstateName", search);
 
-            IDataReader r = cmd.ExecuteReader();
+                r = cmd.ExecuteReader();
+            }
 
             while (r.Read())
             {
@@ -413,12 +427,14 @@ namespace OpenSim.Data.SQLite
             List<int> result = new List<int>();
 
             string sql = "select EstateID from estate_settings";
+            IDataReader r;
 
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
-
-            cmd.CommandText = sql;
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
+            {
+                cmd.CommandText = sql;
 
-            IDataReader r = cmd.ExecuteReader();
+                r = cmd.ExecuteReader();
+            }
 
             while (r.Read())
             {
@@ -434,13 +450,15 @@ namespace OpenSim.Data.SQLite
             List<int> result = new List<int>();
 
             string sql = "select EstateID from estate_settings where estate_settings.EstateOwner = :EstateOwner";
+            IDataReader r;
 
-            SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand();
-
-            cmd.CommandText = sql;
-            cmd.Parameters.AddWithValue(":EstateOwner", ownerID);
+            using (SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand())
+            {
+                cmd.CommandText = sql;
+                cmd.Parameters.AddWithValue(":EstateOwner", ownerID);
 
-            IDataReader r = cmd.ExecuteReader();
+                r = cmd.ExecuteReader();
+            }
 
             while (r.Read())
             {
diff --git a/OpenSim/Data/SQLite/SQLiteFramework.cs b/OpenSim/Data/SQLite/SQLiteFramework.cs
index 1594717..35b9a2f 100644
--- a/OpenSim/Data/SQLite/SQLiteFramework.cs
+++ b/OpenSim/Data/SQLite/SQLiteFramework.cs
@@ -90,12 +90,5 @@ namespace OpenSim.Data.SQLite
                 return cmd.ExecuteReader();
             }
         }
-
-        protected void CloseCommand(SqliteCommand cmd)
-        {
-            cmd.Connection.Close();
-            cmd.Connection.Dispose();
-            cmd.Dispose();
-        }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Data/SQLite/SQLiteFriendsData.cs b/OpenSim/Data/SQLite/SQLiteFriendsData.cs
index 5f68977..cab85eb 100644
--- a/OpenSim/Data/SQLite/SQLiteFriendsData.cs
+++ b/OpenSim/Data/SQLite/SQLiteFriendsData.cs
@@ -53,13 +53,13 @@ namespace OpenSim.Data.SQLite
 
         public FriendsData[] GetFriends(string userID)
         {
-            SqliteCommand cmd = new SqliteCommand();
-
-            cmd.CommandText = String.Format("select a.*,case when b.Flags is null then -1 else b.Flags end as TheirFlags from {0} as a left join {0} as b on a.PrincipalID = b.Friend and a.Friend = b.PrincipalID where a.PrincipalID = :PrincipalID", m_Realm);
-            cmd.Parameters.AddWithValue(":PrincipalID", userID.ToString());
-
-            return DoQuery(cmd);
+            using (SqliteCommand cmd = new SqliteCommand())
+            {
+                cmd.CommandText = String.Format("select a.*,case when b.Flags is null then -1 else b.Flags end as TheirFlags from {0} as a left join {0} as b on a.PrincipalID = b.Friend and a.Friend = b.PrincipalID where a.PrincipalID = :PrincipalID", m_Realm);
+                cmd.Parameters.AddWithValue(":PrincipalID", userID.ToString());
 
+                return DoQuery(cmd);
+            }
         }
 
         public bool Delete(UUID principalID, string friend)
@@ -69,13 +69,14 @@ namespace OpenSim.Data.SQLite
 
         public bool Delete(string principalID, string friend)
         {
-            SqliteCommand cmd = new SqliteCommand();
-
-            cmd.CommandText = String.Format("delete from {0} where PrincipalID = :PrincipalID and Friend = :Friend", m_Realm);
-            cmd.Parameters.AddWithValue(":PrincipalID", principalID.ToString());
-            cmd.Parameters.AddWithValue(":Friend", friend);
+            using (SqliteCommand cmd = new SqliteCommand())
+            {
+                cmd.CommandText = String.Format("delete from {0} where PrincipalID = :PrincipalID and Friend = :Friend", m_Realm);
+                cmd.Parameters.AddWithValue(":PrincipalID", principalID.ToString());
+                cmd.Parameters.AddWithValue(":Friend", friend);
 
-            ExecuteNonQuery(cmd, m_Connection);
+                ExecuteNonQuery(cmd, m_Connection);
+            }
 
             return true;
         }
diff --git a/OpenSim/Data/SQLite/SQLiteGenericTableHandler.cs b/OpenSim/Data/SQLite/SQLiteGenericTableHandler.cs
index 4f977a8..9fbeb10 100644
--- a/OpenSim/Data/SQLite/SQLiteGenericTableHandler.cs
+++ b/OpenSim/Data/SQLite/SQLiteGenericTableHandler.cs
@@ -120,34 +120,35 @@ namespace OpenSim.Data.SQLite
             }
         }
 
-        public T[] Get(string field, string key)
+        public virtual T[] Get(string field, string key)
         {
             return Get(new string[] { field }, new string[] { key });
         }
 
-        public T[] Get(string[] fields, string[] keys)
+        public virtual T[] Get(string[] fields, string[] keys)
         {
             if (fields.Length != keys.Length)
                 return new T[0];
 
             List<string> terms = new List<string>();
 
-            SqliteCommand cmd = new SqliteCommand();
-
-            for (int i = 0 ; i < fields.Length ; i++)
+            using (SqliteCommand cmd = new SqliteCommand())
             {
-                cmd.Parameters.Add(new SqliteParameter(":" + fields[i], keys[i]));
-                terms.Add("`" + fields[i] + "` = :" + fields[i]);
-            }
+                for (int i = 0 ; i < fields.Length ; i++)
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":" + fields[i], keys[i]));
+                    terms.Add("`" + fields[i] + "` = :" + fields[i]);
+                }
 
-            string where = String.Join(" and ", terms.ToArray());
+                string where = String.Join(" and ", terms.ToArray());
 
-            string query = String.Format("select * from {0} where {1}",
-                    m_Realm, where);
+                string query = String.Format("select * from {0} where {1}",
+                        m_Realm, where);
 
-            cmd.CommandText = query;
+                cmd.CommandText = query;
 
-            return DoQuery(cmd);
+                return DoQuery(cmd);
+            }
         }
 
         protected T[] DoQuery(SqliteCommand cmd)
@@ -212,52 +213,54 @@ namespace OpenSim.Data.SQLite
             return result.ToArray();
         }
 
-        public T[] Get(string where)
+        public virtual T[] Get(string where)
         {
-            SqliteCommand cmd = new SqliteCommand();
-
-            string query = String.Format("select * from {0} where {1}",
-                    m_Realm, where);
+            using (SqliteCommand cmd = new SqliteCommand())
+            {
+                string query = String.Format("select * from {0} where {1}",
+                        m_Realm, where);
 
-            cmd.CommandText = query;
+                cmd.CommandText = query;
 
-            return DoQuery(cmd);
+                return DoQuery(cmd);
+            }
         }
 
-        public bool Store(T row)
+        public virtual bool Store(T row)
         {
-            SqliteCommand cmd = new SqliteCommand();
-
-            string query = "";
-            List<String> names = new List<String>();
-            List<String> values = new List<String>();
-
-            foreach (FieldInfo fi in m_Fields.Values)
+            using (SqliteCommand cmd = new SqliteCommand())
             {
-                names.Add(fi.Name);
-                values.Add(":" + fi.Name);
-                cmd.Parameters.Add(new SqliteParameter(":" + fi.Name, fi.GetValue(row).ToString()));
-            }
+                string query = "";
+                List<String> names = new List<String>();
+                List<String> values = new List<String>();
 
-            if (m_DataField != null)
-            {
-                Dictionary<string, string> data =
-                        (Dictionary<string, string>)m_DataField.GetValue(row);
+                foreach (FieldInfo fi in m_Fields.Values)
+                {
+                    names.Add(fi.Name);
+                    values.Add(":" + fi.Name);
+                    cmd.Parameters.Add(new SqliteParameter(":" + fi.Name, fi.GetValue(row).ToString()));
+                }
 
-                foreach (KeyValuePair<string, string> kvp in data)
+                if (m_DataField != null)
                 {
-                    names.Add(kvp.Key);
-                    values.Add(":" + kvp.Key);
-                    cmd.Parameters.Add(new SqliteParameter(":" + kvp.Key, kvp.Value));
+                    Dictionary<string, string> data =
+                            (Dictionary<string, string>)m_DataField.GetValue(row);
+
+                    foreach (KeyValuePair<string, string> kvp in data)
+                    {
+                        names.Add(kvp.Key);
+                        values.Add(":" + kvp.Key);
+                        cmd.Parameters.Add(new SqliteParameter(":" + kvp.Key, kvp.Value));
+                    }
                 }
-            }
 
-            query = String.Format("replace into {0} (`", m_Realm) + String.Join("`,`", names.ToArray()) + "`) values (" + String.Join(",", values.ToArray()) + ")";
+                query = String.Format("replace into {0} (`", m_Realm) + String.Join("`,`", names.ToArray()) + "`) values (" + String.Join(",", values.ToArray()) + ")";
 
-            cmd.CommandText = query;
+                cmd.CommandText = query;
 
-            if (ExecuteNonQuery(cmd, m_Connection) > 0)
-                return true;
+                if (ExecuteNonQuery(cmd, m_Connection) > 0)
+                    return true;
+            }
 
             return false;
         }
@@ -267,28 +270,29 @@ namespace OpenSim.Data.SQLite
             return Delete(new string[] { field }, new string[] { key });
         }        
 
-        public bool Delete(string[] fields, string[] keys)
+        public virtual bool Delete(string[] fields, string[] keys)
         {
             if (fields.Length != keys.Length)
                 return false;
 
             List<string> terms = new List<string>();
 
-            SqliteCommand cmd = new SqliteCommand();
-
-            for (int i = 0 ; i < fields.Length ; i++)
+            using (SqliteCommand cmd = new SqliteCommand())
             {
-                cmd.Parameters.Add(new SqliteParameter(":" + fields[i], keys[i]));
-                terms.Add("`" + fields[i] + "` = :" + fields[i]);
-            }
+                for (int i = 0 ; i < fields.Length ; i++)
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":" + fields[i], keys[i]));
+                    terms.Add("`" + fields[i] + "` = :" + fields[i]);
+                }
 
-            string where = String.Join(" and ", terms.ToArray());
+                string where = String.Join(" and ", terms.ToArray());
 
-            string query = String.Format("delete from {0} where {1}", m_Realm, where);
+                string query = String.Format("delete from {0} where {1}", m_Realm, where);
 
-            cmd.CommandText = query;
+                cmd.CommandText = query;
 
-            return ExecuteNonQuery(cmd, m_Connection) > 0;
+                return ExecuteNonQuery(cmd, m_Connection) > 0;
+            }
         }
     }
 }
diff --git a/OpenSim/Data/SQLite/SQLiteSimulationData.cs b/OpenSim/Data/SQLite/SQLiteSimulationData.cs
index 56df3cb..29cac3c 100644
--- a/OpenSim/Data/SQLite/SQLiteSimulationData.cs
+++ b/OpenSim/Data/SQLite/SQLiteSimulationData.cs
@@ -1366,6 +1366,13 @@ namespace OpenSim.Data.SQLite
             createCol(land, "UserLookAtZ", typeof(Double));
             createCol(land, "AuthbuyerID", typeof(String));
             createCol(land, "OtherCleanTime", typeof(Int32));
+            createCol(land, "Dwell", typeof(Int32));
+            createCol(land, "MediaType", typeof(String));
+            createCol(land, "MediaDescription", typeof(String));
+            createCol(land, "MediaSize", typeof(String));
+            createCol(land, "MediaLoop", typeof(Boolean));
+            createCol(land, "ObscureMedia", typeof(Boolean));
+            createCol(land, "ObscureMusic", typeof(Boolean));
 
             land.PrimaryKey = new DataColumn[] { land.Columns["UUID"] };
 
@@ -1781,9 +1788,16 @@ namespace OpenSim.Data.SQLite
             newData.PassHours = Convert.ToSingle(row["PassHours"]);
             newData.PassPrice = Convert.ToInt32(row["PassPrice"]);
             newData.SnapshotID = (UUID)(String)row["SnapshotUUID"];
+            newData.Dwell = Convert.ToInt32(row["Dwell"]);
+            newData.MediaType = (String)row["MediaType"];
+            newData.MediaDescription = (String)row["MediaDescription"];
+            newData.MediaWidth = Convert.ToInt32((((string)row["MediaSize"]).Split(','))[0]);
+            newData.MediaHeight = Convert.ToInt32((((string)row["MediaSize"]).Split(','))[1]);
+            newData.MediaLoop = Convert.ToBoolean(row["MediaLoop"]);
+            newData.ObscureMedia = Convert.ToBoolean(row["ObscureMedia"]);
+            newData.ObscureMusic = Convert.ToBoolean(row["ObscureMusic"]);
             try
             {
-
                 newData.UserLocation =
                     new Vector3(Convert.ToSingle(row["UserLocationX"]), Convert.ToSingle(row["UserLocationY"]),
                                   Convert.ToSingle(row["UserLocationZ"]));
@@ -2195,12 +2209,13 @@ namespace OpenSim.Data.SQLite
             row["UserLookAtZ"] = land.UserLookAt.Z;
             row["AuthbuyerID"] = land.AuthBuyerID.ToString();
             row["OtherCleanTime"] = land.OtherCleanTime;
+            row["Dwell"] = land.Dwell;
             row["MediaType"] = land.MediaType;
             row["MediaDescription"] = land.MediaDescription;
-            row["MediaSize"] = land.MediaWidth.ToString() + "," + land.MediaHeight.ToString();
-            row["MediaLoop"] = land.MediaLoop.ToString();
-            row["ObscureMusic"] = land.ObscureMusic.ToString();
-            row["ObscureMedia"] = land.ObscureMedia.ToString();
+            row["MediaSize"] = String.Format("{0},{1}", land.MediaWidth, land.MediaHeight);
+            row["MediaLoop"] = land.MediaLoop;
+            row["ObscureMusic"] = land.ObscureMusic;
+            row["ObscureMedia"] = land.ObscureMedia;
         }
 
         /// <summary>
diff --git a/OpenSim/Data/SQLite/SQLiteUserAccountData.cs b/OpenSim/Data/SQLite/SQLiteUserAccountData.cs
index 7a5de50..f98d376 100644
--- a/OpenSim/Data/SQLite/SQLiteUserAccountData.cs
+++ b/OpenSim/Data/SQLite/SQLiteUserAccountData.cs
@@ -66,20 +66,21 @@ namespace OpenSim.Data.SQLite
             if (words.Length > 2)
                 return new UserAccountData[0];
 
-            SqliteCommand cmd = new SqliteCommand();
-
-            if (words.Length == 1)
-            {
-                cmd.CommandText = String.Format("select * from {0} where (ScopeID='{1}' or ScopeID='00000000-0000-0000-0000-000000000000') and (FirstName like '{2}%' or LastName like '{2}%')",
-                    m_Realm, scopeID.ToString(), words[0]);
-            }
-            else
+            using (SqliteCommand cmd = new SqliteCommand())
             {
-                cmd.CommandText = String.Format("select * from {0} where (ScopeID='{1}' or ScopeID='00000000-0000-0000-0000-000000000000') and (FirstName like '{2}%' or LastName like '{3}%')", 
-                    m_Realm, scopeID.ToString(), words[0], words[1]);
-            }
+                if (words.Length == 1)
+                {
+                    cmd.CommandText = String.Format("select * from {0} where (ScopeID='{1}' or ScopeID='00000000-0000-0000-0000-000000000000') and (FirstName like '{2}%' or LastName like '{2}%')",
+                        m_Realm, scopeID.ToString(), words[0]);
+                }
+                else
+                {
+                    cmd.CommandText = String.Format("select * from {0} where (ScopeID='{1}' or ScopeID='00000000-0000-0000-0000-000000000000') and (FirstName like '{2}%' or LastName like '{3}%')", 
+                        m_Realm, scopeID.ToString(), words[0], words[1]);
+                }
 
-            return DoQuery(cmd);
+                return DoQuery(cmd);
+            }
         }
     }
 }
diff --git a/OpenSim/Data/SQLite/SQLiteXInventoryData.cs b/OpenSim/Data/SQLite/SQLiteXInventoryData.cs
index 1f36986..2a0a8f6 100644
--- a/OpenSim/Data/SQLite/SQLiteXInventoryData.cs
+++ b/OpenSim/Data/SQLite/SQLiteXInventoryData.cs
@@ -47,7 +47,7 @@ namespace OpenSim.Data.SQLite
     {
 //        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
-        private SQLiteGenericTableHandler<XInventoryFolder> m_Folders;
+        private SqliteFolderHandler m_Folders;
         private SqliteItemHandler m_Items;
 
         public SQLiteXInventoryData(string conn, string realm)
@@ -55,7 +55,7 @@ namespace OpenSim.Data.SQLite
             if (Util.IsWindows())
                 Util.LoadArchSpecificWindowsDll("sqlite3.dll");
 
-            m_Folders = new SQLiteGenericTableHandler<XInventoryFolder>(
+            m_Folders = new SqliteFolderHandler(
                     conn, "inventoryfolders", "XInventoryStore");
             m_Items = new SqliteItemHandler(
                     conn, "inventoryitems", String.Empty);
@@ -114,6 +114,11 @@ namespace OpenSim.Data.SQLite
             return m_Items.MoveItem(id, newParent);
         }
 
+        public bool MoveFolder(string id, string newParent)
+        {
+            return m_Folders.MoveFolder(id, newParent);
+        }
+
         public XInventoryItem[] GetActiveGestures(UUID principalID)
         {
             return m_Items.GetActiveGestures(principalID);
@@ -125,44 +130,106 @@ namespace OpenSim.Data.SQLite
         }
     }
 
-    public class SqliteItemHandler : SQLiteGenericTableHandler<XInventoryItem>
+    public class SqliteItemHandler : SqliteInventoryHandler<XInventoryItem>
     {
         public SqliteItemHandler(string c, string t, string m) :
                 base(c, t, m)
         {
         }
 
+        public override bool Store(XInventoryItem item)
+        {
+            if (!base.Store(item))
+                return false;
+
+            IncrementFolderVersion(item.parentFolderID);
+
+            return true;
+        }
+
+        public override bool Delete(string field, string val)
+        {
+            XInventoryItem[] retrievedItems = Get(new string[] { field }, new string[] { val });
+            if (retrievedItems.Length == 0)
+                return false;
+
+            if (!base.Delete(field, val))
+                return false;
+
+            // Don't increment folder version here since Delete(string, string) calls Delete(string[], string[])
+//            IncrementFolderVersion(retrievedItems[0].parentFolderID);
+
+            return true;
+        }
+
+        public override bool Delete(string[] fields, string[] vals)
+        {
+            XInventoryItem[] retrievedItems = Get(fields, vals);
+            if (retrievedItems.Length == 0)
+                return false;
+
+            if (!base.Delete(fields, vals))
+                return false;
+
+            HashSet<UUID> deletedItemFolderUUIDs = new HashSet<UUID>();
+
+            Array.ForEach<XInventoryItem>(retrievedItems, i => deletedItemFolderUUIDs.Add(i.parentFolderID));
+
+            foreach (UUID deletedItemFolderUUID in deletedItemFolderUUIDs)
+                IncrementFolderVersion(deletedItemFolderUUID);
+
+            return true;
+        }
+
         public bool MoveItem(string id, string newParent)
         {
-            SqliteCommand cmd = new SqliteCommand();
+            XInventoryItem[] retrievedItems = Get(new string[] { "inventoryID" }, new string[] { id });
+            if (retrievedItems.Length == 0)
+                return false;
+
+            UUID oldParent = retrievedItems[0].parentFolderID;
+
+            using (SqliteCommand cmd = new SqliteCommand())
+            {
+                cmd.CommandText = String.Format("update {0} set parentFolderID = :ParentFolderID where inventoryID = :InventoryID", m_Realm);
+                cmd.Parameters.Add(new SqliteParameter(":ParentFolderID", newParent));
+                cmd.Parameters.Add(new SqliteParameter(":InventoryID", id));
 
-            cmd.CommandText = String.Format("update {0} set parentFolderID = :ParentFolderID where inventoryID = :InventoryID", m_Realm);
-            cmd.Parameters.Add(new SqliteParameter(":ParentFolderID", newParent));
-            cmd.Parameters.Add(new SqliteParameter(":InventoryID", id));
+                if (ExecuteNonQuery(cmd, m_Connection) == 0)
+                    return false;
+            }
+
+            IncrementFolderVersion(oldParent);
+            IncrementFolderVersion(newParent);
 
-            return ExecuteNonQuery(cmd, m_Connection) == 0 ? false : true;
+            return true;
         }
 
         public XInventoryItem[] GetActiveGestures(UUID principalID)
         {
-            SqliteCommand cmd  = new SqliteCommand();
-            cmd.CommandText = String.Format("select * from inventoryitems where avatarId = :uuid and assetType = :type and flags = 1", m_Realm);
+            using (SqliteCommand cmd  = new SqliteCommand())
+            {
+                cmd.CommandText = String.Format("select * from inventoryitems where avatarId = :uuid and assetType = :type and flags = 1", m_Realm);
 
-            cmd.Parameters.Add(new SqliteParameter(":uuid", principalID.ToString()));
-            cmd.Parameters.Add(new SqliteParameter(":type", (int)AssetType.Gesture));
+                cmd.Parameters.Add(new SqliteParameter(":uuid", principalID.ToString()));
+                cmd.Parameters.Add(new SqliteParameter(":type", (int)AssetType.Gesture));
 
-            return DoQuery(cmd);
+                return DoQuery(cmd);
+            }
         }
 
         public int GetAssetPermissions(UUID principalID, UUID assetID)
         {
-            SqliteCommand cmd = new SqliteCommand();
+            IDataReader reader;
 
-            cmd.CommandText = String.Format("select inventoryCurrentPermissions from inventoryitems where avatarID = :PrincipalID and assetID = :AssetID", m_Realm);
-            cmd.Parameters.Add(new SqliteParameter(":PrincipalID", principalID.ToString()));
-            cmd.Parameters.Add(new SqliteParameter(":AssetID", assetID.ToString()));
+            using (SqliteCommand cmd = new SqliteCommand())
+            {
+                cmd.CommandText = String.Format("select inventoryCurrentPermissions from inventoryitems where avatarID = :PrincipalID and assetID = :AssetID", m_Realm);
+                cmd.Parameters.Add(new SqliteParameter(":PrincipalID", principalID.ToString()));
+                cmd.Parameters.Add(new SqliteParameter(":AssetID", assetID.ToString()));
 
-            IDataReader reader = ExecuteReader(cmd, m_Connection);
+                reader = ExecuteReader(cmd, m_Connection);
+            }
 
             int perms = 0;
 
@@ -177,4 +244,81 @@ namespace OpenSim.Data.SQLite
             return perms;
         }
     }
-}
+
+    public class SqliteFolderHandler : SqliteInventoryHandler<XInventoryFolder>
+    {
+        public SqliteFolderHandler(string c, string t, string m) :
+                base(c, t, m)
+        {
+        }
+
+        public override bool Store(XInventoryFolder folder)
+        {
+            if (!base.Store(folder))
+                return false;
+
+            IncrementFolderVersion(folder.parentFolderID);
+
+            return true;
+        }
+
+        public bool MoveFolder(string id, string newParentFolderID)
+        {
+            XInventoryFolder[] folders = Get(new string[] { "folderID" }, new string[] { id });
+
+            if (folders.Length == 0)
+                return false;
+
+            UUID oldParentFolderUUID = folders[0].parentFolderID;
+
+            using (SqliteCommand cmd = new SqliteCommand())
+            {
+                cmd.CommandText = String.Format("update {0} set parentFolderID = :ParentFolderID where folderID = :FolderID", m_Realm);
+                cmd.Parameters.Add(new SqliteParameter(":ParentFolderID", newParentFolderID));
+                cmd.Parameters.Add(new SqliteParameter(":FolderID", id));
+
+                if (ExecuteNonQuery(cmd, m_Connection) == 0)
+                    return false;
+            }
+
+            IncrementFolderVersion(oldParentFolderUUID);
+            IncrementFolderVersion(newParentFolderID);
+
+            return true;
+        }
+
+    }
+
+    public class SqliteInventoryHandler<T> : SQLiteGenericTableHandler<T> where T: class, new()
+    {
+        public SqliteInventoryHandler(string c, string t, string m) : base(c, t, m) {}
+
+        protected bool IncrementFolderVersion(UUID folderID)
+        {
+            return IncrementFolderVersion(folderID.ToString());
+        }
+
+        protected bool IncrementFolderVersion(string folderID)
+        {
+//            m_log.DebugFormat("[MYSQL ITEM HANDLER]: Incrementing version on folder {0}", folderID);
+//            Util.PrintCallStack();
+            
+            using (SqliteCommand cmd = new SqliteCommand())
+            {
+                cmd.CommandText = "update inventoryfolders set version=version+1 where folderID = ?folderID";
+                cmd.Parameters.Add(new SqliteParameter(":folderID", folderID));
+
+                try
+                {
+                    cmd.ExecuteNonQuery();
+                }
+                catch (Exception)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}
\ No newline at end of file