whole lot more moving

67 files changed, 15985 insertions, 0 deletions

diff --git a/OpenSim/Data/Base/BaseDataReader.cs b/OpenSim/Data/Base/BaseDataReader.cs
new file mode 100644
index 0000000..3baefcd
--- /dev/null
+++ b/OpenSim/Data/Base/BaseDataReader.cs
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Data;
+using System.IO;
+
+namespace OpenSim.Framework.Data.Base
+{
+    public abstract class BaseDataReader
+    {
+        private readonly IDataReader m_source;
+
+        public BaseDataReader(IDataReader source)
+        {
+            m_source = source;
+        }
+
+        public object Get(string name)
+        {
+            return m_source[name];
+        }
+
+        public ushort GetUShort(string name)
+        {
+            return (ushort)m_source.GetInt32(m_source.GetOrdinal(name));
+        }
+
+        public byte GetByte(string name)
+        {
+            int ordinal = m_source.GetOrdinal(name);
+            byte value = (byte)m_source.GetInt16(ordinal);
+            return value;
+        }
+
+        public sbyte GetSByte(string name)
+        {
+            return (sbyte)m_source.GetInt16(m_source.GetOrdinal(name));
+        }
+
+        public float GetFloat(string name)
+        {
+            return m_source.GetFloat(m_source.GetOrdinal(name));
+        }
+
+        public byte[] GetBytes(string name)
+        {
+            int ordinal = m_source.GetOrdinal(name);
+
+            if (m_source.GetValue(ordinal) == DBNull.Value)
+            {
+                return null;
+            }
+
+            byte[] buffer = new byte[16384];
+
+            MemoryStream memStream = new MemoryStream();
+
+            long totalRead = 0;
+
+            int bytesRead;
+            do
+            {
+                bytesRead = (int)m_source.GetBytes(ordinal, totalRead, buffer, 0, buffer.Length);
+                totalRead += bytesRead;
+
+                memStream.Write(buffer, 0, bytesRead);
+            } while (bytesRead == buffer.Length);
+
+            return memStream.ToArray();
+        }
+
+        public string GetString(string name)
+        {
+            int ordinal = m_source.GetOrdinal(name);
+            object value = m_source.GetValue(ordinal);
+
+            if (value is DBNull)
+            {
+                return null;
+            }
+
+            return (string)value;
+        }
+
+        public bool Read()
+        {
+            return m_source.Read();
+        }
+
+        public virtual Guid GetGuid(string name)
+        {
+            return m_source.GetGuid(m_source.GetOrdinal(name));
+        }
+
+        public UInt32 GetUInt32(string name )
+        {
+            return (UInt32)GetInt32(name);
+        }
+
+        private Int32 GetInt32(string name)
+        {
+            int ordinal = m_source.GetOrdinal(name);
+            int int32 = m_source.GetInt32(ordinal);
+            return int32;            
+        }
+
+        public Int64 GetInt64(string  name)
+        {
+            int ordinal = m_source.GetOrdinal( name );
+            long int64 = m_source.GetInt64(ordinal);
+            return int64;
+        }
+    }
+}
diff --git a/OpenSim/Data/Base/BaseDatabaseConnector.cs b/OpenSim/Data/Base/BaseDatabaseConnector.cs
new file mode 100644
index 0000000..fa3a6c3
--- /dev/null
+++ b/OpenSim/Data/Base/BaseDatabaseConnector.cs
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+
+namespace OpenSim.Framework.Data.Base
+{
+    public abstract class BaseDatabaseConnector
+    {
+        protected string m_connectionString;
+
+        public BaseDatabaseConnector(string connectionString)
+        {
+            m_connectionString = connectionString;
+        }
+
+        public abstract DbConnection GetNewConnection();
+        public abstract string CreateParamName(string fieldName);
+
+        public DbCommand CreateSelectCommand(BaseTableMapper mapper, DbConnection connection, string fieldName, object key)
+        {
+            string table = mapper.TableName;
+
+            DbCommand command = connection.CreateCommand();
+
+            string conditionString = CreateCondition(mapper, command, fieldName, key);
+
+            string query =
+                String.Format("select * from {0} where {1}", table, conditionString);
+
+            command.CommandText = query;
+            command.CommandType = CommandType.Text;
+
+            return command;
+        }
+
+        public string CreateCondition(BaseTableMapper mapper, DbCommand command, string fieldName, object key)
+        {
+            string keyFieldParamName = mapper.CreateParamName(fieldName);
+
+            DbParameter param = command.CreateParameter();
+            param.ParameterName = keyFieldParamName;
+            param.Value = ConvertToDbType(key);
+            command.Parameters.Add(param);
+
+            return String.Format("{0}={1}", fieldName, keyFieldParamName);
+        }
+
+        public DbCommand CreateUpdateCommand(BaseTableMapper mapper, DbConnection connection, object rowMapper, object primaryKey)
+        {
+            string table = mapper.TableName;
+
+            List<string> fieldNames = new List<string>();
+
+            DbCommand command = connection.CreateCommand();
+
+            foreach (BaseFieldMapper fieldMapper in mapper.Schema.Fields.Values)
+            {
+                if (fieldMapper != mapper.KeyFieldMapper)
+                {
+                    fieldMapper.ExpandField(rowMapper, command, fieldNames);
+                }
+            }
+
+            List<string> assignments = new List<string>();
+
+            foreach (string field in fieldNames)
+            {
+                assignments.Add(String.Format("{0}={1}", field, mapper.CreateParamName(field)));
+            }
+
+            string conditionString = mapper.CreateCondition(command, mapper.KeyFieldMapper.FieldName, primaryKey);
+
+            command.CommandText =
+                String.Format("update {0} set {1} where {2}", table, String.Join(", ", assignments.ToArray()),
+                              conditionString);
+
+            return command;
+        }
+
+        public DbCommand CreateInsertCommand(BaseTableMapper mapper, DbConnection connection, object obj)
+        {
+            string table = mapper.TableName;
+
+            List<string> fieldNames = new List<string>();
+
+            DbCommand command = connection.CreateCommand();
+
+            foreach (BaseFieldMapper fieldMapper in mapper.Schema.Fields.Values)
+            {
+                fieldMapper.ExpandField(obj, command, fieldNames);
+            }
+
+            List<string> paramNames = new List<string>();
+
+            foreach (string field in fieldNames)
+            {
+                paramNames.Add(mapper.CreateParamName(field));
+            }
+
+            command.CommandText =
+                String.Format("insert into {0} ({1}) values ({2})", table, String.Join(", ", fieldNames.ToArray()),
+                              String.Join(", ", paramNames.ToArray()));
+
+            return command;
+        }
+
+        public virtual object ConvertToDbType(object value)
+        {
+            return value;
+        }
+
+        public abstract BaseDataReader CreateReader(IDataReader reader);
+    }
+}
diff --git a/OpenSim/Data/Base/BaseFieldMapper.cs b/OpenSim/Data/Base/BaseFieldMapper.cs
new file mode 100644
index 0000000..03c7bfb
--- /dev/null
+++ b/OpenSim/Data/Base/BaseFieldMapper.cs
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+
+namespace OpenSim.Framework.Data.Base
+{  
+    public delegate TField ObjectGetAccessor<TObj, TField>(TObj obj);
+    public delegate void ObjectSetAccessor<TObj, TField>(TObj obj, TField value);
+
+    public abstract class BaseFieldMapper
+    {
+        private readonly BaseTableMapper m_tableMapper;
+        private readonly string m_fieldName;
+
+        public string FieldName
+        {
+            get { return m_fieldName; }
+        }
+
+        protected Type m_valueType;
+
+        public Type ValueType
+        {
+            get { return m_valueType; }
+        }
+
+        public abstract object GetParamValue(object obj);
+
+        public BaseFieldMapper(BaseTableMapper tableMapper, string fieldName, Type valueType)
+        {
+            m_fieldName = fieldName;
+            m_valueType = valueType;
+            m_tableMapper = tableMapper;
+        }
+
+        public abstract void SetPropertyFromReader(object mapper, BaseDataReader reader);
+
+        public void RawAddParam(DbCommand command, List<string> fieldNames, string fieldName, object value)
+        {
+            string paramName = m_tableMapper.CreateParamName(fieldName);
+            fieldNames.Add(fieldName);
+
+            DbParameter param = command.CreateParameter();
+            param.ParameterName = paramName;
+            param.Value = value;
+
+            command.Parameters.Add(param);
+        }
+
+        public virtual void ExpandField<TObj>(TObj obj, DbCommand command, List<string> fieldNames)
+        {
+            string fieldName = FieldName;
+            object value = GetParamValue(obj);
+
+            RawAddParam(command, fieldNames, fieldName, m_tableMapper.ConvertToDbType(value));
+        }
+
+        protected virtual object GetValue(BaseDataReader reader)
+        {
+            object value;
+
+            if (ValueType == typeof(Guid))
+            {
+                value = reader.GetGuid(m_fieldName);
+            }
+            else if (ValueType == typeof(bool))
+            {
+                uint boolVal = reader.GetUShort(m_fieldName);
+                value = (boolVal == 1);
+            }
+            else
+                if (ValueType == typeof(byte))
+                {
+                    value = reader.GetByte(m_fieldName);
+                }
+                else if (ValueType == typeof(sbyte))
+                {
+                    value = reader.GetSByte(m_fieldName);
+                }
+                else if (ValueType == typeof(ushort))
+                {
+                    value = reader.GetUShort(m_fieldName);
+                }
+                else if (ValueType == typeof(uint))
+                {
+                    value = reader.GetUInt32(m_fieldName);
+                }
+                else if (ValueType == typeof(byte[]))
+                {
+                    value = reader.GetBytes(m_fieldName);
+                }
+                else
+                {
+                    value = reader.Get(m_fieldName);
+                }
+
+            if (value is DBNull)
+            {
+                value = default(ValueType);
+            }
+
+            return value;
+        }
+    }
+
+    public class ObjectField<TObject, TField> : BaseFieldMapper
+    {
+        private readonly ObjectGetAccessor<TObject, TField> m_fieldGetAccessor;
+        private readonly ObjectSetAccessor<TObject, TField> m_fieldSetAccessor;
+
+        public override object GetParamValue(object obj)
+        {
+            return m_fieldGetAccessor((TObject)obj);
+        }
+
+        public override void SetPropertyFromReader(object obj, BaseDataReader reader)
+        {
+            object value;
+
+            value = GetValue(reader);
+
+            if (value == null)
+            {
+                m_fieldSetAccessor((TObject)obj, default(TField));
+            }
+            else
+            {
+                m_fieldSetAccessor((TObject)obj, (TField)value);
+            }
+        }
+
+
+        public ObjectField(BaseTableMapper tableMapper, string fieldName, ObjectGetAccessor<TObject, TField> rowMapperGetAccessor,
+                           ObjectSetAccessor<TObject, TField> rowMapperSetAccessor)
+            : base(tableMapper, fieldName, typeof(TField))
+        {
+            m_fieldGetAccessor = rowMapperGetAccessor;
+            m_fieldSetAccessor = rowMapperSetAccessor;
+        }
+    }
+}
diff --git a/OpenSim/Data/Base/BaseRowMapper.cs b/OpenSim/Data/Base/BaseRowMapper.cs
new file mode 100644
index 0000000..b008b86
--- /dev/null
+++ b/OpenSim/Data/Base/BaseRowMapper.cs
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using OpenSim.Framework.Data.Base;
+
+namespace OpenSim.Framework.Data.Base
+{
+    public abstract class BaseRowMapper
+    {
+        public abstract void FillObject(BaseDataReader reader);
+    }
+
+    public class BaseRowMapper<TObj> : BaseRowMapper
+    {
+        private readonly BaseSchema m_schema;
+        private readonly TObj m_obj;
+
+        public TObj Object
+        {
+            get { return m_obj; }
+        }
+
+        public BaseRowMapper(BaseSchema schema, TObj obj)
+        {
+            m_schema = schema;
+            m_obj = obj;
+        }
+
+        public override void FillObject(BaseDataReader reader)
+        {
+            foreach (BaseFieldMapper fieldMapper in m_schema.Fields.Values)
+            {
+                fieldMapper.SetPropertyFromReader(this, reader);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Data/Base/BaseSchema.cs b/OpenSim/Data/Base/BaseSchema.cs
new file mode 100644
index 0000000..8a7ee71
--- /dev/null
+++ b/OpenSim/Data/Base/BaseSchema.cs
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Collections.Generic;
+using OpenSim.Framework.Data.Base;
+
+namespace OpenSim.Framework.Data.Base
+{
+    public class BaseSchema
+    {
+        protected BaseTableMapper m_tableMapper;
+        protected Dictionary<string, BaseFieldMapper> m_mappings;
+
+        public Dictionary<string, BaseFieldMapper> Fields
+        {
+            get { return m_mappings; }
+        }
+
+        public BaseSchema(BaseTableMapper tableMapper)
+        {
+            m_mappings = new Dictionary<string, BaseFieldMapper>();
+            m_tableMapper = tableMapper;
+        }
+    }
+
+    public class BaseSchema<TObj> : BaseSchema
+    {
+        public BaseSchema(BaseTableMapper tableMapper)
+            : base(tableMapper)
+        {
+        }
+
+        public ObjectField<TObj, TField> AddMapping<TField>(string fieldName,
+                                                            ObjectGetAccessor<TObj, TField> rowMapperGetAccessor,
+                                                            ObjectSetAccessor<TObj, TField> rowMapperSetAccessor)
+        {
+            ObjectField<TObj, TField> rowMapperField =
+                new ObjectField<TObj, TField>(m_tableMapper, fieldName, rowMapperGetAccessor, rowMapperSetAccessor);
+
+            m_mappings.Add(fieldName, rowMapperField);
+
+            return rowMapperField;
+        }
+    }
+}
diff --git a/OpenSim/Data/Base/BaseTableMapper.cs b/OpenSim/Data/Base/BaseTableMapper.cs
new file mode 100644
index 0000000..cad4823
--- /dev/null
+++ b/OpenSim/Data/Base/BaseTableMapper.cs
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Data;
+using System.Data.Common;
+using OpenSim.Framework.Data.Base;
+
+namespace OpenSim.Framework.Data.Base
+{
+    public abstract class BaseTableMapper
+    {
+        private readonly BaseDatabaseConnector m_database;
+        private readonly object m_syncRoot = new object();
+
+        protected void WithConnection(Action<DbConnection> action)
+        {
+            lock (m_syncRoot)
+            {
+                DbConnection m_connection = m_database.GetNewConnection();
+
+                if (m_connection.State != ConnectionState.Open)
+                {
+                    m_connection.Open();
+                }
+
+                action(m_connection);
+
+                if (m_connection.State == ConnectionState.Open)
+                {
+                    m_connection.Close();
+                }
+            }
+        }
+
+        private readonly string m_tableName;
+        public string TableName
+        {
+            get { return m_tableName; }
+        }
+
+        protected BaseSchema m_schema;
+        public BaseSchema Schema
+        {
+            get { return m_schema; }
+        }
+
+        protected BaseFieldMapper m_keyFieldMapper;
+        public BaseFieldMapper KeyFieldMapper
+        {
+            get { return m_keyFieldMapper; }
+        }
+
+        public BaseTableMapper(BaseDatabaseConnector database, string tableName)
+        {
+            m_database = database;
+            m_tableName = tableName.ToLower(); // Stupid MySQL hack.
+        }
+
+        public string CreateParamName(string fieldName)
+        {
+            return m_database.CreateParamName(fieldName);
+        }
+
+        protected DbCommand CreateSelectCommand(DbConnection connection, string fieldName, object primaryKey)
+        {
+            return m_database.CreateSelectCommand(this, connection, fieldName, primaryKey);
+        }
+
+        public string CreateCondition(DbCommand command, string fieldName, object key)
+        {
+            return m_database.CreateCondition(this, command, fieldName, key);
+        }
+
+        public DbCommand CreateInsertCommand(DbConnection connection, object obj)
+        {
+            return m_database.CreateInsertCommand(this, connection, obj);
+        }
+
+        public DbCommand CreateUpdateCommand(DbConnection connection, object rowMapper, object primaryKey)
+        {
+            return m_database.CreateUpdateCommand(this, connection, rowMapper, primaryKey);
+        }
+
+        public object ConvertToDbType(object value)
+        {
+            return m_database.ConvertToDbType(value);
+        }
+
+        protected virtual BaseDataReader CreateReader(IDataReader reader)
+        {
+            return m_database.CreateReader(reader);
+        }
+    }
+
+    public abstract class BaseTableMapper<TRowMapper, TPrimaryKey> : BaseTableMapper
+    {
+        public BaseTableMapper(BaseDatabaseConnector database, string tableName)
+            : base(database, tableName)
+        {
+        }
+
+        // HACK: This is a temporary function used by TryGetValue().
+        // Due to a bug in mono 1.2.6, delegate blocks cannot contain
+        // a using() block.  This has been fixed in SVN, so the next
+        // mono release should work.
+        private void TryGetConnectionValue(DbConnection connection, TPrimaryKey primaryKey, ref TRowMapper result, ref bool success)
+        {
+            using (
+                DbCommand command =
+                CreateSelectCommand(connection, KeyFieldMapper.FieldName, primaryKey))
+            {
+                using (IDataReader reader = command.ExecuteReader())
+                {
+                    if (reader.Read())
+                    {
+                        result = FromReader( CreateReader(reader));
+                        success = true;
+                    }
+                    else
+                    {
+                        success = false;
+                    }
+                }
+            }
+        }
+
+        public bool TryGetValue(TPrimaryKey primaryKey, out TRowMapper value)
+        {
+            TRowMapper result = default(TRowMapper);
+            bool success = false;
+
+            WithConnection(delegate(DbConnection connection)
+                           {
+                               TryGetConnectionValue(connection, primaryKey, ref result, ref success);
+                           });
+
+            value = result;
+
+            return success;
+        }
+
+        // HACK: This is a temporary function used by Remove().
+        // Due to a bug in mono 1.2.6, delegate blocks cannot contain
+        // a using() block.  This has been fixed in SVN, so the next
+        // mono release should work.
+        protected virtual void TryDelete(DbConnection connection, TPrimaryKey id, ref int deleted)
+        {
+            using (
+                DbCommand command =
+                CreateDeleteCommand(connection, KeyFieldMapper.FieldName, id))
+            {
+                deleted = command.ExecuteNonQuery();
+            }
+        }
+
+        public virtual bool Remove(TPrimaryKey id)
+        {
+            int deleted = 0;
+
+            WithConnection(delegate(DbConnection connection)
+                           {
+                               TryDelete(connection, id, ref deleted);
+                           });
+
+            if (deleted == 1)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public DbCommand CreateDeleteCommand(DbConnection connection, string fieldName, TPrimaryKey primaryKey)
+        {
+            string table = TableName;
+
+            DbCommand command = connection.CreateCommand();
+
+            string conditionString = CreateCondition(command, fieldName, primaryKey);
+
+            string query =
+                String.Format("delete from {0} where {1}", table, conditionString);
+
+            command.CommandText = query;
+            command.CommandType = CommandType.Text;
+
+            return command;
+        }
+
+        // HACK: This is a temporary function used by Update().
+        // Due to a bug in mono 1.2.6, delegate blocks cannot contain
+        // a using() block.  This has been fixed in SVN, so the next
+        // mono release should work.
+        protected void TryUpdate(DbConnection connection, TPrimaryKey primaryKey, TRowMapper value, ref int updated)
+        {
+            using (DbCommand command = CreateUpdateCommand(connection, value, primaryKey))
+            {
+                updated = command.ExecuteNonQuery();
+            }
+        }
+
+        public virtual bool Update(TPrimaryKey primaryKey, TRowMapper value)
+        {
+            int updated = 0;
+
+            WithConnection(delegate(DbConnection connection)
+                           {
+                               TryUpdate(connection, primaryKey, value, ref updated);
+                           });
+
+            if (updated == 1)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        // HACK: This is a temporary function used by Add().
+        // Due to a bug in mono 1.2.6, delegate blocks cannot contain
+        // a using() block.  This has been fixed in SVN, so the next
+        // mono release should work.
+        protected void TryAdd(DbConnection connection, TRowMapper value, ref int added)
+        {
+            using (DbCommand command = CreateInsertCommand(connection, value))
+            {
+                added = command.ExecuteNonQuery();
+            }
+        }
+
+        public virtual bool Add(TRowMapper value)
+        {
+            int added = 0;
+
+            WithConnection(delegate(DbConnection connection)
+                           {
+                               TryAdd(connection, value, ref added);
+                           });
+
+            if (added == 1)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public abstract TRowMapper FromReader(BaseDataReader reader);
+    }
+}
diff --git a/OpenSim/Data/Base/OpenSim.Framework.Data.Base.snk b/OpenSim/Data/Base/OpenSim.Framework.Data.Base.snk
new file mode 100644
index 0000000..fc71027
--- /dev/null
+++ b/OpenSim/Data/Base/OpenSim.Framework.Data.Base.snk
diff --git a/OpenSim/Data/Base/Properties/AssemblyInfo.cs b/OpenSim/Data/Base/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..ab97490
--- /dev/null
+++ b/OpenSim/Data/Base/Properties/AssemblyInfo.cs
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Security;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly : AssemblyTitle("OpenSim.Framework.Data.Base")]
+[assembly : AssemblyDescription("Generic Database Abstraction Layer")]
+[assembly : AssemblyConfiguration("")]
+[assembly : AssemblyCompany("OpenSim Project (www.opensimulator.org)")]
+[assembly: AssemblyProduct("OpenSim.Framework.Data.Base")]
+[assembly: AssemblyCopyright("Copyright (c) 2007 OpenSim Project (www.opensimulator.org)")]
+[assembly : AssemblyTrademark("")]
+[assembly : AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+
+[assembly : ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+
+[assembly : Guid("9269f421-19d9-4eea-bfe3-c0ffe426fada")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly : AssemblyVersion("1.0.0.0")]
+[assembly : AssemblyFileVersion("1.0.0.0")]
+[assembly : AllowPartiallyTrustedCallers]
diff --git a/OpenSim/Data/DB4o/DB4oGridData.cs b/OpenSim/Data/DB4o/DB4oGridData.cs
new file mode 100644
index 0000000..31b13e3
--- /dev/null
+++ b/OpenSim/Data/DB4o/DB4oGridData.cs
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using libsecondlife;
+
+namespace OpenSim.Framework.Data.DB4o
+{
+    /// <summary>
+    /// A grid server storage mechanism employing the DB4o database system
+    /// </summary>
+    internal class DB4oGridData : GridDataBase
+    {
+        /// <summary>
+        /// The database manager object
+        /// </summary>
+        private DB4oGridManager manager;
+
+        /// <summary>
+        /// Called when the plugin is first loaded (as constructors are not called)
+        /// </summary>
+        override public void Initialise()
+        {
+            manager = new DB4oGridManager("gridserver.yap");
+        }
+
+        /// <summary>
+        /// Returns a list of regions within the specified ranges
+        /// </summary>
+        /// <param name="a">minimum X coordinate</param>
+        /// <param name="b">minimum Y coordinate</param>
+        /// <param name="c">maximum X coordinate</param>
+        /// <param name="d">maximum Y coordinate</param>
+        /// <returns>An array of region profiles</returns>
+        override public RegionProfileData[] GetProfilesInRange(uint a, uint b, uint c, uint d)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a region located at the specified regionHandle (warning multiple regions may occupy the one spot, first found is returned)
+        /// </summary>
+        /// <param name="handle">The handle to search for</param>
+        /// <returns>A region profile</returns>
+        override public RegionProfileData GetProfileByHandle(ulong handle)
+        {
+            lock (manager.simProfiles)
+            {
+                foreach (LLUUID UUID in manager.simProfiles.Keys)
+                {
+                    if (manager.simProfiles[UUID].regionHandle == handle)
+                    {
+                        return manager.simProfiles[UUID];
+                    }
+                }
+            }
+            throw new Exception("Unable to find profile with handle (" + handle.ToString() + ")");
+        }
+
+        /// <summary>
+        /// Returns a specific region
+        /// </summary>
+        /// <param name="uuid">The region ID code</param>
+        /// <returns>A region profile</returns>
+        override public RegionProfileData GetProfileByLLUUID(LLUUID uuid)
+        {
+            lock (manager.simProfiles)
+            {
+                if (manager.simProfiles.ContainsKey(uuid))
+                    return manager.simProfiles[uuid];
+            }
+            throw new Exception("Unable to find profile with UUID (" + uuid.ToString() +
+                                "). Total Registered Regions: " + manager.simProfiles.Count);
+        }
+
+        override public RegionProfileData GetProfileByString(string regionName)
+        {
+            throw new Exception("GetProfileByString Not supported in DB4oGridData");
+            //return null;
+        }
+
+        /// <summary>
+        /// Adds a new specified region to the database
+        /// </summary>
+        /// <param name="profile">The profile to add</param>
+        /// <returns>A dataresponse enum indicating success</returns>
+        override public DataResponse AddProfile(RegionProfileData profile)
+        {
+            lock (manager.simProfiles)
+            {
+                if (manager.AddRow(profile))
+                {
+                    return DataResponse.RESPONSE_OK;
+                }
+                else
+                {
+                    return DataResponse.RESPONSE_ERROR;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Authenticates a new region using the shared secrets. NOT SECURE.
+        /// </summary>
+        /// <param name="uuid">The UUID the region is authenticating with</param>
+        /// <param name="handle">The location the region is logging into (unused in Db4o)</param>
+        /// <param name="key">The shared secret</param>
+        /// <returns>Authenticated?</returns>
+        override public bool AuthenticateSim(LLUUID uuid, ulong handle, string key)
+        {
+            if (manager.simProfiles[uuid].regionRecvKey == key)
+                return true;
+            return false;
+        }
+
+        /// <summary>
+        /// Shuts down the database
+        /// </summary>
+        override public void Close()
+        {
+            manager = null;
+        }
+
+        /// <summary>
+        /// // Returns a list of avatar and UUIDs that match the query
+        /// </summary>
+        public List<AvatarPickerAvatar> GeneratePickerResults(LLUUID queryID, string query)
+        {
+            //Do nothing yet
+            List<AvatarPickerAvatar> returnlist = new List<AvatarPickerAvatar>();
+            return returnlist;
+        }
+
+        /// <summary>
+        /// Returns the providers name
+        /// </summary>
+        /// <returns>The name of the storage system</returns>
+        override public string getName()
+        {
+            return "DB4o Grid Provider";
+        }
+
+        /// <summary>
+        /// Returns the providers version
+        /// </summary>
+        /// <returns>The version of the storage system</returns>
+        override public string getVersion()
+        {
+            return "0.1";
+        }
+
+        override public ReservationData GetReservationAtPoint(uint x, uint y)
+        {
+            return null;
+        }
+    }
+}
diff --git a/OpenSim/Data/DB4o/DB4oManager.cs b/OpenSim/Data/DB4o/DB4oManager.cs
new file mode 100644
index 0000000..9cacb5e
--- /dev/null
+++ b/OpenSim/Data/DB4o/DB4oManager.cs
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using Db4objects.Db4o;
+using libsecondlife;
+
+namespace OpenSim.Framework.Data.DB4o
+{
+    /// <summary>
+    /// A Database manager for Db4o
+    /// </summary>
+    internal class DB4oGridManager
+    {
+        /// <summary>
+        /// A list of the current regions connected (in-memory cache)
+        /// </summary>
+        public Dictionary<LLUUID, RegionProfileData> simProfiles = new Dictionary<LLUUID, RegionProfileData>();
+
+        /// <summary>
+        /// Database File Name
+        /// </summary>
+        private string dbfl;
+
+        /// <summary>
+        /// Creates a new grid storage manager
+        /// </summary>
+        /// <param name="db4odb">Filename to the database file</param>
+        public DB4oGridManager(string db4odb)
+        {
+            dbfl = db4odb;
+            IObjectContainer database;
+            database = Db4oFactory.OpenFile(dbfl);
+            IObjectSet result = database.Get(typeof (RegionProfileData));
+            // Loads the file into the in-memory cache
+            foreach (RegionProfileData row in result)
+            {
+                simProfiles.Add(row.UUID, row);
+            }
+            database.Close();
+        }
+
+        /// <summary>
+        /// Adds a new profile to the database (Warning: Probably slow.)
+        /// </summary>
+        /// <param name="row">The profile to add</param>
+        /// <returns>Successful?</returns>
+        public bool AddRow(RegionProfileData row)
+        {
+            if (simProfiles.ContainsKey(row.UUID))
+            {
+                simProfiles[row.UUID] = row;
+            }
+            else
+            {
+                simProfiles.Add(row.UUID, row);
+            }
+
+            try
+            {
+                IObjectContainer database;
+                database = Db4oFactory.OpenFile(dbfl);
+                database.Set(row);
+                database.Close();
+                return true;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+    }
+
+    /// <summary>
+    /// A manager for the DB4o database (user profiles)
+    /// </summary>
+    internal class DB4oUserManager
+    {
+        /// <summary>
+        /// A list of the user profiles (in memory cache)
+        /// </summary>
+        public Dictionary<LLUUID, UserProfileData> userProfiles = new Dictionary<LLUUID, UserProfileData>();
+
+        /// <summary>
+        /// Database filename
+        /// </summary>
+        private string dbfl;
+
+        /// <summary>
+        /// Initialises a new DB manager
+        /// </summary>
+        /// <param name="db4odb">The filename to the database</param>
+        public DB4oUserManager(string db4odb)
+        {
+            dbfl = db4odb;
+            IObjectContainer database;
+            database = Db4oFactory.OpenFile(dbfl);
+            // Load to cache
+            IObjectSet result = database.Get(typeof (UserProfileData));
+            foreach (UserProfileData row in result)
+            {
+                if (userProfiles.ContainsKey(row.UUID))
+                    userProfiles[row.UUID] = row;
+                else
+                    userProfiles.Add(row.UUID, row);
+            }
+            database.Close();
+        }
+
+        /// <summary>
+        /// Adds or updates a record to the user database.  Do this when changes are needed
+        /// in the user profile that need to be persistant.
+        /// 
+        /// TODO: the logic here is not ACID, the local cache will be
+        /// updated even if the persistant data is not.  This may lead
+        /// to unexpected results.
+        /// </summary>
+        /// <param name="record">The profile to update</param>
+        /// <returns>true on success, false on fail to persist to db</returns>
+        public bool UpdateRecord(UserProfileData record)
+        {
+            if (userProfiles.ContainsKey(record.UUID))
+            {
+                userProfiles[record.UUID] = record;
+            }
+            else
+            {
+                userProfiles.Add(record.UUID, record);
+            }
+
+            try
+            {
+                IObjectContainer database;
+                database = Db4oFactory.OpenFile(dbfl);
+                database.Set(record);
+                database.Close();
+                return true;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+    }
+}
diff --git a/OpenSim/Data/DB4o/DB4oUserData.cs b/OpenSim/Data/DB4o/DB4oUserData.cs
new file mode 100644
index 0000000..3072e81
--- /dev/null
+++ b/OpenSim/Data/DB4o/DB4oUserData.cs
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using libsecondlife;
+
+namespace OpenSim.Framework.Data.DB4o
+{
+    /// <summary>
+    /// A User storage interface for the DB4o database system
+    /// </summary>
+    public class DB4oUserData : IUserData
+    {
+        //private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// The database manager
+        /// </summary>
+        private DB4oUserManager manager;
+
+        /// <summary>
+        /// Artificial constructor called upon plugin load
+        /// </summary>
+        public void Initialise()
+        {
+            manager = new DB4oUserManager(Path.Combine(Util.dataDir(), "userprofiles.yap"));
+        }
+
+        /// <summary>
+        /// Loads a specified user profile from a UUID
+        /// </summary>
+        /// <param name="uuid">The users UUID</param>
+        /// <returns>A user profile</returns>
+        public UserProfileData GetUserByUUID(LLUUID uuid)
+        {
+            if (manager.userProfiles.ContainsKey(uuid))
+                return manager.userProfiles[uuid];
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a user by searching for its name
+        /// </summary>
+        /// <param name="name">The users account name</param>
+        /// <returns>A matching users profile</returns>
+        public UserProfileData GetUserByName(string name)
+        {
+            return GetUserByName(name.Split(' ')[0], name.Split(' ')[1]);
+        }
+
+        /// <summary>
+        /// Returns a user by searching for its name
+        /// </summary>
+        /// <param name="fname">The first part of the users account name</param>
+        /// <param name="lname">The second part of the users account name</param>
+        /// <returns>A matching users profile</returns>
+        public UserProfileData GetUserByName(string fname, string lname)
+        {
+            foreach (UserProfileData profile in manager.userProfiles.Values)
+            {
+                if (profile.username == fname && profile.surname == lname)
+                    return profile;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a user by UUID direct
+        /// </summary>
+        /// <param name="uuid">The users account ID</param>
+        /// <returns>A matching users profile</returns>
+        public UserAgentData GetAgentByUUID(LLUUID uuid)
+        {
+            try
+            {
+                return GetUserByUUID(uuid).currentAgent;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a session by account name
+        /// </summary>
+        /// <param name="name">The account name</param>
+        /// <returns>The users session agent</returns>
+        public UserAgentData GetAgentByName(string name)
+        {
+            return GetAgentByName(name.Split(' ')[0], name.Split(' ')[1]);
+        }
+
+        /// <summary>
+        /// Returns a session by account name
+        /// </summary>
+        /// <param name="fname">The first part of the users account name</param>
+        /// <param name="lname">The second part of the users account name</param>
+        /// <returns>A user agent</returns>
+        public UserAgentData GetAgentByName(string fname, string lname)
+        {
+            try
+            {
+                return GetUserByName(fname, lname).currentAgent;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+        public void StoreWebLoginKey(LLUUID AgentID, LLUUID WebLoginKey)
+        {
+            UserProfileData user = GetUserByUUID(AgentID);
+            user.webLoginKey = WebLoginKey;
+            UpdateUserProfile(user);
+
+        }
+        #region User Friends List Data
+
+        public void AddNewUserFriend(LLUUID friendlistowner, LLUUID friend, uint perms)
+        {
+            //m_log.Info("[FRIEND]: Stub AddNewUserFriend called");
+        }
+
+        public void RemoveUserFriend(LLUUID friendlistowner, LLUUID friend)
+        {
+            //m_log.Info("[FRIEND]: Stub RemoveUserFriend called");
+        }
+        public void UpdateUserFriendPerms(LLUUID friendlistowner, LLUUID friend, uint perms)
+        {
+            //m_log.Info("[FRIEND]: Stub UpdateUserFriendPerms called");
+        }
+
+
+        public List<FriendListItem> GetUserFriendList(LLUUID friendlistowner)
+        {
+            //m_log.Info("[FRIEND]: Stub GetUserFriendList called");
+            return new List<FriendListItem>();
+        }
+
+        #endregion
+
+        public void UpdateUserCurrentRegion(LLUUID avatarid, LLUUID regionuuid)
+        {
+            //m_log.Info("[USER]: Stub UpdateUserCUrrentRegion called");
+        }
+
+        
+
+        public List<Framework.AvatarPickerAvatar> GeneratePickerResults(LLUUID queryID, string query)
+        {
+            //Do nothing yet
+            List<Framework.AvatarPickerAvatar> returnlist = new List<Framework.AvatarPickerAvatar>();
+            return returnlist;
+        }
+
+        /// <summary>
+        /// Creates a new user profile
+        /// </summary>
+        /// <param name="user">The profile to add to the database</param>
+        public void AddNewUserProfile(UserProfileData user)
+        {
+            try
+            {
+                manager.UpdateRecord(user);
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Creates a new user profile
+        /// </summary>
+        /// <param name="user">The profile to add to the database</param>
+        /// <returns>True on success, false on error</returns>
+        public bool UpdateUserProfile(UserProfileData user)
+        {
+            try
+            {
+                return manager.UpdateRecord(user);
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.ToString());
+                return false;
+            }
+        }
+
+
+        /// <summary>
+        /// Creates a new user agent
+        /// </summary>
+        /// <param name="agent">The agent to add to the database</param>
+        public void AddNewUserAgent(UserAgentData agent)
+        {
+            // Do nothing. yet.
+        }
+
+        /// <summary>
+        /// Transfers money between two user accounts
+        /// </summary>
+        /// <param name="from">Starting account</param>
+        /// <param name="to">End account</param>
+        /// <param name="amount">The amount to move</param>
+        /// <returns>Success?</returns>
+        public bool MoneyTransferRequest(LLUUID from, LLUUID to, uint amount)
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Transfers inventory between two accounts
+        /// </summary>
+        /// <remarks>Move to inventory server</remarks>
+        /// <param name="from">Senders account</param>
+        /// <param name="to">Receivers account</param>
+        /// <param name="item">Inventory item</param>
+        /// <returns>Success?</returns>
+        public bool InventoryTransferRequest(LLUUID from, LLUUID to, LLUUID item)
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Returns the name of the storage provider
+        /// </summary>
+        /// <returns>Storage provider name</returns>
+        public string getName()
+        {
+            return "DB4o Userdata";
+        }
+
+        /// <summary>
+        /// Returns the version of the storage provider
+        /// </summary>
+        /// <returns>Storage provider version</returns>
+        public string GetVersion()
+        {
+            return "0.1";
+        }
+    }
+}
diff --git a/OpenSim/Data/DB4o/Properties/AssemblyInfo.cs b/OpenSim/Data/DB4o/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..ee84938
--- /dev/null
+++ b/OpenSim/Data/DB4o/Properties/AssemblyInfo.cs
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly : AssemblyTitle("OpenSim.Framework.Data.DB4o")]
+[assembly : AssemblyDescription("")]
+[assembly : AssemblyConfiguration("")]
+[assembly : AssemblyCompany("")]
+[assembly : AssemblyProduct("OpenSim.Framework.Data.DB4o")]
+[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2008")]
+[assembly : AssemblyTrademark("")]
+[assembly : AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+
+[assembly : ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+
+[assembly : Guid("57991e15-79da-41b7-aa06-2e6b49165a63")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly : AssemblyVersion("1.0.0.0")]
+[assembly : AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Data/MSSQL/MSSQLAssetData.cs b/OpenSim/Data/MSSQL/MSSQLAssetData.cs
new file mode 100644
index 0000000..059bb5e
--- /dev/null
+++ b/OpenSim/Data/MSSQL/MSSQLAssetData.cs
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using libsecondlife;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.MSSQL
+{
+    internal class MSSQLAssetData : AssetDataBase
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        private MSSQLManager database;
+
+        #region IAssetProvider Members
+
+        private void UpgradeAssetsTable(string tableName)
+        {
+            // null as the version, indicates that the table didn't exist
+            if (tableName == null)
+            {
+                m_log.Info("[ASSETS]: Creating new database tables");
+                database.ExecuteResourceSql("CreateAssetsTable.sql");
+                return;
+            }
+        }
+
+        /// <summary>
+        /// Ensure that the assets related tables exists and are at the latest version
+        /// </summary>
+        private void TestTables()
+        {
+            Dictionary<string, string> tableList = new Dictionary<string, string>();
+
+            tableList["assets"] = null;
+            database.GetTableVersion(tableList);
+
+            UpgradeAssetsTable(tableList["assets"]);
+        }
+
+        override public AssetBase FetchAsset(LLUUID assetID)
+        {
+            AssetBase asset = null;
+
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["id"] = assetID.ToString();
+
+            IDbCommand result = database.Query("SELECT * FROM assets WHERE id = @id", param);
+            IDataReader reader = result.ExecuteReader();
+
+            asset = database.getAssetRow(reader);
+            reader.Close();
+            result.Dispose();
+
+            return asset;
+        }
+
+        override public void CreateAsset(AssetBase asset)
+        {
+            if (ExistsAsset((LLUUID) asset.FullID))
+            {
+                return;
+            }
+
+
+            SqlCommand cmd =
+                new SqlCommand(
+                    "INSERT INTO assets ([id], [name], [description], [assetType], [invType], [local], [temporary], [data])" +
+                    " VALUES " +
+                    "(@id, @name, @description, @assetType, @invType, @local, @temporary, @data)",
+                    database.getConnection());
+
+            using (cmd)
+            {
+                //SqlParameter p = cmd.Parameters.Add("id", SqlDbType.NVarChar);
+                //p.Value = asset.FullID.ToString();
+                cmd.Parameters.AddWithValue("id", asset.FullID.ToString());
+                cmd.Parameters.AddWithValue("name", asset.Name);
+                cmd.Parameters.AddWithValue("description", asset.Description);
+                SqlParameter e = cmd.Parameters.Add("assetType", SqlDbType.TinyInt);
+                e.Value = asset.Type;
+                SqlParameter f = cmd.Parameters.Add("invType", SqlDbType.TinyInt);
+                f.Value = asset.InvType;
+                SqlParameter g = cmd.Parameters.Add("local", SqlDbType.TinyInt);
+                g.Value = asset.Local;
+                SqlParameter h = cmd.Parameters.Add("temporary", SqlDbType.TinyInt);
+                h.Value = asset.Temporary;
+                SqlParameter i = cmd.Parameters.Add("data", SqlDbType.Image);
+                i.Value = asset.Data;
+                try
+                {
+                    cmd.ExecuteNonQuery();
+                }
+                catch (Exception)
+                {
+                    throw;
+                }
+
+                cmd.Dispose();
+            }
+        }
+
+
+        override public void UpdateAsset(AssetBase asset)
+        {
+            SqlCommand command = new SqlCommand("UPDATE assets set id = @id, " +
+                                                "name = @name, " +
+                                                "description = @description," +
+                                                "assetType = @assetType," +
+                                                "invType = @invType," +
+                                                "local = @local," +
+                                                "temporary = @temporary," +
+                                                "data = @data where " +
+                                                "id = @keyId;", database.getConnection());
+            SqlParameter param1 = new SqlParameter("@id", asset.FullID.ToString());
+            SqlParameter param2 = new SqlParameter("@name", asset.Name);
+            SqlParameter param3 = new SqlParameter("@description", asset.Description);
+            SqlParameter param4 = new SqlParameter("@assetType", asset.Type);
+            SqlParameter param5 = new SqlParameter("@invType", asset.InvType);
+            SqlParameter param6 = new SqlParameter("@local", asset.Local);
+            SqlParameter param7 = new SqlParameter("@temporary", asset.Temporary);
+            SqlParameter param8 = new SqlParameter("@data", asset.Data);
+            SqlParameter param9 = new SqlParameter("@keyId", asset.FullID.ToString());
+            command.Parameters.Add(param1);
+            command.Parameters.Add(param2);
+            command.Parameters.Add(param3);
+            command.Parameters.Add(param4);
+            command.Parameters.Add(param5);
+            command.Parameters.Add(param6);
+            command.Parameters.Add(param7);
+            command.Parameters.Add(param8);
+            command.Parameters.Add(param9);
+
+            try
+            {
+                command.ExecuteNonQuery();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+            }
+        }
+
+        override public bool ExistsAsset(LLUUID uuid)
+        {
+            if (FetchAsset(uuid) != null)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// All writes are immediately commited to the database, so this is a no-op
+        /// </summary>
+        override public void CommitAssets()
+        {
+        }
+
+        #endregion
+
+        #region IPlugin Members
+
+        override public void Initialise()
+        {
+            IniFile GridDataMySqlFile = new IniFile("mssql_connection.ini");
+            string settingDataSource = GridDataMySqlFile.ParseFileReadValue("data_source");
+            string settingInitialCatalog = GridDataMySqlFile.ParseFileReadValue("initial_catalog");
+            string settingPersistSecurityInfo = GridDataMySqlFile.ParseFileReadValue("persist_security_info");
+            string settingUserId = GridDataMySqlFile.ParseFileReadValue("user_id");
+            string settingPassword = GridDataMySqlFile.ParseFileReadValue("password");
+
+            database =
+                new MSSQLManager(settingDataSource, settingInitialCatalog, settingPersistSecurityInfo, settingUserId,
+                                 settingPassword);
+
+            TestTables();
+        }
+
+        override public string Version
+        {
+//            get { return database.getVersion(); } 
+            get { return database.getVersion(); }
+        }
+
+        override public string Name
+        {
+            get { return "MSSQL Asset storage engine"; }
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Data/MSSQL/MSSQLDataStore.cs b/OpenSim/Data/MSSQL/MSSQLDataStore.cs
new file mode 100644
index 0000000..d34abe3
--- /dev/null
+++ b/OpenSim/Data/MSSQL/MSSQLDataStore.cs
@@ -0,0 +1,1622 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using System.IO;
+using libsecondlife;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Framework.Data;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Scenes;
+using OpenSim.Framework.Data.MSSQL;
+
+namespace OpenSim.Framework.Data.MSSQL
+{
+    public class MSSQLDataStore : IRegionDataStore
+    {
+        // private static FileSystemDataStore Instance = new FileSystemDataStore();
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        private const string m_primSelect = "select * from prims";
+        private const string m_shapeSelect = "select * from primshapes";
+        private const string m_itemsSelect = "select * from primitems";
+        private const string m_terrainSelect = "select top 1 * from terrain";
+        private const string m_landSelect = "select * from land";
+        private const string m_landAccessListSelect = "select * from landaccesslist";
+
+        private DataSet m_dataSet;
+        private SqlDataAdapter m_primDataAdapter;
+        private SqlDataAdapter m_shapeDataAdapter;
+        private SqlDataAdapter m_itemsDataAdapter;
+        private SqlConnection m_connection;
+        private SqlDataAdapter m_terrainDataAdapter;
+        private SqlDataAdapter m_landDataAdapter;
+        private SqlDataAdapter m_landAccessListDataAdapter;
+
+        private DataTable m_primTable;
+        private DataTable m_shapeTable;
+        private DataTable m_itemsTable;
+        private DataTable m_terrainTable;
+        private DataTable m_landTable;
+        private DataTable m_landAccessListTable;
+
+        // Temporary attribute while this is experimental
+        private bool persistPrimInventories;
+
+        /***********************************************************************
+         *
+         *  Public Interface Functions
+         *
+         **********************************************************************/
+
+        // see IRegionDataStore
+        public void Initialise(string connectionString, bool persistPrimInventories)
+        {
+            // Instance.Initialise("", true);
+
+            m_dataSet = new DataSet();
+            this.persistPrimInventories = persistPrimInventories;
+
+            m_log.Info("[DATASTORE]: MSSql - connecting: " + connectionString);
+            m_connection = new SqlConnection(connectionString);
+
+            SqlCommand primSelectCmd = new SqlCommand(m_primSelect, m_connection);
+            m_primDataAdapter = new SqlDataAdapter(primSelectCmd);
+
+            SqlCommand shapeSelectCmd = new SqlCommand(m_shapeSelect, m_connection);
+            m_shapeDataAdapter = new SqlDataAdapter(shapeSelectCmd);
+
+            SqlCommand itemsSelectCmd = new SqlCommand(m_itemsSelect, m_connection);
+            m_itemsDataAdapter = new SqlDataAdapter(itemsSelectCmd);
+
+            SqlCommand terrainSelectCmd = new SqlCommand(m_terrainSelect, m_connection);
+            m_terrainDataAdapter = new SqlDataAdapter(terrainSelectCmd);
+
+            SqlCommand landSelectCmd = new SqlCommand(m_landSelect, m_connection);
+            m_landDataAdapter = new SqlDataAdapter(landSelectCmd);
+
+            SqlCommand landAccessListSelectCmd = new SqlCommand(m_landAccessListSelect, m_connection);
+            m_landAccessListDataAdapter = new SqlDataAdapter(landAccessListSelectCmd);
+
+            TestTables(m_connection);
+
+            lock (m_dataSet)
+            {
+                m_primTable = createPrimTable();
+                m_dataSet.Tables.Add(m_primTable);
+                setupPrimCommands(m_primDataAdapter, m_connection);
+                m_primDataAdapter.Fill(m_primTable);
+
+                m_shapeTable = createShapeTable();
+                m_dataSet.Tables.Add(m_shapeTable);
+                setupShapeCommands(m_shapeDataAdapter, m_connection);
+                m_shapeDataAdapter.Fill(m_shapeTable);
+
+                if (persistPrimInventories)
+                {
+                    m_itemsTable = createItemsTable();
+                    m_dataSet.Tables.Add(m_itemsTable);
+                    SetupItemsCommands(m_itemsDataAdapter, m_connection);
+                    m_itemsDataAdapter.Fill(m_itemsTable);
+                }
+
+                m_terrainTable = createTerrainTable();
+                m_dataSet.Tables.Add(m_terrainTable);
+                setupTerrainCommands(m_terrainDataAdapter, m_connection);
+                m_terrainDataAdapter.Fill(m_terrainTable);
+
+                m_landTable = createLandTable();
+                m_dataSet.Tables.Add(m_landTable);
+                setupLandCommands(m_landDataAdapter, m_connection);
+                m_landDataAdapter.Fill(m_landTable);
+
+                m_landAccessListTable = createLandAccessListTable();
+                m_dataSet.Tables.Add(m_landAccessListTable);
+                setupLandAccessCommands(m_landAccessListDataAdapter, m_connection);
+                m_landAccessListDataAdapter.Fill(m_landAccessListTable);                
+            }
+        }
+
+        public void StoreObject(SceneObjectGroup obj, LLUUID regionUUID)
+        {
+            // Instance.StoreObject(obj, regionUUID);
+
+            lock (m_dataSet)
+            {
+                foreach (SceneObjectPart prim in obj.Children.Values)
+                {
+                    if ((prim.ObjectFlags & (uint)LLObject.ObjectFlags.Physics) == 0)
+                    {
+                        m_log.Info("[DATASTORE]: Adding obj: " + obj.UUID + " to region: " + regionUUID);
+                        addPrim(prim, obj.UUID, regionUUID);
+                    }
+                    else
+                    {
+                        // m_log.Info("[DATASTORE]: Ignoring Physical obj: " + obj.UUID + " in region: " + regionUUID);
+                    }
+                }
+            }
+
+            Commit();
+        }
+
+        public void RemoveObject(LLUUID obj, LLUUID regionUUID)
+        {
+            // Instance.RemoveObject(obj, regionUUID);
+            
+            m_log.InfoFormat("[DATASTORE]: Removing obj: {0} from region: {1}", obj.UUID, regionUUID);
+
+            DataTable prims = m_primTable;
+            DataTable shapes = m_shapeTable;
+
+            string selectExp = "SceneGroupID = '" + obj.ToString() + "'";
+            lock (m_dataSet)
+            {
+                foreach (DataRow row in prims.Select(selectExp))
+                {
+                    // Remove shapes row
+                    LLUUID uuid = new LLUUID((string)row["UUID"]);
+
+                    DataRow shapeRow = shapes.Rows.Find(uuid.UUID);
+                    if (shapeRow != null)
+                    {
+                        shapeRow.Delete();
+                    }
+
+                    if (persistPrimInventories)
+                    {
+                        RemoveItems(new LLUUID((string)row["UUID"]));
+                    }
+
+                    // Remove prim row
+                    row.Delete();
+                }
+            }
+
+            Commit();
+        }
+
+        /// <summary>
+        /// Remove all persisted items of the given prim.
+        /// The caller must acquire the necessrary synchronization locks and commit or rollback changes.
+        /// </summary>
+        private void RemoveItems(LLUUID uuid)
+        {
+            String sql = String.Format("primID = '{0}'", uuid);
+            DataRow[] itemRows = m_itemsTable.Select(sql);
+
+            foreach (DataRow itemRow in itemRows)
+            {
+                itemRow.Delete();
+            }
+        }
+
+        /// <summary>
+        /// Load persisted objects from region storage.
+        /// </summary>        
+        public List<SceneObjectGroup> LoadObjects(LLUUID regionUUID)
+        {
+            // return Instance.LoadObjects(regionUUID);
+
+            Dictionary<LLUUID, SceneObjectGroup> createdObjects = new Dictionary<LLUUID, SceneObjectGroup>();
+
+            List<SceneObjectGroup> retvals = new List<SceneObjectGroup>();
+
+            DataTable prims = m_primTable;
+            DataTable shapes = m_shapeTable;
+
+            string byRegion = "RegionUUID = '" + regionUUID.ToString() + "'";
+            string orderByParent = "ParentID ASC";
+
+            lock (m_dataSet)
+            {
+                DataRow[] primsForRegion = prims.Select(byRegion, orderByParent);
+                m_log.Info("[DATASTORE]: " +
+                                         "Loaded " + primsForRegion.Length + " prims for region: " + regionUUID);
+
+                foreach (DataRow primRow in primsForRegion)
+                {
+                    try
+                    {
+                        string uuid = (string)primRow["UUID"];
+                        string objID = (string)primRow["SceneGroupID"];
+
+                        SceneObjectPart prim = buildPrim(primRow);
+
+                        if (uuid == objID) //is new SceneObjectGroup ?
+                        {
+                            SceneObjectGroup group = new SceneObjectGroup();
+
+                            DataRow shapeRow = shapes.Rows.Find(prim.UUID);
+                            if (shapeRow != null)
+                            {
+                                prim.Shape = buildShape(shapeRow);
+                            }
+                            else
+                            {
+                                m_log.Info(
+                                    "No shape found for prim in storage, so setting default box shape");
+                                prim.Shape = PrimitiveBaseShape.Default;
+                            }
+                            group.AddPart(prim);
+                            group.RootPart = prim;
+
+                            createdObjects.Add(group.UUID, group);
+                            retvals.Add(group);
+                        }
+                        else
+                        {
+                            DataRow shapeRow = shapes.Rows.Find(prim.UUID);
+                            if (shapeRow != null)
+                            {
+                                prim.Shape = buildShape(shapeRow);
+                            }
+                            else
+                            {
+                                m_log.Info(
+                                    "No shape found for prim in storage, so setting default box shape");
+                                prim.Shape = PrimitiveBaseShape.Default;
+                            }
+                            createdObjects[new LLUUID(objID)].AddPart(prim);
+                        }
+
+                        if (persistPrimInventories)
+                        {
+                            LoadItems(prim);
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Error("[DATASTORE]: Failed create prim object, exception and data follows");
+                        m_log.Info("[DATASTORE]: " + e.ToString());
+                        foreach (DataColumn col in prims.Columns)
+                        {
+                            m_log.Info("[DATASTORE]: Col: " + col.ColumnName + " => " + primRow[col]);
+                        }
+                    }
+                }
+            }
+            return retvals;
+        }
+
+        /// <summary>
+        /// Load in a prim's persisted inventory.
+        /// </summary>
+        /// <param name="prim"></param>
+        private void LoadItems(SceneObjectPart prim)
+        {
+            //m_log.InfoFormat("[DATASTORE]: Loading inventory for {0}, {1}", prim.Name, prim.UUID);
+
+            DataTable dbItems = m_itemsTable;
+
+            String sql = String.Format("primID = '{0}'", prim.UUID.ToString());
+            DataRow[] dbItemRows = dbItems.Select(sql);
+
+            IList<TaskInventoryItem> inventory = new List<TaskInventoryItem>();
+
+            foreach (DataRow row in dbItemRows)
+            {
+                TaskInventoryItem item = buildItem(row);
+                inventory.Add(item);
+
+                //m_log.DebugFormat("[DATASTORE]: Restored item {0}, {1}", item.Name, item.ItemID); 
+            }
+
+            prim.RestoreInventoryItems(inventory);
+
+            // XXX A nasty little hack to recover the folder id for the prim (which is currently stored in 
+            // every item).  This data should really be stored in the prim table itself.
+            if (dbItemRows.Length > 0)
+            {
+                prim.FolderID = inventory[0].ParentID;
+            }
+        }
+
+        public void StoreTerrain(double[,] ter, LLUUID regionID)
+        {
+            int revision = Util.UnixTimeSinceEpoch();
+            m_log.Info("[DATASTORE]: Storing terrain revision r" + revision.ToString());
+
+            DataTable terrain = m_dataSet.Tables["terrain"];
+            lock (m_dataSet)
+            {
+                SqlCommand cmd = new SqlCommand("insert into terrain(RegionUUID, Revision, Heightfield)" +
+                                                    " values(@RegionUUID, @Revision, @Heightfield)", m_connection);
+                using (cmd)
+                {
+                    cmd.Parameters.Add(new SqlParameter("@RegionUUID", regionID.UUID));
+                    cmd.Parameters.Add(new SqlParameter("@Revision", revision));
+                    cmd.Parameters.Add(new SqlParameter("@Heightfield", serializeTerrain(ter)));
+                    cmd.ExecuteNonQuery();
+                }
+            }
+        }
+
+        public double[,] LoadTerrain(LLUUID regionID)
+        {
+            double[,] terret = new double[256, 256];
+            terret.Initialize();
+
+            SqlCommand cmd = new SqlCommand(
+                @"select top 1 RegionUUID, Revision, Heightfield from terrain
+                where RegionUUID=@RegionUUID order by Revision desc"
+                , m_connection);
+
+            SqlParameter param = new SqlParameter();
+            cmd.Parameters.Add(new SqlParameter("@RegionUUID", regionID.UUID));
+
+            if (m_connection.State != ConnectionState.Open)
+            {
+                m_connection.Open();
+            }
+
+            using (SqlDataReader row = cmd.ExecuteReader())
+            {
+                int rev = 0;
+                if (row.Read())
+                {
+                    MemoryStream str = new MemoryStream((byte[])row["Heightfield"]);
+                    BinaryReader br = new BinaryReader(str);
+                    for (int x = 0; x < 256; x++)
+                    {
+                        for (int y = 0; y < 256; y++)
+                        {
+                            terret[x, y] = br.ReadDouble();
+                        }
+                    }
+                    rev = (int)row["Revision"];
+                }
+                else
+                {
+                    m_log.Info("[DATASTORE]: No terrain found for region");
+                    return null;
+                }
+
+                m_log.Info("[DATASTORE]: Loaded terrain revision r" + rev.ToString());
+            }
+
+            return terret;
+        }
+
+        public void RemoveLandObject(LLUUID globalID)
+        {
+            // Instance.RemoveLandObject(globalID);
+
+            lock (m_dataSet)
+            {
+                using (SqlCommand cmd = new SqlCommand("delete from land where UUID=@UUID", m_connection))
+                {
+                    cmd.Parameters.Add(new SqlParameter("@UUID", globalID.UUID));
+                    cmd.ExecuteNonQuery();
+                }
+
+                using (
+                    SqlCommand cmd = new SqlCommand("delete from landaccesslist where LandUUID=@UUID", m_connection)
+                    )
+                {
+                    cmd.Parameters.Add(new SqlParameter("@UUID", globalID.UUID));
+                    cmd.ExecuteNonQuery();
+                }
+            }
+        }
+
+        public void StoreLandObject(ILandObject parcel)
+        {
+            // Instance.StoreLandObject(parcel, regionUUID);
+
+            // Does the new locking fix it?
+            // m_log.Info("[DATASTORE]: Tedds temp fix: Waiting 3 seconds to avoid others writing to table while we hold a dataset of it. (Someone please fix! :))");
+            // System.Threading.Thread.Sleep(2500 + rnd.Next(0, 1000));
+
+            lock (m_dataSet)
+            {
+                DataTable land = m_landTable;
+                DataTable landaccesslist = m_landAccessListTable;
+
+                DataRow landRow = land.Rows.Find(parcel.landData.globalID.UUID);
+                if (landRow == null)
+                {
+                    landRow = land.NewRow();
+                    fillLandRow(landRow, parcel.landData, parcel.regionUUID);
+                    land.Rows.Add(landRow);
+                }
+                else
+                {
+                    fillLandRow(landRow, parcel.landData, parcel.regionUUID);
+                }
+
+                using (
+                    SqlCommand cmd =
+                        new SqlCommand("delete from landaccesslist where LandUUID=@LandUUID", m_connection))
+                {
+                    cmd.Parameters.Add(new SqlParameter("@LandUUID", parcel.landData.globalID.UUID));
+                    cmd.ExecuteNonQuery();
+                }
+
+                foreach (ParcelManager.ParcelAccessEntry entry in parcel.landData.parcelAccessList)
+                {
+                    DataRow newAccessRow = landaccesslist.NewRow();
+                    fillLandAccessRow(newAccessRow, entry, parcel.landData.globalID);
+                    landaccesslist.Rows.Add(newAccessRow);
+                }
+
+            }
+            Commit();
+        }
+
+        public List<LandData> LoadLandObjects(LLUUID regionUUID)
+        {
+            List<LandData> landDataForRegion = new List<LandData>();
+            lock (m_dataSet)
+            {
+                DataTable land = m_landTable;
+                DataTable landaccesslist = m_landAccessListTable;
+                string searchExp = "RegionUUID = '" + regionUUID.UUID + "'";
+                DataRow[] rawDataForRegion = land.Select(searchExp);
+                foreach (DataRow rawDataLand in rawDataForRegion)
+                {
+                    LandData newLand = buildLandData(rawDataLand);
+                    string accessListSearchExp = "LandUUID = '" + newLand.globalID.UUID + "'";
+                    DataRow[] rawDataForLandAccessList = landaccesslist.Select(accessListSearchExp);
+                    foreach (DataRow rawDataLandAccess in rawDataForLandAccessList)
+                    {
+                        newLand.parcelAccessList.Add(buildLandAccessData(rawDataLandAccess));
+                    }
+
+                    landDataForRegion.Add(newLand);
+                }
+            }
+            return landDataForRegion;
+        }
+
+        public void Commit()
+        {
+            if (m_connection.State != ConnectionState.Open)
+            {
+                m_connection.Open();
+            }
+
+            lock (m_dataSet)
+            {
+                // DisplayDataSet(m_dataSet, "Region DataSet");
+
+                m_primDataAdapter.Update(m_primTable);
+                m_shapeDataAdapter.Update(m_shapeTable);
+
+                if (persistPrimInventories)
+                {
+                    m_itemsDataAdapter.Update(m_itemsTable);
+                }
+
+                m_terrainDataAdapter.Update(m_terrainTable);
+                m_landDataAdapter.Update(m_landTable);
+                m_landAccessListDataAdapter.Update(m_landAccessListTable);
+
+                m_dataSet.AcceptChanges();
+            }
+        }
+
+        public void Shutdown()
+        {
+            Commit();
+        }
+
+        /***********************************************************************
+         *
+         *  Database Definition Functions
+         * 
+         *  This should be db agnostic as we define them in ADO.NET terms
+         *
+         **********************************************************************/
+
+        private DataColumn createCol(DataTable dt, string name, Type type)
+        {
+            DataColumn col = new DataColumn(name, type);
+            dt.Columns.Add(col);
+            return col;
+        }
+
+        private DataTable createTerrainTable()
+        {
+            DataTable terrain = new DataTable("terrain");
+
+            createCol(terrain, "RegionUUID", typeof(String));
+            createCol(terrain, "Revision", typeof(Int32));
+            createCol(terrain, "Heightfield", typeof(Byte[]));
+
+            return terrain;
+        }
+
+        private DataTable createPrimTable()
+        {
+            DataTable prims = new DataTable("prims");
+
+            createCol(prims, "UUID", typeof(String));
+            createCol(prims, "RegionUUID", typeof(String));
+            createCol(prims, "ParentID", typeof(Int32));
+            createCol(prims, "CreationDate", typeof(Int32));
+            createCol(prims, "Name", typeof(String));
+            createCol(prims, "SceneGroupID", typeof(String));
+            // various text fields
+            createCol(prims, "Text", typeof(String));
+            createCol(prims, "Description", typeof(String));
+            createCol(prims, "SitName", typeof(String));
+            createCol(prims, "TouchName", typeof(String));
+            // permissions
+            createCol(prims, "ObjectFlags", typeof(Int32));
+            createCol(prims, "CreatorID", typeof(String));
+            createCol(prims, "OwnerID", typeof(String));
+            createCol(prims, "GroupID", typeof(String));
+            createCol(prims, "LastOwnerID", typeof(String));
+            createCol(prims, "OwnerMask", typeof(Int32));
+            createCol(prims, "NextOwnerMask", typeof(Int32));
+            createCol(prims, "GroupMask", typeof(Int32));
+            createCol(prims, "EveryoneMask", typeof(Int32));
+            createCol(prims, "BaseMask", typeof(Int32));
+            // vectors
+            createCol(prims, "PositionX", typeof(Double));
+            createCol(prims, "PositionY", typeof(Double));
+            createCol(prims, "PositionZ", typeof(Double));
+            createCol(prims, "GroupPositionX", typeof(Double));
+            createCol(prims, "GroupPositionY", typeof(Double));
+            createCol(prims, "GroupPositionZ", typeof(Double));
+            createCol(prims, "VelocityX", typeof(Double));
+            createCol(prims, "VelocityY", typeof(Double));
+            createCol(prims, "VelocityZ", typeof(Double));
+            createCol(prims, "AngularVelocityX", typeof(Double));
+            createCol(prims, "AngularVelocityY", typeof(Double));
+            createCol(prims, "AngularVelocityZ", typeof(Double));
+            createCol(prims, "AccelerationX", typeof(Double));
+            createCol(prims, "AccelerationY", typeof(Double));
+            createCol(prims, "AccelerationZ", typeof(Double));
+            // quaternions
+            createCol(prims, "RotationX", typeof(Double));
+            createCol(prims, "RotationY", typeof(Double));
+            createCol(prims, "RotationZ", typeof(Double));
+            createCol(prims, "RotationW", typeof(Double));
+
+            // sit target
+            createCol(prims, "SitTargetOffsetX", typeof(Double));
+            createCol(prims, "SitTargetOffsetY", typeof(Double));
+            createCol(prims, "SitTargetOffsetZ", typeof(Double));
+
+            createCol(prims, "SitTargetOrientW", typeof(Double));
+            createCol(prims, "SitTargetOrientX", typeof(Double));
+            createCol(prims, "SitTargetOrientY", typeof(Double));
+            createCol(prims, "SitTargetOrientZ", typeof(Double));
+
+            // Add in contraints
+            prims.PrimaryKey = new DataColumn[] { prims.Columns["UUID"] };
+
+            return prims;
+        }
+
+        private DataTable createLandTable()
+        {
+            DataTable land = new DataTable("land");
+            createCol(land, "UUID", typeof(String));
+            createCol(land, "RegionUUID", typeof(String));
+            createCol(land, "LocalLandID", typeof(Int32));
+
+            // Bitmap is a byte[512]
+            createCol(land, "Bitmap", typeof(Byte[]));
+
+            createCol(land, "Name", typeof(String));
+            createCol(land, "Description", typeof(String));
+            createCol(land, "OwnerUUID", typeof(String));
+            createCol(land, "IsGroupOwned", typeof(Int32));
+            createCol(land, "Area", typeof(Int32));
+            createCol(land, "AuctionID", typeof(Int32)); //Unemplemented
+            createCol(land, "Category", typeof(Int32)); //Enum libsecondlife.Parcel.ParcelCategory
+            createCol(land, "ClaimDate", typeof(Int32));
+            createCol(land, "ClaimPrice", typeof(Int32));
+            createCol(land, "GroupUUID", typeof(String));
+            createCol(land, "SalePrice", typeof(Int32));
+            createCol(land, "LandStatus", typeof(Int32)); //Enum. libsecondlife.Parcel.ParcelStatus
+            createCol(land, "LandFlags", typeof(Int32));
+            createCol(land, "LandingType", typeof(Int32));
+            createCol(land, "MediaAutoScale", typeof(Int32));
+            createCol(land, "MediaTextureUUID", typeof(String));
+            createCol(land, "MediaURL", typeof(String));
+            createCol(land, "MusicURL", typeof(String));
+            createCol(land, "PassHours", typeof(Double));
+            createCol(land, "PassPrice", typeof(Int32));
+            createCol(land, "SnapshotUUID", typeof(String));
+            createCol(land, "UserLocationX", typeof(Double));
+            createCol(land, "UserLocationY", typeof(Double));
+            createCol(land, "UserLocationZ", typeof(Double));
+            createCol(land, "UserLookAtX", typeof(Double));
+            createCol(land, "UserLookAtY", typeof(Double));
+            createCol(land, "UserLookAtZ", typeof(Double));
+
+            land.PrimaryKey = new DataColumn[] { land.Columns["UUID"] };
+
+            return land;
+        }
+
+        private DataTable createLandAccessListTable()
+        {
+            DataTable landaccess = new DataTable("landaccesslist");
+            createCol(landaccess, "LandUUID", typeof(String));
+            createCol(landaccess, "AccessUUID", typeof(String));
+            createCol(landaccess, "Flags", typeof(Int32));
+
+            return landaccess;
+        }
+
+        private DataTable createShapeTable()
+        {
+            DataTable shapes = new DataTable("primshapes");
+            createCol(shapes, "UUID", typeof(String));
+            // shape is an enum
+            createCol(shapes, "Shape", typeof(Int32));
+            // vectors
+            createCol(shapes, "ScaleX", typeof(Double));
+            createCol(shapes, "ScaleY", typeof(Double));
+            createCol(shapes, "ScaleZ", typeof(Double));
+            // paths
+            createCol(shapes, "PCode", typeof(Int32));
+            createCol(shapes, "PathBegin", typeof(Int32));
+            createCol(shapes, "PathEnd", typeof(Int32));
+            createCol(shapes, "PathScaleX", typeof(Int32));
+            createCol(shapes, "PathScaleY", typeof(Int32));
+            createCol(shapes, "PathShearX", typeof(Int32));
+            createCol(shapes, "PathShearY", typeof(Int32));
+            createCol(shapes, "PathSkew", typeof(Int32));
+            createCol(shapes, "PathCurve", typeof(Int32));
+            createCol(shapes, "PathRadiusOffset", typeof(Int32));
+            createCol(shapes, "PathRevolutions", typeof(Int32));
+            createCol(shapes, "PathTaperX", typeof(Int32));
+            createCol(shapes, "PathTaperY", typeof(Int32));
+            createCol(shapes, "PathTwist", typeof(Int32));
+            createCol(shapes, "PathTwistBegin", typeof(Int32));
+            // profile
+            createCol(shapes, "ProfileBegin", typeof(Int32));
+            createCol(shapes, "ProfileEnd", typeof(Int32));
+            createCol(shapes, "ProfileCurve", typeof(Int32));
+            createCol(shapes, "ProfileHollow", typeof(Int32));
+            createCol(shapes, "State", typeof(Int32));
+            // text TODO: this isn't right, but I'm not sure the right
+            // way to specify this as a blob atm
+            createCol(shapes, "Texture", typeof(Byte[]));
+            createCol(shapes, "ExtraParams", typeof(Byte[]));
+
+            shapes.PrimaryKey = new DataColumn[] { shapes.Columns["UUID"] };
+
+            return shapes;
+        }
+
+        private DataTable createItemsTable()
+        {
+            DataTable items = new DataTable("primitems");
+
+            createCol(items, "itemID", typeof(String));
+            createCol(items, "primID", typeof(String));
+            createCol(items, "assetID", typeof(String));
+            createCol(items, "parentFolderID", typeof(String));
+
+            createCol(items, "invType", typeof(Int32));
+            createCol(items, "assetType", typeof(Int32));
+
+            createCol(items, "name", typeof(String));
+            createCol(items, "description", typeof(String));
+
+            createCol(items, "creationDate", typeof(Int64));
+            createCol(items, "creatorID", typeof(String));
+            createCol(items, "ownerID", typeof(String));
+            createCol(items, "lastOwnerID", typeof(String));
+            createCol(items, "groupID", typeof(String));
+
+            createCol(items, "nextPermissions", typeof(Int32));
+            createCol(items, "currentPermissions", typeof(Int32));
+            createCol(items, "basePermissions", typeof(Int32));
+            createCol(items, "everyonePermissions", typeof(Int32));
+            createCol(items, "groupPermissions", typeof(Int32));
+
+            items.PrimaryKey = new DataColumn[] { items.Columns["itemID"] };
+
+            return items;
+        }
+
+        /***********************************************************************
+         *  
+         *  Convert between ADO.NET <=> OpenSim Objects
+         *
+         *  These should be database independant
+         *
+         **********************************************************************/
+
+        private SceneObjectPart buildPrim(DataRow row)
+        {
+            SceneObjectPart prim = new SceneObjectPart();
+            prim.UUID = new LLUUID((String)row["UUID"]);
+            // explicit conversion of integers is required, which sort
+            // of sucks.  No idea if there is a shortcut here or not.
+            prim.ParentID = Convert.ToUInt32(row["ParentID"]);
+            prim.CreationDate = Convert.ToInt32(row["CreationDate"]);
+            prim.Name = (String)row["Name"];
+            // various text fields
+            prim.Text = (String)row["Text"];
+            prim.Description = (String)row["Description"];
+            prim.SitName = (String)row["SitName"];
+            prim.TouchName = (String)row["TouchName"];
+            // permissions
+            prim.ObjectFlags = Convert.ToUInt32(row["ObjectFlags"]);
+            prim.CreatorID = new LLUUID((String)row["CreatorID"]);
+            prim.OwnerID = new LLUUID((String)row["OwnerID"]);
+            prim.GroupID = new LLUUID((String)row["GroupID"]);
+            prim.LastOwnerID = new LLUUID((String)row["LastOwnerID"]);
+            prim.OwnerMask = Convert.ToUInt32(row["OwnerMask"]);
+            prim.NextOwnerMask = Convert.ToUInt32(row["NextOwnerMask"]);
+            prim.GroupMask = Convert.ToUInt32(row["GroupMask"]);
+            prim.EveryoneMask = Convert.ToUInt32(row["EveryoneMask"]);
+            prim.BaseMask = Convert.ToUInt32(row["BaseMask"]);
+            // vectors
+            prim.OffsetPosition = new LLVector3(
+                Convert.ToSingle(row["PositionX"]),
+                Convert.ToSingle(row["PositionY"]),
+                Convert.ToSingle(row["PositionZ"])
+                );
+            prim.GroupPosition = new LLVector3(
+                Convert.ToSingle(row["GroupPositionX"]),
+                Convert.ToSingle(row["GroupPositionY"]),
+                Convert.ToSingle(row["GroupPositionZ"])
+                );
+            prim.Velocity = new LLVector3(
+                Convert.ToSingle(row["VelocityX"]),
+                Convert.ToSingle(row["VelocityY"]),
+                Convert.ToSingle(row["VelocityZ"])
+                );
+            prim.AngularVelocity = new LLVector3(
+                Convert.ToSingle(row["AngularVelocityX"]),
+                Convert.ToSingle(row["AngularVelocityY"]),
+                Convert.ToSingle(row["AngularVelocityZ"])
+                );
+            prim.Acceleration = new LLVector3(
+                Convert.ToSingle(row["AccelerationX"]),
+                Convert.ToSingle(row["AccelerationY"]),
+                Convert.ToSingle(row["AccelerationZ"])
+                );
+            // quaternions
+            prim.RotationOffset = new LLQuaternion(
+                Convert.ToSingle(row["RotationX"]),
+                Convert.ToSingle(row["RotationY"]),
+                Convert.ToSingle(row["RotationZ"]),
+                Convert.ToSingle(row["RotationW"])
+                );
+            try
+            {
+                prim.SetSitTargetLL(new LLVector3(
+                                        Convert.ToSingle(row["SitTargetOffsetX"]),
+                                        Convert.ToSingle(row["SitTargetOffsetY"]),
+                                        Convert.ToSingle(row["SitTargetOffsetZ"])), new LLQuaternion(
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientX"]),
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientY"]),
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientZ"]),
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientW"])));
+            }
+            catch (InvalidCastException)
+            {
+                // Database table was created before we got here and now has null values :P
+
+                using (
+                    SqlCommand cmd =
+                        new SqlCommand(
+                            "ALTER TABLE [prims] ADD COLUMN [SitTargetOffsetX] float NOT NULL default 0,  ADD COLUMN [SitTargetOffsetY] float NOT NULL default 0, ADD COLUMN [SitTargetOffsetZ] float NOT NULL default 0, ADD COLUMN [SitTargetOrientW] float NOT NULL default 0, ADD COLUMN [SitTargetOrientX] float NOT NULL default 0, ADD COLUMN [SitTargetOrientY] float NOT NULL default 0, ADD COLUMN [SitTargetOrientZ] float NOT NULL default 0;",
+                            m_connection))
+                {
+                    cmd.ExecuteNonQuery();
+                }
+            }
+
+            return prim;
+        }
+
+        /// <summary>
+        /// Build a prim inventory item from the persisted data.
+        /// </summary>
+        /// <param name="row"></param>
+        /// <returns></returns>
+        private TaskInventoryItem buildItem(DataRow row)
+        {
+            TaskInventoryItem taskItem = new TaskInventoryItem();
+
+            taskItem.ItemID         = new LLUUID((String)row["itemID"]);
+            taskItem.ParentPartID   = new LLUUID((String)row["primID"]);
+            taskItem.AssetID        = new LLUUID((String)row["assetID"]);
+            taskItem.ParentID       = new LLUUID((String)row["parentFolderID"]);
+
+            taskItem.InvType        = Convert.ToInt32(row["invType"]);
+            taskItem.Type           = Convert.ToInt32(row["assetType"]);
+
+            taskItem.Name           = (String)row["name"];
+            taskItem.Description    = (String)row["description"];
+            taskItem.CreationDate   = Convert.ToUInt32(row["creationDate"]);
+            taskItem.CreatorID      = new LLUUID((String)row["creatorID"]);
+            taskItem.OwnerID        = new LLUUID((String)row["ownerID"]);
+            taskItem.LastOwnerID    = new LLUUID((String)row["lastOwnerID"]);
+            taskItem.GroupID        = new LLUUID((String)row["groupID"]);
+
+            taskItem.NextOwnerMask  = Convert.ToUInt32(row["nextPermissions"]);
+            taskItem.OwnerMask      = Convert.ToUInt32(row["currentPermissions"]);
+            taskItem.BaseMask       = Convert.ToUInt32(row["basePermissions"]);
+            taskItem.EveryoneMask   = Convert.ToUInt32(row["everyonePermissions"]);
+            taskItem.GroupMask      = Convert.ToUInt32(row["groupPermissions"]);
+
+            return taskItem;
+        }
+
+        private LandData buildLandData(DataRow row)
+        {
+            LandData newData = new LandData();
+
+            newData.globalID        = new LLUUID((String)row["UUID"]);
+            newData.localID         = Convert.ToInt32(row["LocalLandID"]);
+
+            // Bitmap is a byte[512]
+            newData.landBitmapByteArray = (Byte[])row["Bitmap"];
+
+            newData.landName        = (String)row["Name"];
+            newData.landDesc        = (String)row["Description"];
+            newData.ownerID         = (String)row["OwnerUUID"];
+            newData.isGroupOwned    = Convert.ToBoolean(row["IsGroupOwned"]);
+            newData.area            = Convert.ToInt32(row["Area"]);
+            newData.auctionID       = Convert.ToUInt32(row["AuctionID"]); //Unemplemented
+            newData.category        = (Parcel.ParcelCategory)Convert.ToInt32(row["Category"]);
+            //Enum libsecondlife.Parcel.ParcelCategory
+            newData.claimDate       = Convert.ToInt32(row["ClaimDate"]);
+            newData.claimPrice      = Convert.ToInt32(row["ClaimPrice"]);
+            newData.groupID         = new LLUUID((String)row["GroupUUID"]);
+            newData.salePrice       = Convert.ToInt32(row["SalePrice"]);
+            newData.landStatus      = (Parcel.ParcelStatus)Convert.ToInt32(row["LandStatus"]);
+            //Enum. libsecondlife.Parcel.ParcelStatus
+            newData.landFlags       = Convert.ToUInt32(row["LandFlags"]);
+            newData.landingType     = Convert.ToByte(row["LandingType"]);
+            newData.mediaAutoScale  = Convert.ToByte(row["MediaAutoScale"]);
+            newData.mediaID         = new LLUUID((String)row["MediaTextureUUID"]);
+            newData.mediaURL        = (String)row["MediaURL"];
+            newData.musicURL        = (String)row["MusicURL"];
+            newData.passHours       = Convert.ToSingle(row["PassHours"]);
+            newData.passPrice       = Convert.ToInt32(row["PassPrice"]);
+            newData.snapshotID      = (String)row["SnapshotUUID"];
+
+            newData.userLocation =
+                new LLVector3(Convert.ToSingle(row["UserLocationX"]), Convert.ToSingle(row["UserLocationY"]),
+                              Convert.ToSingle(row["UserLocationZ"]));
+            newData.userLookAt =
+                new LLVector3(Convert.ToSingle(row["UserLookAtX"]), Convert.ToSingle(row["UserLookAtY"]),
+                              Convert.ToSingle(row["UserLookAtZ"]));
+            newData.parcelAccessList = new List<ParcelManager.ParcelAccessEntry>();
+
+            return newData;
+        }
+
+        private ParcelManager.ParcelAccessEntry buildLandAccessData(DataRow row)
+        {
+            ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry();
+            entry.AgentID = new LLUUID((string)row["AccessUUID"]);
+            entry.Flags = (ParcelManager.AccessList)Convert.ToInt32(row["Flags"]);
+            entry.Time = new DateTime();
+            return entry;
+        }
+
+        private Array serializeTerrain(double[,] val)
+        {
+            MemoryStream str = new MemoryStream(65536 * sizeof(double));
+            BinaryWriter bw = new BinaryWriter(str);
+
+            // TODO: COMPATIBILITY - Add byte-order conversions
+            for (int x = 0; x < 256; x++)
+                for (int y = 0; y < 256; y++)
+                    bw.Write(val[x, y]);
+
+            return str.ToArray();
+        }
+
+        private void fillPrimRow(DataRow row, SceneObjectPart prim, LLUUID sceneGroupID, LLUUID regionUUID)
+        {
+            row["UUID"]                 = prim.UUID;
+            row["RegionUUID"]           = regionUUID;
+            row["ParentID"]             = prim.ParentID;
+            row["CreationDate"]         = prim.CreationDate;
+            row["Name"]                 = prim.Name;
+            row["SceneGroupID"]         = sceneGroupID;
+            // the UUID of the root part for this SceneObjectGroup
+            // various text fields
+            row["Text"]                 = prim.Text;
+            row["Description"]          = prim.Description;
+            row["SitName"]              = prim.SitName;
+            row["TouchName"]            = prim.TouchName;
+            // permissions
+            row["ObjectFlags"]          = prim.ObjectFlags;
+            row["CreatorID"]            = prim.CreatorID;
+            row["OwnerID"]              = prim.OwnerID;
+            row["GroupID"]              = prim.GroupID;
+            row["LastOwnerID"]          = prim.LastOwnerID;
+            row["OwnerMask"]            = prim.OwnerMask;
+            row["NextOwnerMask"]        = prim.NextOwnerMask;
+            row["GroupMask"]            = prim.GroupMask;
+            row["EveryoneMask"]         = prim.EveryoneMask;
+            row["BaseMask"]             = prim.BaseMask;
+            // vectors
+            row["PositionX"]            = prim.OffsetPosition.X;
+            row["PositionY"]            = prim.OffsetPosition.Y;
+            row["PositionZ"]            = prim.OffsetPosition.Z;
+            row["GroupPositionX"]       = prim.GroupPosition.X;
+            row["GroupPositionY"]       = prim.GroupPosition.Y;
+            row["GroupPositionZ"]       = prim.GroupPosition.Z;
+            row["VelocityX"]            = prim.Velocity.X;
+            row["VelocityY"]            = prim.Velocity.Y;
+            row["VelocityZ"]            = prim.Velocity.Z;
+            row["AngularVelocityX"]     = prim.AngularVelocity.X;
+            row["AngularVelocityY"]     = prim.AngularVelocity.Y;
+            row["AngularVelocityZ"]     = prim.AngularVelocity.Z;
+            row["AccelerationX"]        = prim.Acceleration.X;
+            row["AccelerationY"]        = prim.Acceleration.Y;
+            row["AccelerationZ"]        = prim.Acceleration.Z;
+            // quaternions
+            row["RotationX"]            = prim.RotationOffset.X;
+            row["RotationY"]            = prim.RotationOffset.Y;
+            row["RotationZ"]            = prim.RotationOffset.Z;
+            row["RotationW"]            = prim.RotationOffset.W;
+
+            try
+            {
+                // Sit target
+                LLVector3 sitTargetPos = prim.GetSitTargetPositionLL();
+                row["SitTargetOffsetX"] = sitTargetPos.X;
+                row["SitTargetOffsetY"] = sitTargetPos.Y;
+                row["SitTargetOffsetZ"] = sitTargetPos.Z;
+
+                LLQuaternion sitTargetOrient = prim.GetSitTargetOrientationLL();
+                row["SitTargetOrientW"] = sitTargetOrient.W;
+                row["SitTargetOrientX"] = sitTargetOrient.X;
+                row["SitTargetOrientY"] = sitTargetOrient.Y;
+                row["SitTargetOrientZ"] = sitTargetOrient.Z;
+            }
+            catch (Exception)
+            {
+                // Database table was created before we got here and needs to be created! :P
+
+                using (
+                    SqlCommand cmd =
+                        new SqlCommand(
+                            "ALTER TABLE [prims] ADD COLUMN [SitTargetOffsetX] float NOT NULL default 0,  ADD COLUMN [SitTargetOffsetY] float NOT NULL default 0, ADD COLUMN [SitTargetOffsetZ] float NOT NULL default 0, ADD COLUMN [SitTargetOrientW] float NOT NULL default 0, ADD COLUMN [SitTargetOrientX] float NOT NULL default 0, ADD COLUMN [SitTargetOrientY] float NOT NULL default 0, ADD COLUMN [SitTargetOrientZ] float NOT NULL default 0;",
+                            m_connection))
+                    {
+                        cmd.ExecuteNonQuery();
+                    }
+            }
+        }
+
+        private void fillItemRow(DataRow row, TaskInventoryItem taskItem)
+        {
+            row["itemID"] = taskItem.ItemID;
+            row["primID"] = taskItem.ParentPartID;
+            row["assetID"] = taskItem.AssetID;
+            row["parentFolderID"] = taskItem.ParentID;
+
+            row["invType"] = taskItem.InvType;
+            row["assetType"] = taskItem.Type;
+
+            row["name"] = taskItem.Name;
+            row["description"] = taskItem.Description;
+            row["creationDate"] = taskItem.CreationDate;
+            row["creatorID"] = taskItem.CreatorID;
+            row["ownerID"] = taskItem.OwnerID;
+            row["lastOwnerID"] = taskItem.LastOwnerID;
+            row["groupID"] = taskItem.GroupID;
+            row["nextPermissions"] = taskItem.NextOwnerMask;
+            row["currentPermissions"] = taskItem.OwnerMask;
+            row["basePermissions"] = taskItem.BaseMask;
+            row["everyonePermissions"] = taskItem.EveryoneMask;
+            row["groupPermissions"] = taskItem.GroupMask;
+        }
+
+        private void fillLandRow(DataRow row, LandData land, LLUUID regionUUID)
+        {
+            row["UUID"] = land.globalID.UUID;
+            row["RegionUUID"] = regionUUID.UUID;
+            row["LocalLandID"] = land.localID;
+
+            // Bitmap is a byte[512]
+            row["Bitmap"] = land.landBitmapByteArray;
+
+            row["Name"] = land.landName;
+            row["Description"] = land.landDesc;
+            row["OwnerUUID"] = land.ownerID.UUID;
+            row["IsGroupOwned"] = land.isGroupOwned;
+            row["Area"] = land.area;
+            row["AuctionID"] = land.auctionID; //Unemplemented
+            row["Category"] = land.category; //Enum libsecondlife.Parcel.ParcelCategory
+            row["ClaimDate"] = land.claimDate;
+            row["ClaimPrice"] = land.claimPrice;
+            row["GroupUUID"] = land.groupID.UUID;
+            row["SalePrice"] = land.salePrice;
+            row["LandStatus"] = land.landStatus; //Enum. libsecondlife.Parcel.ParcelStatus
+            row["LandFlags"] = land.landFlags;
+            row["LandingType"] = land.landingType;
+            row["MediaAutoScale"] = land.mediaAutoScale;
+            row["MediaTextureUUID"] = land.mediaID.UUID;
+            row["MediaURL"] = land.mediaURL;
+            row["MusicURL"] = land.musicURL;
+            row["PassHours"] = land.passHours;
+            row["PassPrice"] = land.passPrice;
+            row["SnapshotUUID"] = land.snapshotID.UUID;
+            row["UserLocationX"] = land.userLocation.X;
+            row["UserLocationY"] = land.userLocation.Y;
+            row["UserLocationZ"] = land.userLocation.Z;
+            row["UserLookAtX"] = land.userLookAt.X;
+            row["UserLookAtY"] = land.userLookAt.Y;
+            row["UserLookAtZ"] = land.userLookAt.Z;
+        }
+
+        private void fillLandAccessRow(DataRow row, ParcelManager.ParcelAccessEntry entry, LLUUID parcelID)
+        {
+            row["LandUUID"] = parcelID.UUID;
+            row["AccessUUID"] = entry.AgentID.UUID;
+            row["Flags"] = entry.Flags;
+        }
+
+        private PrimitiveBaseShape buildShape(DataRow row)
+        {
+            PrimitiveBaseShape s = new PrimitiveBaseShape();
+            s.Scale = new LLVector3(
+                Convert.ToSingle(row["ScaleX"]),
+                Convert.ToSingle(row["ScaleY"]),
+                Convert.ToSingle(row["ScaleZ"])
+                );
+            // paths
+            s.PCode = Convert.ToByte(row["PCode"]);
+            s.PathBegin = Convert.ToUInt16(row["PathBegin"]);
+            s.PathEnd = Convert.ToUInt16(row["PathEnd"]);
+            s.PathScaleX = Convert.ToByte(row["PathScaleX"]);
+            s.PathScaleY = Convert.ToByte(row["PathScaleY"]);
+            s.PathShearX = Convert.ToByte(row["PathShearX"]);
+            s.PathShearY = Convert.ToByte(row["PathShearY"]);
+            s.PathSkew = Convert.ToSByte(row["PathSkew"]);
+            s.PathCurve = Convert.ToByte(row["PathCurve"]);
+            s.PathRadiusOffset = Convert.ToSByte(row["PathRadiusOffset"]);
+            s.PathRevolutions = Convert.ToByte(row["PathRevolutions"]);
+            s.PathTaperX = Convert.ToSByte(row["PathTaperX"]);
+            s.PathTaperY = Convert.ToSByte(row["PathTaperY"]);
+            s.PathTwist = Convert.ToSByte(row["PathTwist"]);
+            s.PathTwistBegin = Convert.ToSByte(row["PathTwistBegin"]);
+            // profile
+            s.ProfileBegin = Convert.ToUInt16(row["ProfileBegin"]);
+            s.ProfileEnd = Convert.ToUInt16(row["ProfileEnd"]);
+            s.ProfileCurve = Convert.ToByte(row["ProfileCurve"]);
+            s.ProfileHollow = Convert.ToUInt16(row["ProfileHollow"]);
+            s.State = Convert.ToByte(row["State"]);
+
+            byte[] textureEntry = (byte[])row["Texture"];
+            s.TextureEntry = textureEntry;
+
+            s.ExtraParams = (byte[])row["ExtraParams"];
+
+            return s;
+        }
+
+        private void fillShapeRow(DataRow row, SceneObjectPart prim)
+        {
+            PrimitiveBaseShape s = prim.Shape;
+            row["UUID"] = prim.UUID;
+            // shape is an enum
+            row["Shape"] = 0;
+            // vectors
+            row["ScaleX"] = s.Scale.X;
+            row["ScaleY"] = s.Scale.Y;
+            row["ScaleZ"] = s.Scale.Z;
+            // paths
+            row["PCode"] = s.PCode;
+            row["PathBegin"] = s.PathBegin;
+            row["PathEnd"] = s.PathEnd;
+            row["PathScaleX"] = s.PathScaleX;
+            row["PathScaleY"] = s.PathScaleY;
+            row["PathShearX"] = s.PathShearX;
+            row["PathShearY"] = s.PathShearY;
+            row["PathSkew"] = s.PathSkew;
+            row["PathCurve"] = s.PathCurve;
+            row["PathRadiusOffset"] = s.PathRadiusOffset;
+            row["PathRevolutions"] = s.PathRevolutions;
+            row["PathTaperX"] = s.PathTaperX;
+            row["PathTaperY"] = s.PathTaperY;
+            row["PathTwist"] = s.PathTwist;
+            row["PathTwistBegin"] = s.PathTwistBegin;
+            // profile
+            row["ProfileBegin"] = s.ProfileBegin;
+            row["ProfileEnd"] = s.ProfileEnd;
+            row["ProfileCurve"] = s.ProfileCurve;
+            row["ProfileHollow"] = s.ProfileHollow;
+            row["State"] = s.State;
+            row["Texture"] = s.TextureEntry;
+            row["ExtraParams"] = s.ExtraParams;
+        }
+
+        private void addPrim(SceneObjectPart prim, LLUUID sceneGroupID, LLUUID regionUUID)
+        {
+            DataTable prims = m_dataSet.Tables["prims"];
+            DataTable shapes = m_dataSet.Tables["primshapes"];
+
+            DataRow primRow = prims.Rows.Find(prim.UUID);
+            if (primRow == null)
+            {
+                primRow = prims.NewRow();
+                fillPrimRow(primRow, prim, sceneGroupID, regionUUID);
+                prims.Rows.Add(primRow);
+            }
+            else
+            {
+                fillPrimRow(primRow, prim, sceneGroupID, regionUUID);
+            }
+
+            DataRow shapeRow = shapes.Rows.Find(prim.UUID);
+            if (shapeRow == null)
+            {
+                shapeRow = shapes.NewRow();
+                fillShapeRow(shapeRow, prim);
+                shapes.Rows.Add(shapeRow);
+            }
+            else
+            {
+                fillShapeRow(shapeRow, prim);
+            }
+        }
+
+        // see IRegionDatastore
+        public void StorePrimInventory(LLUUID primID, ICollection<TaskInventoryItem> items)
+        {
+            if (!persistPrimInventories)
+                return;
+
+            m_log.InfoFormat("[DATASTORE]: Persisting Prim Inventory with prim ID {0}", primID);
+
+            // For now, we're just going to crudely remove all the previous inventory items 
+            // no matter whether they have changed or not, and replace them with the current set.
+            lock (m_dataSet)
+            {
+                RemoveItems(primID);
+
+                // repalce with current inventory details
+                foreach (TaskInventoryItem newItem in items)
+                {
+                    //                    m_log.InfoFormat(
+                    //                        "[DATASTORE]: " +
+                    //                        "Adding item {0}, {1} to prim ID {2}", 
+                    //                        newItem.Name, newItem.ItemID, newItem.ParentPartID);
+
+                    DataRow newItemRow = m_itemsTable.NewRow();
+                    fillItemRow(newItemRow, newItem);
+                    m_itemsTable.Rows.Add(newItemRow);
+                }
+            }
+
+            Commit();
+        }
+
+        /***********************************************************************
+         *
+         *  SQL Statement Creation Functions
+         *
+         *  These functions create SQL statements for update, insert, and create.
+         *  They can probably be factored later to have a db independant
+         *  portion and a db specific portion
+         *
+         **********************************************************************/
+
+        private SqlCommand createInsertCommand(string table, DataTable dt)
+        {
+            /**
+             *  This is subtle enough to deserve some commentary.
+             *  Instead of doing *lots* and *lots of hardcoded strings
+             *  for database definitions we'll use the fact that
+             *  realistically all insert statements look like "insert
+             *  into A(b, c) values(:b, :c) on the parameterized query
+             *  front.  If we just have a list of b, c, etc... we can
+             *  generate these strings instead of typing them out.
+             */
+            string[] cols = new string[dt.Columns.Count];
+            for (int i = 0; i < dt.Columns.Count; i++)
+            {
+                DataColumn col = dt.Columns[i];
+                cols[i] = col.ColumnName;
+            }
+
+            string sql = "insert into " + table + "(";
+            sql += String.Join(", ", cols);
+            // important, the first ':' needs to be here, the rest get added in the join
+            sql += ") values (@";
+            sql += String.Join(", @", cols);
+            sql += ")";
+            SqlCommand cmd = new SqlCommand(sql);
+
+            // this provides the binding for all our parameters, so
+            // much less code than it used to be
+            foreach (DataColumn col in dt.Columns)
+            {
+                cmd.Parameters.Add(createSqlParameter(col.ColumnName, col.DataType));
+            }
+            return cmd;
+        }
+
+        private SqlCommand createUpdateCommand(string table, string pk, DataTable dt)
+        {
+            string sql = "update " + table + " set ";
+            string subsql = String.Empty;
+            foreach (DataColumn col in dt.Columns)
+            {
+                if (subsql.Length > 0)
+                {
+                    // a map function would rock so much here
+                    subsql += ", ";
+                }
+                subsql += col.ColumnName + "= @" + col.ColumnName;
+            }
+            sql += subsql;
+            sql += " where " + pk;
+            SqlCommand cmd = new SqlCommand(sql);
+            
+            // this provides the binding for all our parameters, so
+            // much less code than it used to be
+
+            foreach (DataColumn col in dt.Columns)
+            {
+                cmd.Parameters.Add(createSqlParameter(col.ColumnName, col.DataType));
+            }
+            return cmd;
+        }
+
+        private string defineTable(DataTable dt)
+        {
+            string sql = "create table " + dt.TableName + "(";
+            string subsql = String.Empty;
+            foreach (DataColumn col in dt.Columns)
+            {
+                if (subsql.Length > 0)
+                {
+                    // a map function would rock so much here
+                    subsql += ",\n";
+                }
+                subsql += col.ColumnName + " " + MSSQLManager.SqlType(col.DataType);
+                if (dt.PrimaryKey.Length > 0 && col == dt.PrimaryKey[0])
+                {
+                    subsql += " primary key";
+                }
+            }
+            sql += subsql;
+            sql += ")";
+
+            return sql;
+        }
+
+        /***********************************************************************
+         *
+         *  Database Binding functions
+         *
+         *  These will be db specific due to typing, and minor differences
+         *  in databases.
+         *
+         **********************************************************************/
+
+        ///<summary>
+        /// This is a convenience function that collapses 5 repetitive
+        /// lines for defining SqlParameters to 2 parameters:
+        /// column name and database type.
+        ///        
+        /// It assumes certain conventions like :param as the param
+        /// name to replace in parametrized queries, and that source
+        /// version is always current version, both of which are fine
+        /// for us.
+        ///</summary>
+        ///<returns>a built Sql parameter</returns>
+        private SqlParameter createSqlParameter(string name, Type type)
+        {
+            SqlParameter param = new SqlParameter();
+            param.ParameterName = "@" + name;
+            param.DbType = dbtypeFromType(type);
+            param.SourceColumn = name;
+            param.SourceVersion = DataRowVersion.Current;
+            return param;
+        }
+
+// TODO: unused
+//         private SqlParameter createParamWithValue(string name, Type type, Object o)
+//         {
+//             SqlParameter param = createSqlParameter(name, type);
+//             param.Value = o;
+//             return param;
+//         }
+
+        private void setupPrimCommands(SqlDataAdapter da, SqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("prims", m_dataSet.Tables["prims"]);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("prims", "UUID=@UUID", m_dataSet.Tables["prims"]);
+            da.UpdateCommand.Connection = conn;
+
+            SqlCommand delete = new SqlCommand("delete from prims where UUID = @UUID");
+            delete.Parameters.Add(createSqlParameter("UUID", typeof(String)));
+            delete.Connection = conn;
+            da.DeleteCommand = delete;
+        }
+
+        private void SetupItemsCommands(SqlDataAdapter da, SqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("primitems", m_itemsTable);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("primitems", "itemID = @itemID", m_itemsTable);
+            da.UpdateCommand.Connection = conn;
+
+            SqlCommand delete = new SqlCommand("delete from primitems where itemID = @itemID");
+            delete.Parameters.Add(createSqlParameter("itemID", typeof(String)));
+            delete.Connection = conn;
+            da.DeleteCommand = delete;
+        }
+
+        private void setupTerrainCommands(SqlDataAdapter da, SqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("terrain", m_dataSet.Tables["terrain"]);
+            da.InsertCommand.Connection = conn;
+        }
+
+        private void setupLandCommands(SqlDataAdapter da, SqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("land", m_dataSet.Tables["land"]);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("land", "UUID=@UUID", m_dataSet.Tables["land"]);
+            da.UpdateCommand.Connection = conn;
+        }
+
+        private void setupLandAccessCommands(SqlDataAdapter da, SqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("landaccesslist", m_dataSet.Tables["landaccesslist"]);
+            da.InsertCommand.Connection = conn;
+        }
+
+        private void setupShapeCommands(SqlDataAdapter da, SqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("primshapes", m_dataSet.Tables["primshapes"]);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("primshapes", "UUID=@UUID", m_dataSet.Tables["primshapes"]);
+            da.UpdateCommand.Connection = conn;
+
+            SqlCommand delete = new SqlCommand("delete from primshapes where UUID = @UUID");
+            delete.Parameters.Add(createSqlParameter("UUID", typeof(String)));
+            delete.Connection = conn;
+            da.DeleteCommand = delete;
+        }
+
+        private void InitDB(SqlConnection conn)
+        {
+            string createPrims = defineTable(createPrimTable());
+            string createShapes = defineTable(createShapeTable());
+            string createItems = defineTable(createItemsTable());
+            string createTerrain = defineTable(createTerrainTable());
+            string createLand = defineTable(createLandTable());
+            string createLandAccessList = defineTable(createLandAccessListTable());
+
+            SqlCommand pcmd = new SqlCommand(createPrims, conn);
+            SqlCommand scmd = new SqlCommand(createShapes, conn);
+            SqlCommand icmd = new SqlCommand(createItems, conn);
+            SqlCommand tcmd = new SqlCommand(createTerrain, conn);
+            SqlCommand lcmd = new SqlCommand(createLand, conn);
+            SqlCommand lalcmd = new SqlCommand(createLandAccessList, conn);
+            
+            conn.Open();
+            try
+            {
+                pcmd.ExecuteNonQuery();
+            }
+            catch (SqlException e)
+            {
+                m_log.WarnFormat("[MSSql]: Primitives Table Already Exists: {0}", e);
+            }
+
+            try
+            {
+                scmd.ExecuteNonQuery();
+            }
+            catch (SqlException e)
+            {
+                m_log.WarnFormat("[MSSql]: Shapes Table Already Exists: {0}", e);
+            }
+
+            try
+            {
+                icmd.ExecuteNonQuery();
+            }
+            catch (SqlException e)
+            {
+                m_log.WarnFormat("[MSSql]: Items Table Already Exists: {0}", e);
+            }
+
+            try
+            {
+                tcmd.ExecuteNonQuery();
+            }
+            catch (SqlException e)
+            {
+                m_log.WarnFormat("[MSSql]: Terrain Table Already Exists: {0}", e);
+            }
+
+            try
+            {
+                lcmd.ExecuteNonQuery();
+            }
+            catch (SqlException e)
+            {
+                m_log.WarnFormat("[MSSql]: Land Table Already Exists: {0}", e);
+            }
+
+            try
+            {
+                lalcmd.ExecuteNonQuery();
+            }
+            catch (SqlException e)
+            {
+                m_log.WarnFormat("[MSSql]: LandAccessList Table Already Exists: {0}", e);
+            }
+            conn.Close();
+        }
+
+        private bool TestTables(SqlConnection conn)
+        {
+            SqlCommand primSelectCmd = new SqlCommand(m_primSelect, conn);
+            SqlDataAdapter pDa = new SqlDataAdapter(primSelectCmd);
+            SqlCommand shapeSelectCmd = new SqlCommand(m_shapeSelect, conn);
+            SqlDataAdapter sDa = new SqlDataAdapter(shapeSelectCmd);
+            SqlCommand itemsSelectCmd = new SqlCommand(m_itemsSelect, conn);
+            SqlDataAdapter iDa = new SqlDataAdapter(itemsSelectCmd);
+            SqlCommand terrainSelectCmd = new SqlCommand(m_terrainSelect, conn);
+            SqlDataAdapter tDa = new SqlDataAdapter(terrainSelectCmd);
+            SqlCommand landSelectCmd = new SqlCommand(m_landSelect, conn);
+            SqlDataAdapter lDa = new SqlDataAdapter(landSelectCmd);
+            SqlCommand landAccessListSelectCmd = new SqlCommand(m_landAccessListSelect, conn);
+            SqlDataAdapter lalDa = new SqlDataAdapter(landAccessListSelectCmd);
+
+            DataSet tmpDS = new DataSet();
+            try
+            {
+                pDa.Fill(tmpDS, "prims");
+                sDa.Fill(tmpDS, "primshapes");
+
+                if (persistPrimInventories)
+                    iDa.Fill(tmpDS, "primitems");
+
+                tDa.Fill(tmpDS, "terrain");
+                lDa.Fill(tmpDS, "land");
+                lalDa.Fill(tmpDS, "landaccesslist");
+            }
+            catch (SqlException)
+            {
+                m_log.Info("[DATASTORE]: MySql Database doesn't exist... creating");
+                InitDB(conn);
+            }
+
+            pDa.Fill(tmpDS, "prims");
+            sDa.Fill(tmpDS, "primshapes");
+
+            if (persistPrimInventories)
+                iDa.Fill(tmpDS, "primitems");
+
+            tDa.Fill(tmpDS, "terrain");
+            lDa.Fill(tmpDS, "land");
+            lalDa.Fill(tmpDS, "landaccesslist");
+
+            foreach (DataColumn col in createPrimTable().Columns)
+            {
+                if (!tmpDS.Tables["prims"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing required column:" + col.ColumnName);
+                    return false;
+                }
+            }
+
+            foreach (DataColumn col in createShapeTable().Columns)
+            {
+                if (!tmpDS.Tables["primshapes"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing required column:" + col.ColumnName);
+                    return false;
+                }
+            }
+
+            // XXX primitems should probably go here eventually
+
+            foreach (DataColumn col in createTerrainTable().Columns)
+            {
+                if (!tmpDS.Tables["terrain"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing require column:" + col.ColumnName);
+                    return false;
+                }
+            }
+
+            foreach (DataColumn col in createLandTable().Columns)
+            {
+                if (!tmpDS.Tables["land"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing require column:" + col.ColumnName);
+                    return false;
+                }
+            }
+
+            foreach (DataColumn col in createLandAccessListTable().Columns)
+            {
+                if (!tmpDS.Tables["landaccesslist"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing require column:" + col.ColumnName);
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /***********************************************************************
+         *
+         *  Type conversion functions
+         *
+         **********************************************************************/
+
+        private DbType dbtypeFromType(Type type)
+        {
+            if (type == typeof(String))
+            {
+                return DbType.String;
+            }
+            else if (type == typeof(Int32))
+            {
+                return DbType.Int32;
+            }
+            else if (type == typeof(Double))
+            {
+                return DbType.Double;
+            }
+            else if (type == typeof(Byte[]))
+            {
+                return DbType.Binary;
+            }
+            else
+            {
+                return DbType.String;
+            }
+        }           
+    }
+}
diff --git a/OpenSim/Data/MSSQL/MSSQLGridData.cs b/OpenSim/Data/MSSQL/MSSQLGridData.cs
new file mode 100644
index 0000000..9bd8acc
--- /dev/null
+++ b/OpenSim/Data/MSSQL/MSSQLGridData.cs
@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Security.Cryptography;
+using System.Text;
+using libsecondlife;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.MSSQL
+{
+    /// <summary>
+    /// A grid data interface for Microsoft SQL Server
+    /// </summary>
+    public class MSSQLGridData : GridDataBase
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Database manager
+        /// </summary>
+        private MSSQLManager database;
+
+        private string m_regionsTableName;
+
+        /// <summary>
+        /// Initialises the Grid Interface
+        /// </summary>
+        override public void Initialise()
+        {
+            IniFile iniFile = new IniFile("mssql_connection.ini");
+
+            string settingDataSource = iniFile.ParseFileReadValue("data_source");
+            string settingInitialCatalog = iniFile.ParseFileReadValue("initial_catalog");
+            string settingPersistSecurityInfo = iniFile.ParseFileReadValue("persist_security_info");
+            string settingUserId = iniFile.ParseFileReadValue("user_id");
+            string settingPassword = iniFile.ParseFileReadValue("password");
+
+            m_regionsTableName = iniFile.ParseFileReadValue("regionstablename");
+            if (m_regionsTableName == null)
+            {
+                m_regionsTableName = "regions";
+            }
+
+            database =
+                new MSSQLManager(settingDataSource, settingInitialCatalog, settingPersistSecurityInfo, settingUserId,
+                                 settingPassword);
+
+            TestTables();
+        }
+
+        private void TestTables()
+        {
+            IDbCommand cmd = database.Query("SELECT TOP 1 * FROM "+m_regionsTableName, new Dictionary<string, string>());
+ 
+            try
+            {
+                cmd.ExecuteNonQuery();
+                cmd.Dispose();
+            }
+            catch (Exception)
+            {
+                m_log.Info("[DATASTORE]: MSSQL Database doesn't exist... creating");
+                database.ExecuteResourceSql("Mssql-regions.sql");            
+            }
+        }
+
+        /// <summary>
+        /// Shuts down the grid interface
+        /// </summary>
+        override public void Close()
+        {
+            database.Close();
+        }
+
+        /// <summary>
+        /// Returns the storage system name
+        /// </summary>
+        /// <returns>A string containing the storage system name</returns>
+        override public string getName()
+        {
+            return "Sql OpenGridData";
+        }
+
+        /// <summary>
+        /// Returns the storage system version
+        /// </summary>
+        /// <returns>A string containing the storage system version</returns>
+        override public string getVersion()
+        {
+            return "0.1";
+        }
+
+        /// <summary>
+        /// Returns a list of regions within the specified ranges
+        /// </summary>
+        /// <param name="a">minimum X coordinate</param>
+        /// <param name="b">minimum Y coordinate</param>
+        /// <param name="c">maximum X coordinate</param>
+        /// <param name="d">maximum Y coordinate</param>
+        /// <returns>An array of region profiles</returns>
+        override public RegionProfileData[] GetProfilesInRange(uint a, uint b, uint c, uint d)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a sim profile from its location
+        /// </summary>
+        /// <param name="handle">Region location handle</param>
+        /// <returns>Sim profile</returns>
+        override public RegionProfileData GetProfileByHandle(ulong handle)
+        {
+            IDataReader reader = null;
+            try
+            {
+                Dictionary<string, string> param = new Dictionary<string, string>();
+                param["handle"] = handle.ToString();
+                IDbCommand result = database.Query("SELECT * FROM " + m_regionsTableName + " WHERE regionHandle = @handle", param);
+                reader = result.ExecuteReader();
+
+                RegionProfileData row = database.getRegionRow(reader);
+                reader.Close();
+                result.Dispose();
+
+                return row;
+            }
+            catch (Exception)
+            {
+                if (reader != null)
+                {
+                    reader.Close();
+                }
+            }
+            return null;
+        }
+       
+        /// <summary>
+        /// Returns a sim profile from its UUID
+        /// </summary>
+        /// <param name="uuid">The region UUID</param>
+        /// <returns>The sim profile</returns>
+        override public RegionProfileData GetProfileByLLUUID(LLUUID uuid)
+        {
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["uuid"] = uuid.ToString();
+            IDbCommand result = database.Query("SELECT * FROM " + m_regionsTableName + " WHERE uuid = @uuid", param);
+            IDataReader reader = result.ExecuteReader();
+
+            RegionProfileData row = database.getRegionRow(reader);
+            reader.Close();
+            result.Dispose();
+
+            return row;
+        }
+
+        /// <summary>
+        /// Returns a sim profile from it's Region name string
+        /// </summary>
+        /// <param name="uuid">The region name search query</param>
+        /// <returns>The sim profile</returns>
+        override public RegionProfileData GetProfileByString(string regionName)
+        {
+            if (regionName.Length > 2)
+            {
+                try
+                {
+                    lock (database)
+                    {
+                        Dictionary<string, string> param = new Dictionary<string, string>();
+                        // Add % because this is a like query.
+                        param["?regionName"] = regionName + "%";
+                        // Order by statement will return shorter matches first.  Only returns one record or no record.
+                        IDbCommand result = database.Query("SELECT top 1 * FROM " + m_regionsTableName + " WHERE regionName like ?regionName order by regionName", param);
+                        IDataReader reader = result.ExecuteReader();
+
+                        RegionProfileData row = database.getRegionRow(reader);
+                        reader.Close();
+                        result.Dispose();
+
+                        return row;
+                    }
+                }
+                catch (Exception e)
+                {
+                    database.Reconnect();
+                    m_log.Error(e.ToString());
+                    return null;
+                }
+            }
+            else
+            {
+                m_log.Error("[DATABASE]: Searched for a Region Name shorter then 3 characters");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Adds a new specified region to the database
+        /// </summary>
+        /// <param name="profile">The profile to add</param>
+        /// <returns>A dataresponse enum indicating success</returns>
+        override public DataResponse AddProfile(RegionProfileData profile)
+        {
+            try
+            {
+                if (GetProfileByLLUUID(profile.UUID) != null)
+                {
+                    return DataResponse.RESPONSE_OK;
+                }
+            }
+            catch (Exception)
+            {
+                System.Console.WriteLine("No regions found. Create new one.");
+            }
+
+            if (insertRegionRow(profile))
+            {
+                return DataResponse.RESPONSE_OK;
+            }
+            else
+            {
+                return DataResponse.RESPONSE_ERROR;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new region in the database
+        /// </summary>
+        /// <param name="profile">The region profile to insert</param>
+        /// <returns>Successful?</returns>
+        public bool insertRegionRow(RegionProfileData profile)
+        {
+            //Insert new region
+            string sql =
+                "INSERT INTO " + m_regionsTableName + " ([regionHandle], [regionName], [uuid], [regionRecvKey], [regionSecret], [regionSendKey], [regionDataURI], ";
+            sql +=
+                "[serverIP], [serverPort], [serverURI], [locX], [locY], [locZ], [eastOverrideHandle], [westOverrideHandle], [southOverrideHandle], [northOverrideHandle], [regionAssetURI], [regionAssetRecvKey], ";
+            sql +=
+                "[regionAssetSendKey], [regionUserURI], [regionUserRecvKey], [regionUserSendKey], [regionMapTexture], [serverHttpPort], [serverRemotingPort], [owner_uuid]) VALUES ";
+
+            sql += "(@regionHandle, @regionName, @uuid, @regionRecvKey, @regionSecret, @regionSendKey, @regionDataURI, ";
+            sql +=
+                "@serverIP, @serverPort, @serverURI, @locX, @locY, @locZ, @eastOverrideHandle, @westOverrideHandle, @southOverrideHandle, @northOverrideHandle, @regionAssetURI, @regionAssetRecvKey, ";
+            sql +=
+                "@regionAssetSendKey, @regionUserURI, @regionUserRecvKey, @regionUserSendKey, @regionMapTexture, @serverHttpPort, @serverRemotingPort, @owner_uuid);";
+
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+
+            parameters["regionHandle"] = profile.regionHandle.ToString();
+            parameters["regionName"] = profile.regionName;
+            parameters["uuid"] = profile.UUID.ToString();
+            parameters["regionRecvKey"] = profile.regionRecvKey;
+            parameters["regionSecret"] = profile.regionSecret;
+            parameters["regionSendKey"] = profile.regionSendKey;
+            parameters["regionDataURI"] = profile.regionDataURI;
+            parameters["serverIP"] = profile.serverIP;
+            parameters["serverPort"] = profile.serverPort.ToString();
+            parameters["serverURI"] = profile.serverURI;
+            parameters["locX"] = profile.regionLocX.ToString();
+            parameters["locY"] = profile.regionLocY.ToString();
+            parameters["locZ"] = profile.regionLocZ.ToString();
+            parameters["eastOverrideHandle"] = profile.regionEastOverrideHandle.ToString();
+            parameters["westOverrideHandle"] = profile.regionWestOverrideHandle.ToString();
+            parameters["northOverrideHandle"] = profile.regionNorthOverrideHandle.ToString();
+            parameters["southOverrideHandle"] = profile.regionSouthOverrideHandle.ToString();
+            parameters["regionAssetURI"] = profile.regionAssetURI;
+            parameters["regionAssetRecvKey"] = profile.regionAssetRecvKey;
+            parameters["regionAssetSendKey"] = profile.regionAssetSendKey;
+            parameters["regionUserURI"] = profile.regionUserURI;
+            parameters["regionUserRecvKey"] = profile.regionUserRecvKey;
+            parameters["regionUserSendKey"] = profile.regionUserSendKey;
+            parameters["regionMapTexture"] = profile.regionMapTextureID.ToString();
+            parameters["serverHttpPort"] = profile.httpPort.ToString();
+            parameters["serverRemotingPort"] = profile.remotingPort.ToString();
+            parameters["owner_uuid"] = profile.owner_uuid.ToString();
+
+            bool returnval = false;
+
+            try
+            {
+                IDbCommand result = database.Query(sql, parameters);
+
+                if (result.ExecuteNonQuery() == 1)
+                    returnval = true;
+
+                result.Dispose();
+            }
+            catch (Exception e)
+            {
+                m_log.Error("MSSQLManager : " + e.ToString());
+            }
+
+            return returnval;
+        }
+
+        /// <summary>
+        /// DEPRECATED. Attempts to authenticate a region by comparing a shared secret.
+        /// </summary>
+        /// <param name="uuid">The UUID of the challenger</param>
+        /// <param name="handle">The attempted regionHandle of the challenger</param>
+        /// <param name="authkey">The secret</param>
+        /// <returns>Whether the secret and regionhandle match the database entry for UUID</returns>
+        override public bool AuthenticateSim(LLUUID uuid, ulong handle, string authkey)
+        {
+            bool throwHissyFit = false; // Should be true by 1.0
+
+            if (throwHissyFit)
+                throw new Exception("CRYPTOWEAK AUTHENTICATE: Refusing to authenticate due to replay potential.");
+
+            RegionProfileData data = GetProfileByLLUUID(uuid);
+
+            return (handle == data.regionHandle && authkey == data.regionSecret);
+        }
+
+        /// <summary>
+        /// NOT YET FUNCTIONAL. Provides a cryptographic authentication of a region
+        /// </summary>
+        /// <remarks>This requires a security audit.</remarks>
+        /// <param name="uuid"></param>
+        /// <param name="handle"></param>
+        /// <param name="authhash"></param>
+        /// <param name="challenge"></param>
+        /// <returns></returns>
+        public bool AuthenticateSim(LLUUID uuid, ulong handle, string authhash, string challenge)
+        {
+            SHA512Managed HashProvider = new SHA512Managed();
+            ASCIIEncoding TextProvider = new ASCIIEncoding();
+
+            byte[] stream = TextProvider.GetBytes(uuid.ToString() + ":" + handle.ToString() + ":" + challenge);
+            byte[] hash = HashProvider.ComputeHash(stream);
+            return false;
+        }
+
+        override public ReservationData GetReservationAtPoint(uint x, uint y)
+        {
+            return null;
+        }
+    }
+}
diff --git a/OpenSim/Data/MSSQL/MSSQLInventoryData.cs b/OpenSim/Data/MSSQL/MSSQLInventoryData.cs
new file mode 100644
index 0000000..1e99e51
--- /dev/null
+++ b/OpenSim/Data/MSSQL/MSSQLInventoryData.cs
@@ -0,0 +1,728 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using libsecondlife;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.MSSQL
+{
+    /// <summary>
+    /// A MySQL interface for the inventory server
+    /// </summary>
+    public class MSSQLInventoryData : IInventoryData
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// The database manager
+        /// </summary>
+        private MSSQLManager database;
+
+        /// <summary>
+        /// Loads and initialises this database plugin
+        /// </summary>
+        public void Initialise()
+        {
+            IniFile GridDataMySqlFile = new IniFile("mssql_connection.ini");
+            string settingDataSource = GridDataMySqlFile.ParseFileReadValue("data_source");
+            string settingInitialCatalog = GridDataMySqlFile.ParseFileReadValue("initial_catalog");
+            string settingPersistSecurityInfo = GridDataMySqlFile.ParseFileReadValue("persist_security_info");
+            string settingUserId = GridDataMySqlFile.ParseFileReadValue("user_id");
+            string settingPassword = GridDataMySqlFile.ParseFileReadValue("password");
+
+            database =
+                new MSSQLManager(settingDataSource, settingInitialCatalog, settingPersistSecurityInfo, settingUserId,
+                                 settingPassword);
+            TestTables();
+        }
+
+        #region Test and initialization code
+
+        private void UpgradeFoldersTable(string tableName)
+        {
+            // null as the version, indicates that the table didn't exist
+            if (tableName == null)
+            {
+                database.ExecuteResourceSql("CreateFoldersTable.sql");
+                //database.ExecuteResourceSql("UpgradeFoldersTableToVersion2.sql");   
+                return;
+            }
+        }
+
+        private void UpgradeItemsTable(string tableName)
+        {
+            // null as the version, indicates that the table didn't exist
+            if (tableName == null)
+            {
+                database.ExecuteResourceSql("CreateItemsTable.sql");
+                //database.ExecuteResourceSql("UpgradeItemsTableToVersion2.sql");
+                return;
+            }
+        }
+
+        private void TestTables()
+        {
+            Dictionary<string, string> tableList = new Dictionary<string, string>();
+
+            tableList["inventoryfolders"] = null;
+            tableList["inventoryitems"] = null;
+
+            database.GetTableVersion(tableList);
+
+            UpgradeFoldersTable(tableList["inventoryfolders"]);
+            UpgradeItemsTable(tableList["inventoryitems"]);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// The name of this DB provider
+        /// </summary>
+        /// <returns>Name of DB provider</returns>
+        public string getName()
+        {
+            return "MSSQL Inventory Data Interface";
+        }
+
+        /// <summary>
+        /// Closes this DB provider
+        /// </summary>
+        public void Close()
+        {
+            // Do nothing.
+        }
+
+        /// <summary>
+        /// Returns the version of this DB provider
+        /// </summary>
+        /// <returns>A string containing the DB provider</returns>
+        public string getVersion()
+        {
+            return database.getVersion();
+        }
+
+        /// <summary>
+        /// Returns a list of items in a specified folder
+        /// </summary>
+        /// <param name="folderID">The folder to search</param>
+        /// <returns>A list containing inventory items</returns>
+        public List<InventoryItemBase> getInventoryInFolder(LLUUID folderID)
+        {
+            try
+            {
+                lock (database)
+                {
+                    List<InventoryItemBase> items = new List<InventoryItemBase>();
+
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["parentFolderID"] = folderID.ToString();
+
+                    IDbCommand result =
+                        database.Query("SELECT * FROM inventoryitems WHERE parentFolderID = @parentFolderID", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    while (reader.Read())
+                        items.Add(readInventoryItem(reader));
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return items;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a list of the root folders within a users inventory
+        /// </summary>
+        /// <param name="user">The user whos inventory is to be searched</param>
+        /// <returns>A list of folder objects</returns>
+        public List<InventoryFolderBase> getUserRootFolders(LLUUID user)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["uuid"] = user.ToString();
+                    param["zero"] = LLUUID.Zero.ToString();
+
+                    IDbCommand result =
+                        database.Query(
+                            "SELECT * FROM inventoryfolders WHERE parentFolderID = @zero AND agentID = @uuid", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    List<InventoryFolderBase> items = new List<InventoryFolderBase>();
+                    while (reader.Read())
+                        items.Add(readInventoryFolder(reader));
+
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return items;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        // see InventoryItemBase.getUserRootFolder
+        public InventoryFolderBase getUserRootFolder(LLUUID user)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["uuid"] = user.ToString();
+                    param["zero"] = LLUUID.Zero.ToString();
+
+                    IDbCommand result =
+                        database.Query(
+                            "SELECT * FROM inventoryfolders WHERE parentFolderID = @zero AND agentID = @uuid", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    List<InventoryFolderBase> items = new List<InventoryFolderBase>();
+                    while (reader.Read())
+                        items.Add(readInventoryFolder(reader));
+
+                    InventoryFolderBase rootFolder = null;
+
+                    // There should only ever be one root folder for a user.  However, if there's more
+                    // than one we'll simply use the first one rather than failing.  It would be even
+                    // nicer to print some message to this effect, but this feels like it's too low a 
+                    // to put such a message out, and it's too minor right now to spare the time to
+                    // suitably refactor.                    
+                    if (items.Count > 0)
+                    {
+                        rootFolder = items[0];
+                    }
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return rootFolder;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a list of folders in a users inventory contained within the specified folder
+        /// </summary>
+        /// <param name="parentID">The folder to search</param>
+        /// <returns>A list of inventory folders</returns>
+        public List<InventoryFolderBase> getInventoryFolders(LLUUID parentID)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["parentFolderID"] = parentID.ToString();
+
+
+                    IDbCommand result =
+                        database.Query("SELECT * FROM inventoryfolders WHERE parentFolderID = @parentFolderID", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    List<InventoryFolderBase> items = new List<InventoryFolderBase>();
+
+                    while (reader.Read())
+                        items.Add(readInventoryFolder(reader));
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return items;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Reads a one item from an SQL result
+        /// </summary>
+        /// <param name="reader">The SQL Result</param>
+        /// <returns>the item read</returns>
+        private InventoryItemBase readInventoryItem(IDataReader reader)
+        {
+            try
+            {
+                InventoryItemBase item = new InventoryItemBase();
+
+                item.inventoryID = new LLUUID((string) reader["inventoryID"]);
+                item.assetID = new LLUUID((string) reader["assetID"]);
+                item.assetType = (int) reader["assetType"];
+                item.parentFolderID = new LLUUID((string) reader["parentFolderID"]);
+                item.avatarID = new LLUUID((string) reader["avatarID"]);
+                item.inventoryName = (string) reader["inventoryName"];
+                item.inventoryDescription = (string) reader["inventoryDescription"];
+                item.inventoryNextPermissions = Convert.ToUInt32(reader["inventoryNextPermissions"]);
+                item.inventoryCurrentPermissions = Convert.ToUInt32(reader["inventoryCurrentPermissions"]);
+                item.invType = (int) reader["invType"];
+                item.creatorsID = new LLUUID((string) reader["creatorID"]);
+                item.inventoryBasePermissions = Convert.ToUInt32(reader["inventoryBasePermissions"]);
+                item.inventoryEveryOnePermissions = Convert.ToUInt32(reader["inventoryEveryOnePermissions"]);
+                return item;
+            }
+            catch (SqlException e)
+            {
+                m_log.Error(e.ToString());
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a specified inventory item
+        /// </summary>
+        /// <param name="item">The item to return</param>
+        /// <returns>An inventory item</returns>
+        public InventoryItemBase getInventoryItem(LLUUID itemID)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["inventoryID"] = itemID.ToString();
+
+                    IDbCommand result =
+                        database.Query("SELECT * FROM inventoryitems WHERE inventoryID = @inventoryID", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    InventoryItemBase item = null;
+                    if (reader.Read())
+                        item = readInventoryItem(reader);
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return item;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Reads a list of inventory folders returned by a query.
+        /// </summary>
+        /// <param name="reader">A MySQL Data Reader</param>
+        /// <returns>A List containing inventory folders</returns>
+        protected InventoryFolderBase readInventoryFolder(IDataReader reader)
+        {
+            try
+            {
+                InventoryFolderBase folder = new InventoryFolderBase();
+                folder.agentID = new LLUUID((string) reader["agentID"]);
+                folder.parentID = new LLUUID((string) reader["parentFolderID"]);
+                folder.folderID = new LLUUID((string) reader["folderID"]);
+                folder.name = (string) reader["folderName"];
+                folder.type = (short) reader["type"];
+                folder.version = (ushort) ((int) reader["version"]);
+                return folder;
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a specified inventory folder
+        /// </summary>
+        /// <param name="folder">The folder to return</param>
+        /// <returns>A folder class</returns>
+        public InventoryFolderBase getInventoryFolder(LLUUID folderID)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["uuid"] = folderID.ToString();
+
+                    IDbCommand result = database.Query("SELECT * FROM inventoryfolders WHERE folderID = @uuid", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    reader.Read();
+                    InventoryFolderBase folder = readInventoryFolder(reader);
+                    reader.Close();
+                    result.Dispose();
+
+                    return folder;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Adds a specified item to the database
+        /// </summary>
+        /// <param name="item">The inventory item</param>
+        public void addInventoryItem(InventoryItemBase item)
+        {
+            if (getInventoryItem(item.inventoryID) != null)
+            {
+                updateInventoryItem(item);
+                return;
+            }
+
+            string sql = "INSERT INTO inventoryitems";
+            sql +=
+                "([inventoryID], [assetID], [assetType], [parentFolderID], [avatarID], [inventoryName], [inventoryDescription], [inventoryNextPermissions], [inventoryCurrentPermissions], [invType], [creatorID], [inventoryBasePermissions], [inventoryEveryOnePermissions]) VALUES ";
+            sql +=
+                "(@inventoryID, @assetID, @assetType, @parentFolderID, @avatarID, @inventoryName, @inventoryDescription, @inventoryNextPermissions, @inventoryCurrentPermissions, @invType, @creatorID, @inventoryBasePermissions, @inventoryEveryOnePermissions);";
+
+            try
+            {
+                Dictionary<string, string> param = new Dictionary<string, string>();
+                param["inventoryID"] = item.inventoryID.ToString();
+                param["assetID"] = item.assetID.ToString();
+                param["assetType"] = item.assetType.ToString();
+                param["parentFolderID"] = item.parentFolderID.ToString();
+                param["avatarID"] = item.avatarID.ToString();
+                param["inventoryName"] = item.inventoryName;
+                param["inventoryDescription"] = item.inventoryDescription;
+                param["inventoryNextPermissions"] = item.inventoryNextPermissions.ToString();
+                param["inventoryCurrentPermissions"] = item.inventoryCurrentPermissions.ToString();
+                param["invType"] = Convert.ToString(item.invType);
+                param["creatorID"] = item.creatorsID.ToString();
+                param["inventoryBasePermissions"] = Convert.ToString(item.inventoryBasePermissions);
+                param["inventoryEveryOnePermissions"] = Convert.ToString(item.inventoryEveryOnePermissions);
+
+                IDbCommand result = database.Query(sql, param);
+                result.ExecuteNonQuery();
+                result.Dispose();
+            }
+            catch (SqlException e)
+            {
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Updates the specified inventory item
+        /// </summary>
+        /// <param name="item">Inventory item to update</param>
+        public void updateInventoryItem(InventoryItemBase item)
+        {
+            SqlCommand command = new SqlCommand("UPDATE inventoryitems set inventoryID = @inventoryID, " +
+                                                "assetID = @assetID, " +
+                                                "assetType = @assetType" +
+                                                "parentFolderID = @parentFolderID" +
+                                                "avatarID = @avatarID" +
+                                                "inventoryName = @inventoryName" +
+                                                "inventoryDescription = @inventoryDescription" +
+                                                "inventoryNextPermissions = @inventoryNextPermissions" +
+                                                "inventoryCurrentPermissions = @inventoryCurrentPermissions" +
+                                                "invType = @invType" +
+                                                "creatorID = @creatorID" +
+                                                "inventoryBasePermissions = @inventoryBasePermissions" +
+                                                "inventoryEveryOnePermissions = @inventoryEveryOnePermissions) where " +
+                                                "inventoryID = @keyInventoryID;", database.getConnection());
+            SqlParameter param1 = new SqlParameter("@inventoryID", item.inventoryID.ToString());
+            SqlParameter param2 = new SqlParameter("@assetID", item.assetID);
+            SqlParameter param3 = new SqlParameter("@assetType", item.assetType);
+            SqlParameter param4 = new SqlParameter("@parentFolderID", item.parentFolderID);
+            SqlParameter param5 = new SqlParameter("@avatarID", item.avatarID);
+            SqlParameter param6 = new SqlParameter("@inventoryName", item.inventoryName);
+            SqlParameter param7 = new SqlParameter("@inventoryDescription", item.inventoryDescription);
+            SqlParameter param8 = new SqlParameter("@inventoryNextPermissions", item.inventoryNextPermissions);
+            SqlParameter param9 = new SqlParameter("@inventoryCurrentPermissions", item.inventoryCurrentPermissions);
+            SqlParameter param10 = new SqlParameter("@invType", item.invType);
+            SqlParameter param11 = new SqlParameter("@creatorID", item.creatorsID);
+            SqlParameter param12 = new SqlParameter("@inventoryBasePermissions", item.inventoryBasePermissions);
+            SqlParameter param13 = new SqlParameter("@inventoryEveryOnePermissions", item.inventoryEveryOnePermissions);
+            SqlParameter param14 = new SqlParameter("@keyInventoryID", item.inventoryID.ToString());
+            command.Parameters.Add(param1);
+            command.Parameters.Add(param2);
+            command.Parameters.Add(param3);
+            command.Parameters.Add(param4);
+            command.Parameters.Add(param5);
+            command.Parameters.Add(param6);
+            command.Parameters.Add(param7);
+            command.Parameters.Add(param8);
+            command.Parameters.Add(param9);
+            command.Parameters.Add(param10);
+            command.Parameters.Add(param11);
+            command.Parameters.Add(param12);
+            command.Parameters.Add(param13);
+            command.Parameters.Add(param14);
+
+            try
+            {
+                command.ExecuteNonQuery();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="item"></param>
+        public void deleteInventoryItem(LLUUID itemID)
+        {
+            try
+            {
+                Dictionary<string, string> param = new Dictionary<string, string>();
+                param["uuid"] = itemID.ToString();
+
+                IDbCommand cmd = database.Query("DELETE FROM inventoryitems WHERE inventoryID=@uuid", param);
+                cmd.ExecuteNonQuery();
+                cmd.Dispose();
+            }
+            catch (SqlException e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Creates a new inventory folder
+        /// </summary>
+        /// <param name="folder">Folder to create</param>
+        public void addInventoryFolder(InventoryFolderBase folder)
+        {
+            string sql =
+                "INSERT INTO inventoryfolders ([folderID], [agentID], [parentFolderID], [folderName], [type], [version]) VALUES ";
+            sql += "(@folderID, @agentID, @parentFolderID, @folderName, @type, @version);";
+
+
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["folderID"] = folder.folderID.ToString();
+            param["agentID"] = folder.agentID.ToString();
+            param["parentFolderID"] = folder.parentID.ToString();
+            param["folderName"] = folder.name;
+            param["type"] = Convert.ToString(folder.type);
+            param["version"] = Convert.ToString(folder.version);
+
+            try
+            {
+                IDbCommand result = database.Query(sql, param);
+                result.ExecuteNonQuery();
+                result.Dispose();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Updates an inventory folder
+        /// </summary>
+        /// <param name="folder">Folder to update</param>
+        public void updateInventoryFolder(InventoryFolderBase folder)
+        {
+            SqlCommand command = new SqlCommand("UPDATE inventoryfolders set folderID = @folderID, " +
+                                                "agentID = @agentID, " +
+                                                "parentFolderID = @parentFolderID," +
+                                                "folderName = @folderName," +
+                                                "type = @type," +
+                                                "version = @version where " +
+                                                "folderID = @keyFolderID;", database.getConnection());
+            SqlParameter param1 = new SqlParameter("@folderID", folder.folderID.ToString());
+            SqlParameter param2 = new SqlParameter("@agentID", folder.agentID.ToString());
+            SqlParameter param3 = new SqlParameter("@parentFolderID", folder.parentID.ToString());
+            SqlParameter param4 = new SqlParameter("@folderName", folder.name);
+            SqlParameter param5 = new SqlParameter("@type", folder.type);
+            SqlParameter param6 = new SqlParameter("@version", folder.version);
+            SqlParameter param7 = new SqlParameter("@keyFolderID", folder.folderID.ToString());
+            command.Parameters.Add(param1);
+            command.Parameters.Add(param2);
+            command.Parameters.Add(param3);
+            command.Parameters.Add(param4);
+            command.Parameters.Add(param5);
+            command.Parameters.Add(param6);
+            command.Parameters.Add(param7);
+
+            try
+            {
+                command.ExecuteNonQuery();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Updates an inventory folder
+        /// </summary>
+        /// <param name="folder">Folder to update</param>
+        public void moveInventoryFolder(InventoryFolderBase folder)
+        {
+            SqlCommand command = new SqlCommand("UPDATE inventoryfolders set folderID = @folderID, " +
+                                                "parentFolderID = @parentFolderID," +
+                                                "folderID = @keyFolderID;", database.getConnection());
+            SqlParameter param1 = new SqlParameter("@folderID", folder.folderID.ToString());
+            SqlParameter param2 = new SqlParameter("@parentFolderID", folder.parentID.ToString());
+            SqlParameter param3 = new SqlParameter("@keyFolderID", folder.folderID.ToString());
+            command.Parameters.Add(param1);
+            command.Parameters.Add(param2);
+            command.Parameters.Add(param3);
+
+            try
+            {
+                command.ExecuteNonQuery();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Append a list of all the child folders of a parent folder 
+        /// </summary>
+        /// <param name="folders">list where folders will be appended</param>
+        /// <param name="parentID">ID of parent</param>
+        protected void getInventoryFolders(ref List<InventoryFolderBase> folders, LLUUID parentID)
+        {
+            List<InventoryFolderBase> subfolderList = getInventoryFolders(parentID);
+
+            foreach (InventoryFolderBase f in subfolderList)
+                folders.Add(f);
+        }
+
+        // See IInventoryData
+        public List<InventoryFolderBase> getFolderHierarchy(LLUUID parentID)
+        {
+            List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
+            getInventoryFolders(ref folders, parentID);
+
+            for (int i = 0; i < folders.Count; i++)
+                getInventoryFolders(ref folders, folders[i].folderID);
+
+            return folders;
+        }
+
+        protected void deleteOneFolder(LLUUID folderID)
+        {
+            try
+            {
+                Dictionary<string, string> param = new Dictionary<string, string>();
+                param["folderID"] = folderID.ToString();
+
+                IDbCommand cmd = database.Query("DELETE FROM inventoryfolders WHERE folderID=@folderID", param);
+                cmd.ExecuteNonQuery();
+                cmd.Dispose();
+            }
+            catch (SqlException e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+        }
+
+        protected void deleteItemsInFolder(LLUUID folderID)
+        {
+            try
+            {
+                Dictionary<string, string> param = new Dictionary<string, string>();
+                param["parentFolderID"] = folderID.ToString();
+
+
+                IDbCommand cmd =
+                    database.Query("DELETE FROM inventoryitems WHERE parentFolderID=@parentFolderID", param);
+                cmd.ExecuteNonQuery();
+                cmd.Dispose();
+            }
+            catch (SqlException e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Delete an inventory folder
+        /// </summary>
+        /// <param name="folderId">Id of folder to delete</param>
+        public void deleteInventoryFolder(LLUUID folderID)
+        {
+            lock (database)
+            {
+                List<InventoryFolderBase> subFolders = getFolderHierarchy(folderID);
+
+                //Delete all sub-folders
+                foreach (InventoryFolderBase f in subFolders)
+                {
+                    deleteOneFolder(f.folderID);
+                    deleteItemsInFolder(f.folderID);
+                }
+
+                //Delete the actual row
+                deleteOneFolder(folderID);
+                deleteItemsInFolder(folderID);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Data/MSSQL/MSSQLLogData.cs b/OpenSim/Data/MSSQL/MSSQLLogData.cs
new file mode 100644
index 0000000..c76af53
--- /dev/null
+++ b/OpenSim/Data/MSSQL/MSSQLLogData.cs
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Collections.Generic;
+using System.Data;
+
+namespace OpenSim.Framework.Data.MSSQL
+{
+    /// <summary>
+    /// An interface to the log database for MySQL
+    /// </summary>
+    internal class MSSQLLogData : ILogData
+    {
+        /// <summary>
+        /// The database manager
+        /// </summary>
+        public MSSQLManager database;
+
+        /// <summary>
+        /// Artificial constructor called when the plugin is loaded
+        /// </summary>
+        public void Initialise()
+        {
+            IniFile GridDataMySqlFile = new IniFile("mssql_connection.ini");
+            string settingDataSource = GridDataMySqlFile.ParseFileReadValue("data_source");
+            string settingInitialCatalog = GridDataMySqlFile.ParseFileReadValue("initial_catalog");
+            string settingPersistSecurityInfo = GridDataMySqlFile.ParseFileReadValue("persist_security_info");
+            string settingUserId = GridDataMySqlFile.ParseFileReadValue("user_id");
+            string settingPassword = GridDataMySqlFile.ParseFileReadValue("password");
+
+            database =
+                new MSSQLManager(settingDataSource, settingInitialCatalog, settingPersistSecurityInfo, settingUserId,
+                                 settingPassword);
+
+            IDbCommand cmd = database.Query("select top 1 * from logs", new Dictionary<string, string>());
+            try
+            {
+                cmd.ExecuteNonQuery();
+                cmd.Dispose();
+            }
+            catch
+            {
+                database.ExecuteResourceSql("Mssql-logs.sql");
+            }
+
+        }
+
+        /// <summary>
+        /// Saves a log item to the database
+        /// </summary>
+        /// <param name="serverDaemon">The daemon triggering the event</param>
+        /// <param name="target">The target of the action (region / agent UUID, etc)</param>
+        /// <param name="methodCall">The method call where the problem occured</param>
+        /// <param name="arguments">The arguments passed to the method</param>
+        /// <param name="priority">How critical is this?</param>
+        /// <param name="logMessage">The message to log</param>
+        public void saveLog(string serverDaemon, string target, string methodCall, string arguments, int priority,
+                            string logMessage)
+        {
+            try
+            {
+                database.insertLogRow(serverDaemon, target, methodCall, arguments, priority, logMessage);
+            }
+            catch
+            {
+                database.Reconnect();
+            }
+        }
+
+        /// <summary>
+        /// Returns the name of this DB provider
+        /// </summary>
+        /// <returns>A string containing the DB provider name</returns>
+        public string getName()
+        {
+            return "MSSQL Logdata Interface";
+        }
+
+        /// <summary>
+        /// Closes the database provider
+        /// </summary>
+        public void Close()
+        {
+            // Do nothing.
+        }
+
+        /// <summary>
+        /// Returns the version of this DB provider
+        /// </summary>
+        /// <returns>A string containing the provider version</returns>
+        public string getVersion()
+        {
+            return "0.1";
+        }
+    }
+}
diff --git a/OpenSim/Data/MSSQL/MSSQLManager.cs b/OpenSim/Data/MSSQL/MSSQLManager.cs
new file mode 100644
index 0000000..efe62be
--- /dev/null
+++ b/OpenSim/Data/MSSQL/MSSQLManager.cs
@@ -0,0 +1,529 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using System.IO;
+using System.Reflection;
+using libsecondlife;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.MSSQL
+{
+    /// <summary>
+    /// A management class for the MS SQL Storage Engine
+    /// </summary>
+    public class MSSQLManager
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// The database connection object
+        /// </summary>
+        private IDbConnection dbcon;
+
+        /// <summary>
+        /// Connection string for ADO.net
+        /// </summary>
+        private readonly string connectionString;
+
+        public MSSQLManager(string dataSource, string initialCatalog, string persistSecurityInfo, string userId,
+                            string password)
+        {
+            connectionString = "Data Source=" + dataSource + ";Initial Catalog=" + initialCatalog +
+                                   ";Persist Security Info=" + persistSecurityInfo + ";User ID=" + userId + ";Password=" +
+                                   password + ";";
+            dbcon = new SqlConnection(connectionString);
+            dbcon.Open();
+        }
+
+        //private DataTable createRegionsTable()
+        //{
+        //    DataTable regions = new DataTable("regions");
+
+        //    createCol(regions, "regionHandle", typeof (ulong));
+        //    createCol(regions, "regionName", typeof (String));
+        //    createCol(regions, "uuid", typeof (String));
+
+        //    createCol(regions, "regionRecvKey", typeof (String));
+        //    createCol(regions, "regionSecret", typeof (String));
+        //    createCol(regions, "regionSendKey", typeof (String));
+
+        //    createCol(regions, "regionDataURI", typeof (String));
+        //    createCol(regions, "serverIP", typeof (String));
+        //    createCol(regions, "serverPort", typeof (String));
+        //    createCol(regions, "serverURI", typeof (String));
+
+
+        //    createCol(regions, "locX", typeof (uint));
+        //    createCol(regions, "locY", typeof (uint));
+        //    createCol(regions, "locZ", typeof (uint));
+
+        //    createCol(regions, "eastOverrideHandle", typeof (ulong));
+        //    createCol(regions, "westOverrideHandle", typeof (ulong));
+        //    createCol(regions, "southOverrideHandle", typeof (ulong));
+        //    createCol(regions, "northOverrideHandle", typeof (ulong));
+
+        //    createCol(regions, "regionAssetURI", typeof (String));
+        //    createCol(regions, "regionAssetRecvKey", typeof (String));
+        //    createCol(regions, "regionAssetSendKey", typeof (String));
+
+        //    createCol(regions, "regionUserURI", typeof (String));
+        //    createCol(regions, "regionUserRecvKey", typeof (String));
+        //    createCol(regions, "regionUserSendKey", typeof (String));
+
+        //    createCol(regions, "regionMapTexture", typeof (String));
+        //    createCol(regions, "serverHttpPort", typeof (String));
+        //    createCol(regions, "serverRemotingPort", typeof (uint));
+
+        //    // Add in contraints
+        //    regions.PrimaryKey = new DataColumn[] {regions.Columns["UUID"]};
+        //    return regions;
+        //}
+
+        protected static void createCol(DataTable dt, string name, Type type)
+        {
+            DataColumn col = new DataColumn(name, type);
+            dt.Columns.Add(col);
+        }
+
+        protected static string defineTable(DataTable dt)
+        {
+            string sql = "create table " + dt.TableName + "(";
+            string subsql = String.Empty;
+            foreach (DataColumn col in dt.Columns)
+            {
+                if (subsql.Length > 0)
+                {
+                    // a map function would rock so much here
+                    subsql += ",\n";
+                }
+
+                subsql += col.ColumnName + " " + SqlType(col.DataType);
+                if (col == dt.PrimaryKey[0])
+                {
+                    subsql += " primary key";
+                }
+            }
+            sql += subsql;
+            sql += ")";
+            return sql;
+        }
+
+
+        // this is something we'll need to implement for each db
+        // slightly differently.
+        public static string SqlType(Type type)
+        {
+            if (type == typeof(String))
+            {
+                return "varchar(255)";
+            }
+            else if (type == typeof(Int32))
+            {
+                return "integer";
+            }
+            else if (type == typeof(Double))
+            {
+                return "float";
+            }
+            else if (type == typeof(Byte[]))
+            {
+                return "image";
+            }
+            else
+            {
+                return "varchar(255)";
+            }
+        }
+
+        /// <summary>
+        /// Shuts down the database connection
+        /// </summary>
+        public void Close()
+        {
+            dbcon.Close();
+            dbcon = null;
+        }
+
+        /// <summary>
+        /// Reconnects to the database
+        /// </summary>
+        public void Reconnect()
+        {
+            lock (dbcon)
+            {
+                try
+                {
+                    // Close the DB connection
+                    dbcon.Close();
+                    // Try reopen it
+                    dbcon = new SqlConnection(connectionString);
+                    dbcon.Open();
+                }
+                catch (Exception e)
+                {
+                    m_log.Error("Unable to reconnect to database " + e.ToString());
+                }
+            }
+        }
+
+        /// <summary>
+        /// Runs a query with protection against SQL Injection by using parameterised input.
+        /// </summary>
+        /// <param name="sql">The SQL string - replace any variables such as WHERE x = "y" with WHERE x = @y</param>
+        /// <param name="parameters">The parameters - index so that @y is indexed as 'y'</param>
+        /// <returns>A Sql DB Command</returns>
+        public IDbCommand Query(string sql, Dictionary<string, string> parameters)
+        {
+            SqlCommand dbcommand = (SqlCommand)dbcon.CreateCommand();
+            dbcommand.CommandText = sql;
+            foreach (KeyValuePair<string, string> param in parameters)
+            {
+                dbcommand.Parameters.AddWithValue(param.Key, param.Value);
+            }
+
+            return (IDbCommand)dbcommand;
+        }
+
+        /// <summary>
+        /// Runs a database reader object and returns a region row
+        /// </summary>
+        /// <param name="reader">An active database reader</param>
+        /// <returns>A region row</returns>
+        public RegionProfileData getRegionRow(IDataReader reader)
+        {
+            RegionProfileData regionprofile = new RegionProfileData();
+
+            if (reader.Read())
+            {
+                // Region Main
+                regionprofile.regionHandle = Convert.ToUInt64(reader["regionHandle"]);
+                regionprofile.regionName = (string)reader["regionName"];
+                regionprofile.UUID = new LLUUID((string)reader["uuid"]);
+
+                // Secrets
+                regionprofile.regionRecvKey = (string)reader["regionRecvKey"];
+                regionprofile.regionSecret = (string)reader["regionSecret"];
+                regionprofile.regionSendKey = (string)reader["regionSendKey"];
+
+                // Region Server
+                regionprofile.regionDataURI = (string)reader["regionDataURI"];
+                regionprofile.regionOnline = false; // Needs to be pinged before this can be set.
+                regionprofile.serverIP = (string)reader["serverIP"];
+                regionprofile.serverPort = Convert.ToUInt32(reader["serverPort"]);
+                regionprofile.serverURI = (string)reader["serverURI"];
+                regionprofile.httpPort = Convert.ToUInt32(reader["serverHttpPort"]);
+                regionprofile.remotingPort = Convert.ToUInt32(reader["serverRemotingPort"]);
+
+
+                // Location
+                regionprofile.regionLocX = Convert.ToUInt32(reader["locX"]);
+                regionprofile.regionLocY = Convert.ToUInt32(reader["locY"]);
+                regionprofile.regionLocZ = Convert.ToUInt32(reader["locZ"]);
+
+                // Neighbours - 0 = No Override
+                regionprofile.regionEastOverrideHandle = Convert.ToUInt64(reader["eastOverrideHandle"]);
+                regionprofile.regionWestOverrideHandle = Convert.ToUInt64(reader["westOverrideHandle"]);
+                regionprofile.regionSouthOverrideHandle = Convert.ToUInt64(reader["southOverrideHandle"]);
+                regionprofile.regionNorthOverrideHandle = Convert.ToUInt64(reader["northOverrideHandle"]);
+
+                // Assets
+                regionprofile.regionAssetURI = (string)reader["regionAssetURI"];
+                regionprofile.regionAssetRecvKey = (string)reader["regionAssetRecvKey"];
+                regionprofile.regionAssetSendKey = (string)reader["regionAssetSendKey"];
+
+                // Userserver
+                regionprofile.regionUserURI = (string)reader["regionUserURI"];
+                regionprofile.regionUserRecvKey = (string)reader["regionUserRecvKey"];
+                regionprofile.regionUserSendKey = (string)reader["regionUserSendKey"];
+                try
+                {
+                    regionprofile.owner_uuid = new LLUUID((string)reader["owner_uuid"]);
+                }
+                catch(Exception)
+                {}
+                // World Map Addition
+                string tempRegionMap = reader["regionMapTexture"].ToString();
+                if (tempRegionMap != String.Empty)
+                {
+                    regionprofile.regionMapTextureID = new LLUUID(tempRegionMap);
+                }
+                else
+                {
+                    regionprofile.regionMapTextureID = new LLUUID();
+                }
+            }
+            else
+            {
+                reader.Close();
+                throw new Exception("No rows to return");
+            }
+            return regionprofile;
+        }
+
+        /// <summary>
+        /// Reads a user profile from an active data reader
+        /// </summary>
+        /// <param name="reader">An active database reader</param>
+        /// <returns>A user profile</returns>
+        public UserProfileData readUserRow(IDataReader reader)
+        {
+            UserProfileData retval = new UserProfileData();
+
+            if (reader.Read())
+            {
+                retval.UUID = new LLUUID((string)reader["UUID"]);
+                retval.username = (string)reader["username"];
+                retval.surname = (string)reader["lastname"];
+
+                retval.passwordHash = (string)reader["passwordHash"];
+                retval.passwordSalt = (string)reader["passwordSalt"];
+
+                retval.homeRegion = Convert.ToUInt64(reader["homeRegion"].ToString());
+                retval.homeLocation = new LLVector3(
+                    Convert.ToSingle(reader["homeLocationX"].ToString()),
+                    Convert.ToSingle(reader["homeLocationY"].ToString()),
+                    Convert.ToSingle(reader["homeLocationZ"].ToString()));
+                retval.homeLookAt = new LLVector3(
+                    Convert.ToSingle(reader["homeLookAtX"].ToString()),
+                    Convert.ToSingle(reader["homeLookAtY"].ToString()),
+                    Convert.ToSingle(reader["homeLookAtZ"].ToString()));
+
+                retval.created = Convert.ToInt32(reader["created"].ToString());
+                retval.lastLogin = Convert.ToInt32(reader["lastLogin"].ToString());
+
+                retval.userInventoryURI = (string)reader["userInventoryURI"];
+                retval.userAssetURI = (string)reader["userAssetURI"];
+
+                retval.profileCanDoMask = Convert.ToUInt32(reader["profileCanDoMask"].ToString());
+                retval.profileWantDoMask = Convert.ToUInt32(reader["profileWantDoMask"].ToString());
+
+                retval.profileAboutText = (string)reader["profileAboutText"];
+                retval.profileFirstText = (string)reader["profileFirstText"];
+
+                retval.profileImage = new LLUUID((string)reader["profileImage"]);
+                retval.profileFirstImage = new LLUUID((string)reader["profileFirstImage"]);
+                retval.webLoginKey = new LLUUID((string)reader["webLoginKey"]);
+            }
+            else
+            {
+                return null;
+            }
+            return retval;
+        }
+
+        /// <summary>
+        /// Reads an agent row from a database reader
+        /// </summary>
+        /// <param name="reader">An active database reader</param>
+        /// <returns>A user session agent</returns>
+        public UserAgentData readAgentRow(IDataReader reader)
+        {
+            UserAgentData retval = new UserAgentData();
+
+            if (reader.Read())
+            {
+                // Agent IDs
+                retval.UUID = new LLUUID((string)reader["UUID"]);
+                retval.sessionID = new LLUUID((string)reader["sessionID"]);
+                retval.secureSessionID = new LLUUID((string)reader["secureSessionID"]);
+
+                // Agent Who?
+                retval.agentIP = (string)reader["agentIP"];
+                retval.agentPort = Convert.ToUInt32(reader["agentPort"].ToString());
+                retval.agentOnline = Convert.ToBoolean(reader["agentOnline"].ToString());
+
+                // Login/Logout times (UNIX Epoch)
+                retval.loginTime = Convert.ToInt32(reader["loginTime"].ToString());
+                retval.logoutTime = Convert.ToInt32(reader["logoutTime"].ToString());
+
+                // Current position
+                retval.currentRegion = (string)reader["currentRegion"];
+                retval.currentHandle = Convert.ToUInt64(reader["currentHandle"].ToString());
+                LLVector3.TryParse((string)reader["currentPos"], out retval.currentPos);
+            }
+            else
+            {
+                return null;
+            }
+            return retval;
+        }
+
+        public AssetBase getAssetRow(IDataReader reader)
+        {
+            AssetBase asset = new AssetBase();
+            if (reader.Read())
+            {
+                // Region Main
+
+                asset = new AssetBase();
+                asset.Data = (byte[])reader["data"];
+                asset.Description = (string)reader["description"];
+                asset.FullID = new LLUUID((string)reader["id"]);
+                asset.InvType = Convert.ToSByte(reader["invType"]);
+                asset.Local = Convert.ToBoolean(reader["local"]); // ((sbyte)reader["local"]) != 0 ? true : false;
+                asset.Name = (string)reader["name"];
+                asset.Type = Convert.ToSByte(reader["assetType"]);
+            }
+            else
+            {
+                return null; // throw new Exception("No rows to return");
+            }
+            return asset;
+        }
+
+
+        /// <summary>
+        /// Inserts a new row into the log database
+        /// </summary>
+        /// <param name="serverDaemon">The daemon which triggered this event</param>
+        /// <param name="target">Who were we operating on when this occured (region UUID, user UUID, etc)</param>
+        /// <param name="methodCall">The method call where the problem occured</param>
+        /// <param name="arguments">The arguments passed to the method</param>
+        /// <param name="priority">How critical is this?</param>
+        /// <param name="logMessage">Extra message info</param>
+        /// <returns>Saved successfully?</returns>
+        public bool insertLogRow(string serverDaemon, string target, string methodCall, string arguments, int priority,
+                                 string logMessage)
+        {
+            string sql = "INSERT INTO logs ([target], [server], [method], [arguments], [priority], [message]) VALUES ";
+            sql += "(@target, @server, @method, @arguments, @priority, @message);";
+
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+            parameters["server"] = serverDaemon;
+            parameters["target"] = target;
+            parameters["method"] = methodCall;
+            parameters["arguments"] = arguments;
+            parameters["priority"] = priority.ToString();
+            parameters["message"] = logMessage;
+
+            bool returnval = false;
+
+            try
+            {
+                IDbCommand result = Query(sql, parameters);
+
+                if (result.ExecuteNonQuery() == 1)
+                    returnval = true;
+
+                result.Dispose();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+                return false;
+            }
+
+            return returnval;
+        }
+       
+        /// <summary>
+        /// Execute a SQL statement stored in a resource, as a string
+        /// </summary>
+        /// <param name="name"></param>
+        public void ExecuteResourceSql(string name)
+        {
+            SqlCommand cmd = new SqlCommand(getResourceString(name), (SqlConnection)dbcon);
+            cmd.ExecuteNonQuery();
+            cmd.Dispose();
+        }
+
+        public SqlConnection getConnection()
+        {
+            return (SqlConnection)dbcon;
+        }
+
+        /// <summary>
+        /// Given a list of tables, return the version of the tables, as seen in the database
+        /// </summary>
+        /// <param name="tableList"></param>
+        public void GetTableVersion(Dictionary<string, string> tableList)
+        {
+            lock (dbcon)
+            {
+                Dictionary<string, string> param = new Dictionary<string, string>();
+                param["dbname"] = dbcon.Database;
+                IDbCommand tablesCmd =
+                    Query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_CATALOG=@dbname", param);
+                using (IDataReader tables = tablesCmd.ExecuteReader())
+                {
+                    while (tables.Read())
+                    {
+                        try
+                        {
+                            string tableName = (string)tables["TABLE_NAME"];
+                            if (tableList.ContainsKey(tableName))
+                                tableList[tableName] = tableName;
+                        }
+                        catch (Exception e)
+                        {
+                            m_log.Error(e.ToString());
+                        }
+                    }
+                    tables.Close();
+                }
+            }
+        }
+
+        private string getResourceString(string name)
+        {
+            Assembly assem = GetType().Assembly;
+            string[] names = assem.GetManifestResourceNames();
+
+            foreach (string s in names)
+                if (s.EndsWith(name))
+                    using (Stream resource = assem.GetManifestResourceStream(s))
+                    {
+                        using (StreamReader resourceReader = new StreamReader(resource))
+                        {
+                            string resourceString = resourceReader.ReadToEnd();
+                            return resourceString;
+                        }
+                    }
+            throw new Exception(string.Format("Resource '{0}' was not found", name));
+        }
+
+        /// <summary> 
+        /// Returns the version of this DB provider
+        /// </summary>
+        /// <returns>A string containing the DB provider</returns>
+        public string getVersion()
+        {
+            Module module = GetType().Module;
+            string dllName = module.Assembly.ManifestModule.Name;
+            Version dllVersion = module.Assembly.GetName().Version;
+
+
+            return
+                string.Format("{0}.{1}.{2}.{3}", dllVersion.Major, dllVersion.Minor, dllVersion.Build,
+                              dllVersion.Revision);
+        }
+    }
+}
diff --git a/OpenSim/Data/MSSQL/MSSQLUserData.cs b/OpenSim/Data/MSSQL/MSSQLUserData.cs
new file mode 100644
index 0000000..be0417d
--- /dev/null
+++ b/OpenSim/Data/MSSQL/MSSQLUserData.cs
@@ -0,0 +1,771 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using libsecondlife;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.MSSQL
+{
+    /// <summary>
+    /// A database interface class to a user profile storage system
+    /// </summary>
+    public class MSSQLUserData : UserDataBase
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Database manager for MySQL
+        /// </summary>
+        public MSSQLManager database;
+
+        private string m_agentsTableName;
+        private string m_usersTableName;
+        private string m_userFriendsTableName;
+
+        /// <summary>
+        /// Loads and initialises the MySQL storage plugin
+        /// </summary>
+        override public void Initialise()
+        {
+            // Load from an INI file connection details
+            // TODO: move this to XML?
+            IniFile iniFile = new IniFile("mssql_connection.ini");
+            string settingDataSource = iniFile.ParseFileReadValue("data_source");
+            string settingInitialCatalog = iniFile.ParseFileReadValue("initial_catalog");
+            string settingPersistSecurityInfo = iniFile.ParseFileReadValue("persist_security_info");
+            string settingUserId = iniFile.ParseFileReadValue("user_id");
+            string settingPassword = iniFile.ParseFileReadValue("password");
+
+            m_usersTableName = iniFile.ParseFileReadValue("userstablename");
+            if (m_usersTableName == null)
+            {
+                m_usersTableName = "users";
+            }
+
+            m_userFriendsTableName = iniFile.ParseFileReadValue("userfriendstablename");
+            if (m_userFriendsTableName == null)
+            {
+                m_userFriendsTableName = "userfriends";
+            }
+
+            m_agentsTableName = iniFile.ParseFileReadValue("agentstablename");
+            if (m_agentsTableName == null)
+            {
+                m_agentsTableName = "agents";
+            }
+
+            database =
+                new MSSQLManager(settingDataSource, settingInitialCatalog, settingPersistSecurityInfo, settingUserId,
+                                 settingPassword);
+
+            TestTables();
+        }
+
+        private bool TestTables()
+        {
+            IDbCommand cmd;
+
+            cmd = database.Query("select top 1 * from " + m_usersTableName, new Dictionary<string, string>());
+            try
+            {
+                cmd.ExecuteNonQuery();
+            }
+            catch
+            {
+                database.ExecuteResourceSql("Mssql-users.sql");
+            }
+       
+            cmd = database.Query("select top 1 * from " + m_agentsTableName, new Dictionary<string, string>());
+            try
+            {
+                cmd.ExecuteNonQuery();
+            }
+            catch
+            {
+                database.ExecuteResourceSql("Mssql-agents.sql");
+            }
+
+            cmd = database.Query("select top 1 * from " + m_userFriendsTableName, new Dictionary<string, string>());
+            try
+            {
+                cmd.ExecuteNonQuery();
+            }
+            catch
+            {
+                database.ExecuteResourceSql("CreateUserFriendsTable.sql");
+            }
+
+            return true;
+        }
+        /// <summary>
+        /// Searches the database for a specified user profile by name components
+        /// </summary>
+        /// <param name="user">The first part of the account name</param>
+        /// <param name="last">The second part of the account name</param>
+        /// <returns>A user profile</returns>
+        override public UserProfileData GetUserByName(string user, string last)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["first"] = user;
+                    param["second"] = last;
+
+                    IDbCommand result =
+                        database.Query("SELECT * FROM " + m_usersTableName + " WHERE username = @first AND lastname = @second", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    UserProfileData row = database.readUserRow(reader);
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return row;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        #region User Friends List Data
+
+        override public void AddNewUserFriend(LLUUID friendlistowner, LLUUID friend, uint perms)
+        {
+            int dtvalue = Util.UnixTimeSinceEpoch();
+
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["@ownerID"] = friendlistowner.UUID.ToString();
+            param["@friendID"] = friend.UUID.ToString();
+            param["@friendPerms"] = perms.ToString();
+            param["@datetimestamp"] = dtvalue.ToString();
+
+            try
+            {
+                lock (database)
+                {
+                    IDbCommand adder =
+                        database.Query(
+                        "INSERT INTO " + m_userFriendsTableName + " " +
+                        "(ownerID,friendID,friendPerms,datetimestamp) " +
+                        "VALUES " +
+                        "(@ownerID,@friendID,@friendPerms,@datetimestamp)",
+                            param);
+
+                    adder.ExecuteNonQuery();
+
+                    adder =
+                        database.Query(
+                        "INSERT INTO " + m_userFriendsTableName + " " +
+                        "(ownerID,friendID,friendPerms,datetimestamp) " +
+                        "VALUES " +
+                        "(@friendID,@ownerID,@friendPerms,@datetimestamp)",
+                            param);
+                    adder.ExecuteNonQuery();
+
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return;
+            }
+        }
+
+        override public void RemoveUserFriend(LLUUID friendlistowner, LLUUID friend)
+        {
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["@ownerID"] = friendlistowner.UUID.ToString();
+            param["@friendID"] = friend.UUID.ToString();
+
+
+            try
+            {
+                lock (database)
+                {
+                    IDbCommand updater =
+                        database.Query(
+                        "delete from " + m_userFriendsTableName + " where ownerID = @ownerID and friendID = @friendID",
+                            param);
+                    updater.ExecuteNonQuery();
+
+                    updater =
+                        database.Query(
+                        "delete from " + m_userFriendsTableName + " where ownerID = @friendID and friendID = @ownerID",
+                            param);
+                    updater.ExecuteNonQuery();
+
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return;
+            }
+        }
+
+        override public void UpdateUserFriendPerms(LLUUID friendlistowner, LLUUID friend, uint perms)
+        {
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["@ownerID"] = friendlistowner.UUID.ToString();
+            param["@friendID"] = friend.UUID.ToString();
+            param["@friendPerms"] = perms.ToString();
+
+
+            try
+            {
+                lock (database)
+                {
+                    IDbCommand updater =
+                        database.Query(
+                        "update " + m_userFriendsTableName +
+                        " SET friendPerms = @friendPerms " +
+                        "where ownerID = @ownerID and friendID = @friendID",
+                            param);
+
+                    updater.ExecuteNonQuery();
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return;
+            }
+        }
+
+
+        override public List<FriendListItem> GetUserFriendList(LLUUID friendlistowner)
+        {
+            List<FriendListItem> Lfli = new List<FriendListItem>();
+
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["@ownerID"] = friendlistowner.UUID.ToString();
+
+            try
+            {
+                lock (database)
+                {
+                    //Left Join userfriends to itself
+                    IDbCommand result =
+                        database.Query(
+                        "select a.ownerID,a.friendID,a.friendPerms,b.friendPerms as ownerperms from " + m_userFriendsTableName + " as a, " + m_userFriendsTableName + " as b" +
+                        " where a.ownerID = @ownerID and b.ownerID = a.friendID and b.friendID = a.ownerID",
+                            param);
+                    IDataReader reader = result.ExecuteReader();
+
+
+                    while (reader.Read())
+                    {
+                        FriendListItem fli = new FriendListItem();
+                        fli.FriendListOwner = new LLUUID((string)reader["ownerID"]);
+                        fli.Friend = new LLUUID((string)reader["friendID"]);
+                        fli.FriendPerms = (uint)Convert.ToInt32(reader["friendPerms"]);
+
+                        // This is not a real column in the database table, it's a joined column from the opposite record
+                        fli.FriendListOwnerPerms = (uint)Convert.ToInt32(reader["ownerperms"]);
+
+                        Lfli.Add(fli);
+                    }
+                    reader.Close();
+                    result.Dispose();
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return Lfli;
+            }
+
+            return Lfli;
+        }
+
+        #endregion
+
+        override public void UpdateUserCurrentRegion(LLUUID avatarid, LLUUID regionuuid)
+        {
+            m_log.Info("[USER]: Stub UpdateUserCUrrentRegion called");
+        }
+
+
+
+        override public List<Framework.AvatarPickerAvatar> GeneratePickerResults(LLUUID queryID, string query)
+        {
+            List<Framework.AvatarPickerAvatar> returnlist = new List<Framework.AvatarPickerAvatar>();
+            string[] querysplit;
+            querysplit = query.Split(' ');
+            if (querysplit.Length == 2)
+            {
+                try
+                {
+                    lock (database)
+                    {
+                        Dictionary<string, string> param = new Dictionary<string, string>();
+                        param["first"] = querysplit[0];
+                        param["second"] = querysplit[1];
+
+                        IDbCommand result =
+                            database.Query(
+                                "SELECT UUID,username,lastname FROM " + m_usersTableName + " WHERE username = @first AND lastname = @second",
+                                param);
+                        IDataReader reader = result.ExecuteReader();
+
+
+                        while (reader.Read())
+                        {
+                            Framework.AvatarPickerAvatar user = new Framework.AvatarPickerAvatar();
+                            user.AvatarID = new LLUUID((string)reader["UUID"]);
+                            user.firstName = (string)reader["username"];
+                            user.lastName = (string)reader["lastname"];
+                            returnlist.Add(user);
+                        }
+                        reader.Close();
+                        result.Dispose();
+                    }
+                }
+                catch (Exception e)
+                {
+                    database.Reconnect();
+                    m_log.Error(e.ToString());
+                    return returnlist;
+                }
+            }
+            else if (querysplit.Length == 1)
+            {
+                try
+                {
+                    lock (database)
+                    {
+                        Dictionary<string, string> param = new Dictionary<string, string>();
+                        param["first"] = querysplit[0];
+
+                        IDbCommand result =
+                            database.Query(
+                                "SELECT UUID,username,lastname FROM " + m_usersTableName + " WHERE username = @first OR lastname = @first",
+                                param);
+                        IDataReader reader = result.ExecuteReader();
+
+
+                        while (reader.Read())
+                        {
+                            Framework.AvatarPickerAvatar user = new Framework.AvatarPickerAvatar();
+                            user.AvatarID = new LLUUID((string)reader["UUID"]);
+                            user.firstName = (string)reader["username"];
+                            user.lastName = (string)reader["lastname"];
+                            returnlist.Add(user);
+                        }
+                        reader.Close();
+                        result.Dispose();
+                    }
+                }
+                catch (Exception e)
+                {
+                    database.Reconnect();
+                    m_log.Error(e.ToString());
+                    return returnlist;
+                }
+            }
+            return returnlist;
+        }
+
+        // See IUserData
+        override public UserProfileData GetUserByUUID(LLUUID uuid)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["uuid"] = uuid.ToString();
+
+                    IDbCommand result = database.Query("SELECT * FROM " + m_usersTableName + " WHERE UUID = @uuid", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    UserProfileData row = database.readUserRow(reader);
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return row;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a user session searching by name
+        /// </summary>
+        /// <param name="name">The account name</param>
+        /// <returns>The users session</returns>
+        override public UserAgentData GetAgentByName(string name)
+        {
+            return GetAgentByName(name.Split(' ')[0], name.Split(' ')[1]);
+        }
+
+        /// <summary>
+        /// Returns a user session by account name
+        /// </summary>
+        /// <param name="user">First part of the users account name</param>
+        /// <param name="last">Second part of the users account name</param>
+        /// <returns>The users session</returns>
+        override public UserAgentData GetAgentByName(string user, string last)
+        {
+            UserProfileData profile = GetUserByName(user, last);
+            return GetAgentByUUID(profile.UUID);
+        }
+
+        /// <summary>
+        /// Returns an agent session by account UUID
+        /// </summary>
+        /// <param name="uuid">The accounts UUID</param>
+        /// <returns>The users session</returns>
+        override public UserAgentData GetAgentByUUID(LLUUID uuid)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["uuid"] = uuid.ToString();
+
+                    IDbCommand result = database.Query("SELECT * FROM " + m_agentsTableName + " WHERE UUID = @uuid", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    UserAgentData row = database.readAgentRow(reader);
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return row;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+        override public void StoreWebLoginKey(LLUUID AgentID, LLUUID WebLoginKey)
+        {
+            UserProfileData user = GetUserByUUID(AgentID);
+            user.webLoginKey = WebLoginKey;
+            UpdateUserProfile(user);
+
+        }
+        /// <summary>
+        /// Creates a new users profile
+        /// </summary>
+        /// <param name="user">The user profile to create</param>
+        override public void AddNewUserProfile(UserProfileData user)
+        {
+            try
+            {
+                lock (database)
+                {
+                    InsertUserRow(user.UUID, user.username, user.surname, user.passwordHash, user.passwordSalt,
+                                           user.homeRegion, user.homeLocation.X, user.homeLocation.Y,
+                                           user.homeLocation.Z,
+                                           user.homeLookAt.X, user.homeLookAt.Y, user.homeLookAt.Z, user.created,
+                                           user.lastLogin, user.userInventoryURI, user.userAssetURI,
+                                           user.profileCanDoMask, user.profileWantDoMask,
+                                           user.profileAboutText, user.profileFirstText, user.profileImage,
+                                           user.profileFirstImage, user.webLoginKey);
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Creates a new user and inserts it into the database
+        /// </summary>
+        /// <param name="uuid">User ID</param>
+        /// <param name="username">First part of the login</param>
+        /// <param name="lastname">Second part of the login</param>
+        /// <param name="passwordHash">A salted hash of the users password</param>
+        /// <param name="passwordSalt">The salt used for the password hash</param>
+        /// <param name="homeRegion">A regionHandle of the users home region</param>
+        /// <param name="homeLocX">Home region position vector</param>
+        /// <param name="homeLocY">Home region position vector</param>
+        /// <param name="homeLocZ">Home region position vector</param>
+        /// <param name="homeLookAtX">Home region 'look at' vector</param>
+        /// <param name="homeLookAtY">Home region 'look at' vector</param>
+        /// <param name="homeLookAtZ">Home region 'look at' vector</param>
+        /// <param name="created">Account created (unix timestamp)</param>
+        /// <param name="lastlogin">Last login (unix timestamp)</param>
+        /// <param name="inventoryURI">Users inventory URI</param>
+        /// <param name="assetURI">Users asset URI</param>
+        /// <param name="canDoMask">I can do mask</param>
+        /// <param name="wantDoMask">I want to do mask</param>
+        /// <param name="aboutText">Profile text</param>
+        /// <param name="firstText">Firstlife text</param>
+        /// <param name="profileImage">UUID for profile image</param>
+        /// <param name="firstImage">UUID for firstlife image</param>
+        /// <returns>Success?</returns>
+        private bool InsertUserRow(LLUUID uuid, string username, string lastname, string passwordHash,
+                                  string passwordSalt, UInt64 homeRegion, float homeLocX, float homeLocY, float homeLocZ,
+                                  float homeLookAtX, float homeLookAtY, float homeLookAtZ, int created, int lastlogin,
+                                  string inventoryURI, string assetURI, uint canDoMask, uint wantDoMask,
+                                  string aboutText, string firstText,
+                                  LLUUID profileImage, LLUUID firstImage, LLUUID webLoginKey)
+        {
+            string sql = "INSERT INTO "+m_usersTableName;
+            sql += " ([UUID], [username], [lastname], [passwordHash], [passwordSalt], [homeRegion], ";
+            sql +=
+                "[homeLocationX], [homeLocationY], [homeLocationZ], [homeLookAtX], [homeLookAtY], [homeLookAtZ], [created], ";
+            sql +=
+                "[lastLogin], [userInventoryURI], [userAssetURI], [profileCanDoMask], [profileWantDoMask], [profileAboutText], ";
+            sql += "[profileFirstText], [profileImage], [profileFirstImage], [webLoginKey]) VALUES ";
+
+            sql += "(@UUID, @username, @lastname, @passwordHash, @passwordSalt, @homeRegion, ";
+            sql +=
+                "@homeLocationX, @homeLocationY, @homeLocationZ, @homeLookAtX, @homeLookAtY, @homeLookAtZ, @created, ";
+            sql +=
+                "@lastLogin, @userInventoryURI, @userAssetURI, @profileCanDoMask, @profileWantDoMask, @profileAboutText, ";
+            sql += "@profileFirstText, @profileImage, @profileFirstImage, @webLoginKey);";
+
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+            parameters["UUID"] = uuid.ToString();
+            parameters["username"] = username.ToString();
+            parameters["lastname"] = lastname.ToString();
+            parameters["passwordHash"] = passwordHash.ToString();
+            parameters["passwordSalt"] = passwordSalt.ToString();
+            parameters["homeRegion"] = homeRegion.ToString();
+            parameters["homeLocationX"] = homeLocX.ToString();
+            parameters["homeLocationY"] = homeLocY.ToString();
+            parameters["homeLocationZ"] = homeLocZ.ToString();
+            parameters["homeLookAtX"] = homeLookAtX.ToString();
+            parameters["homeLookAtY"] = homeLookAtY.ToString();
+            parameters["homeLookAtZ"] = homeLookAtZ.ToString();
+            parameters["created"] = created.ToString();
+            parameters["lastLogin"] = lastlogin.ToString();
+            parameters["userInventoryURI"] = String.Empty;
+            parameters["userAssetURI"] = String.Empty;
+            parameters["profileCanDoMask"] = "0";
+            parameters["profileWantDoMask"] = "0";
+            parameters["profileAboutText"] = aboutText;
+            parameters["profileFirstText"] = firstText;
+            parameters["profileImage"] = profileImage.ToString();
+            parameters["profileFirstImage"] = firstImage.ToString();
+            parameters["webLoginKey"] = LLUUID.Random().ToString();
+
+            bool returnval = false;
+
+            try
+            {
+                IDbCommand result = database.Query(sql, parameters);
+
+                if (result.ExecuteNonQuery() == 1)
+                    returnval = true;
+
+                result.Dispose();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+                return false;
+            }
+
+            return returnval;
+        }
+
+        /// <summary>
+        /// Creates a new agent
+        /// </summary>
+        /// <param name="agent">The agent to create</param>
+        override public void AddNewUserAgent(UserAgentData agent)
+        {
+            // Do nothing.
+        }
+
+
+        override public bool UpdateUserProfile(UserProfileData user)
+        {
+            SqlCommand command = new SqlCommand("UPDATE " + m_usersTableName + " set UUID = @uuid, " +
+                                                "username = @username, " +
+                                                "lastname = @lastname," +
+                                                "passwordHash = @passwordHash," +
+                                                "passwordSalt = @passwordSalt," +
+                                                "homeRegion = @homeRegion," +
+                                                "homeLocationX = @homeLocationX," +
+                                                "homeLocationY = @homeLocationY," +
+                                                "homeLocationZ = @homeLocationZ," +
+                                                "homeLookAtX = @homeLookAtX," +
+                                                "homeLookAtY = @homeLookAtY," +
+                                                "homeLookAtZ = @homeLookAtZ," +
+                                                "created = @created," +
+                                                "lastLogin = @lastLogin," +
+                                                "userInventoryURI = @userInventoryURI," +
+                                                "userAssetURI = @userAssetURI," +
+                                                "profileCanDoMask = @profileCanDoMask," +
+                                                "profileWantDoMask = @profileWantDoMask," +
+                                                "profileAboutText = @profileAboutText," +
+                                                "profileFirstText = @profileFirstText," +
+                                                "profileImage = @profileImage," +
+                                                "profileFirstImage = @profileFirstImage, " +
+                                                "webLoginKey = @webLoginKey  where " +
+                                                "UUID = @keyUUUID;", database.getConnection());
+            SqlParameter param1 = new SqlParameter("@uuid", user.UUID.ToString());
+            SqlParameter param2 = new SqlParameter("@username", user.username);
+            SqlParameter param3 = new SqlParameter("@lastname", user.surname);
+            SqlParameter param4 = new SqlParameter("@passwordHash", user.passwordHash);
+            SqlParameter param5 = new SqlParameter("@passwordSalt", user.passwordSalt);
+            SqlParameter param6 = new SqlParameter("@homeRegion", Convert.ToInt64(user.homeRegion));
+            SqlParameter param7 = new SqlParameter("@homeLocationX", user.homeLocation.X);
+            SqlParameter param8 = new SqlParameter("@homeLocationY", user.homeLocation.Y);
+            SqlParameter param9 = new SqlParameter("@homeLocationZ", user.homeLocation.Y);
+            SqlParameter param10 = new SqlParameter("@homeLookAtX", user.homeLookAt.X);
+            SqlParameter param11 = new SqlParameter("@homeLookAtY", user.homeLookAt.Y);
+            SqlParameter param12 = new SqlParameter("@homeLookAtZ", user.homeLookAt.Z);
+            SqlParameter param13 = new SqlParameter("@created", Convert.ToInt32(user.created));
+            SqlParameter param14 = new SqlParameter("@lastLogin", Convert.ToInt32(user.lastLogin));
+            SqlParameter param15 = new SqlParameter("@userInventoryURI", user.userInventoryURI);
+            SqlParameter param16 = new SqlParameter("@userAssetURI", user.userAssetURI);
+            SqlParameter param17 = new SqlParameter("@profileCanDoMask", Convert.ToInt32(user.profileCanDoMask));
+            SqlParameter param18 = new SqlParameter("@profileWantDoMask", Convert.ToInt32(user.profileWantDoMask));
+            SqlParameter param19 = new SqlParameter("@profileAboutText", user.profileAboutText);
+            SqlParameter param20 = new SqlParameter("@profileFirstText", user.profileFirstText);
+            SqlParameter param21 = new SqlParameter("@profileImage", user.profileImage.ToString());
+            SqlParameter param22 = new SqlParameter("@profileFirstImage", user.profileFirstImage.ToString());
+            SqlParameter param23 = new SqlParameter("@keyUUUID", user.UUID.ToString());
+            SqlParameter param24 = new SqlParameter("@webLoginKey", user.webLoginKey.UUID.ToString());
+            command.Parameters.Add(param1);
+            command.Parameters.Add(param2);
+            command.Parameters.Add(param3);
+            command.Parameters.Add(param4);
+            command.Parameters.Add(param5);
+            command.Parameters.Add(param6);
+            command.Parameters.Add(param7);
+            command.Parameters.Add(param8);
+            command.Parameters.Add(param9);
+            command.Parameters.Add(param10);
+            command.Parameters.Add(param11);
+            command.Parameters.Add(param12);
+            command.Parameters.Add(param13);
+            command.Parameters.Add(param14);
+            command.Parameters.Add(param15);
+            command.Parameters.Add(param16);
+            command.Parameters.Add(param17);
+            command.Parameters.Add(param18);
+            command.Parameters.Add(param19);
+            command.Parameters.Add(param20);
+            command.Parameters.Add(param21);
+            command.Parameters.Add(param22);
+            command.Parameters.Add(param23);
+            command.Parameters.Add(param24);
+            try
+            {
+                int affected = command.ExecuteNonQuery();
+                if (affected != 0)
+                {
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Performs a money transfer request between two accounts
+        /// </summary>
+        /// <param name="from">The senders account ID</param>
+        /// <param name="to">The receivers account ID</param>
+        /// <param name="amount">The amount to transfer</param>
+        /// <returns>Success?</returns>
+        override public bool MoneyTransferRequest(LLUUID from, LLUUID to, uint amount)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Performs an inventory transfer request between two accounts
+        /// </summary>
+        /// <remarks>TODO: Move to inventory server</remarks>
+        /// <param name="from">The senders account ID</param>
+        /// <param name="to">The receivers account ID</param>
+        /// <param name="item">The item to transfer</param>
+        /// <returns>Success?</returns>
+        override public bool InventoryTransferRequest(LLUUID from, LLUUID to, LLUUID item)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Database provider name
+        /// </summary>
+        /// <returns>Provider name</returns>
+        override public string getName()
+        {
+            return "MSSQL Userdata Interface";
+        }
+
+        /// <summary>
+        /// Database provider version
+        /// </summary>
+        /// <returns>provider version</returns>
+        override public string GetVersion()
+        {
+            return database.getVersion();
+        }
+
+        /// <summary>
+        /// Not implemented
+        /// </summary>
+        /// <param name="query"></param>
+        public void runQuery(string query)
+        {
+        }
+    }
+}
diff --git a/OpenSim/Data/MSSQL/Properties/AssemblyInfo.cs b/OpenSim/Data/MSSQL/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..f6ac328
--- /dev/null
+++ b/OpenSim/Data/MSSQL/Properties/AssemblyInfo.cs
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly : AssemblyTitle("OpenSim.Framework.Data.MSSQL")]
+[assembly : AssemblyDescription("")]
+[assembly : AssemblyConfiguration("")]
+[assembly : AssemblyCompany("")]
+[assembly : AssemblyProduct("OpenSim.Framework.Data.MSSQL")]
+[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2008")]
+[assembly : AssemblyTrademark("")]
+[assembly : AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+
+[assembly : ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+
+[assembly : Guid("0e1c1ca4-2cf2-4315-b0e7-432c02feea8a")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly : AssemblyVersion("1.0.0.0")]
+[assembly : AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Data/MSSQL/Resources/AvatarAppearance.sql b/OpenSim/Data/MSSQL/Resources/AvatarAppearance.sql
new file mode 100644
index 0000000..ccefba2
--- /dev/null
+++ b/OpenSim/Data/MSSQL/Resources/AvatarAppearance.sql
@@ -0,0 +1,44 @@
+--

+-- Create schema avatar_appearance

+--

+

+SET ANSI_NULLS ON

+SET QUOTED_IDENTIFIER ON

+SET ANSI_PADDING ON

+

+CREATE TABLE [avatarappearance]  (

+  [UUID]  uniqueidentifier NOT NULL,

+  [Serial]  int NOT NULL,

+  [WearableItem0]  uniqueidentifier NOT NULL,

+  [WearableAsset0]  uniqueidentifier NOT NULL,

+  [WearableItem1]  uniqueidentifier NOT NULL,

+  [WearableAsset1]  uniqueidentifier NOT NULL,

+  [WearableItem2]  uniqueidentifier NOT NULL,

+  [WearableAsset2]  uniqueidentifier NOT NULL,

+  [WearableItem3]  uniqueidentifier NOT NULL,

+  [WearableAsset3]  uniqueidentifier NOT NULL,

+  [WearableItem4]  uniqueidentifier NOT NULL,

+  [WearableAsset4]  uniqueidentifier NOT NULL,

+  [WearableItem5]  uniqueidentifier NOT NULL,

+  [WearableAsset5]  uniqueidentifier NOT NULL,

+  [WearableItem6]  uniqueidentifier NOT NULL,

+  [WearableAsset6]  uniqueidentifier NOT NULL,

+  [WearableItem7]  uniqueidentifier NOT NULL,

+  [WearableAsset7]  uniqueidentifier NOT NULL,

+  [WearableItem8]  uniqueidentifier NOT NULL,

+  [WearableAsset8]  uniqueidentifier NOT NULL,

+  [WearableItem9]  uniqueidentifier NOT NULL,

+  [WearableAsset9]  uniqueidentifier NOT NULL,

+  [WearableItem10]  uniqueidentifier NOT NULL,

+  [WearableAsset10]  uniqueidentifier NOT NULL,

+  [WearableItem11]  uniqueidentifier NOT NULL,

+  [WearableAsset11]  uniqueidentifier NOT NULL,

+  [WearableItem12]  uniqueidentifier NOT NULL,

+  [WearableAsset12]  uniqueidentifier NOT NULL

+

+  PRIMARY KEY  CLUSTERED (

+  [UUID]

+  ) WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]

+) ON [PRIMARY]

+

+SET ANSI_PADDING OFF

diff --git a/OpenSim/Data/MSSQL/Resources/CreateAssetsTable.sql b/OpenSim/Data/MSSQL/Resources/CreateAssetsTable.sql
new file mode 100644
index 0000000..c7cb21a
--- /dev/null
+++ b/OpenSim/Data/MSSQL/Resources/CreateAssetsTable.sql
@@ -0,0 +1,19 @@
+SET ANSI_NULLS ON
+SET QUOTED_IDENTIFIER ON
+SET ANSI_PADDING ON
+CREATE TABLE [assets] (
+  [id] [varchar](36) NOT NULL,
+  [name] [varchar](64) NOT NULL,
+  [description] [varchar](64) NOT NULL,
+  [assetType] [tinyint] NOT NULL,
+  [invType] [tinyint] NOT NULL,
+  [local] [tinyint] NOT NULL,
+  [temporary] [tinyint] NOT NULL,
+  [data] [image] NOT NULL,
+PRIMARY KEY CLUSTERED 
+(
+        [id] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+) ON [PRIMARY]
+
+SET ANSI_PADDING OFF
diff --git a/OpenSim/Data/MSSQL/Resources/CreateFoldersTable.sql b/OpenSim/Data/MSSQL/Resources/CreateFoldersTable.sql
new file mode 100644
index 0000000..95d183a
--- /dev/null
+++ b/OpenSim/Data/MSSQL/Resources/CreateFoldersTable.sql
@@ -0,0 +1,27 @@
+SET ANSI_NULLS ON
+SET QUOTED_IDENTIFIER ON
+SET ANSI_PADDING ON
+CREATE TABLE [inventoryfolders] (
+  [folderID] [varchar](36) NOT NULL default '',
+  [agentID] [varchar](36) default NULL,
+  [parentFolderID] [varchar](36) default NULL,
+  [folderName] [varchar](64) default NULL,
+  [type] [smallint] NOT NULL default 0,
+  [version] [int] NOT NULL default 0,  
+  PRIMARY KEY CLUSTERED
+(
+        [folderID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+) ON [PRIMARY]
+
+CREATE NONCLUSTERED INDEX [owner] ON [inventoryfolders]
+(
+        [agentID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+
+CREATE NONCLUSTERED INDEX [parent] ON [inventoryfolders]
+(
+        [parentFolderID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+
+SET ANSI_PADDING OFF
diff --git a/OpenSim/Data/MSSQL/Resources/CreateItemsTable.sql b/OpenSim/Data/MSSQL/Resources/CreateItemsTable.sql
new file mode 100644
index 0000000..5bb27ba
--- /dev/null
+++ b/OpenSim/Data/MSSQL/Resources/CreateItemsTable.sql
@@ -0,0 +1,39 @@
+SET ANSI_NULLS ON
+
+SET QUOTED_IDENTIFIER ON
+
+SET ANSI_PADDING ON
+
+CREATE TABLE [inventoryitems] (
+  [inventoryID] [varchar](36) NOT NULL default '',
+  [assetID] [varchar](36) default NULL,
+  [assetType] [int] default NULL,
+  [parentFolderID] [varchar](36) default NULL,
+  [avatarID] [varchar](36) default NULL,
+  [inventoryName] [varchar](64) default NULL,
+  [inventoryDescription] [varchar](128) default NULL,
+  [inventoryNextPermissions] [int] default NULL,
+  [inventoryCurrentPermissions] [int] default NULL,
+  [invType] [int] default NULL,
+  [creatorID] [varchar](36) default NULL,
+  [inventoryBasePermissions] [int] NOT NULL default 0,
+  [inventoryEveryOnePermissions] [int] NOT NULL default 0, 
+  PRIMARY KEY CLUSTERED
+(
+        [inventoryID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+) ON [PRIMARY]
+
+
+CREATE NONCLUSTERED INDEX [owner] ON [inventoryitems]
+(
+        [avatarID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+
+CREATE NONCLUSTERED INDEX [folder] ON [inventoryitems]
+(
+        [parentFolderID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+
+SET ANSI_PADDING OFF
+
diff --git a/OpenSim/Data/MSSQL/Resources/CreateUserFriendsTable.sql b/OpenSim/Data/MSSQL/Resources/CreateUserFriendsTable.sql
new file mode 100644
index 0000000..6f5885e
--- /dev/null
+++ b/OpenSim/Data/MSSQL/Resources/CreateUserFriendsTable.sql
@@ -0,0 +1,14 @@
+SET ANSI_NULLS ON
+
+SET QUOTED_IDENTIFIER ON
+
+SET ANSI_PADDING ON
+
+CREATE TABLE [dbo].[userfriends](
+[ownerID] [varchar](50) COLLATE Latin1_General_CI_AS NOT NULL,
+[friendID] [varchar](50) COLLATE Latin1_General_CI_AS NOT NULL,
+[friendPerms] [nvarchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,
+[datetimestamp] [nvarchar](50) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL
+) ON [PRIMARY]
+
+SET ANSI_PADDING OFF
diff --git a/OpenSim/Data/MSSQL/Resources/Mssql-agents.sql b/OpenSim/Data/MSSQL/Resources/Mssql-agents.sql
new file mode 100644
index 0000000..ad53173
--- /dev/null
+++ b/OpenSim/Data/MSSQL/Resources/Mssql-agents.sql
@@ -0,0 +1,37 @@
+SET ANSI_NULLS ON
+
+SET QUOTED_IDENTIFIER ON
+
+SET ANSI_PADDING ON
+
+CREATE TABLE [agents] (
+  [UUID] [varchar](36) NOT NULL,
+  [sessionID] [varchar](36) NOT NULL,
+  [secureSessionID] [varchar](36) NOT NULL,
+  [agentIP] [varchar](16) NOT NULL,
+  [agentPort] [int] NOT NULL,
+  [agentOnline] [tinyint] NOT NULL,
+  [loginTime] [int] NOT NULL,
+  [logoutTime] [int] NOT NULL,
+  [currentRegion] [varchar](36) NOT NULL,
+  [currentHandle] [bigint] NOT NULL,
+  [currentPos] [varchar](64) NOT NULL,
+  PRIMARY KEY CLUSTERED
+(
+        [UUID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+) ON [PRIMARY]
+
+
+CREATE NONCLUSTERED INDEX [session] ON [agents]
+(
+        [sessionID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+
+CREATE NONCLUSTERED INDEX [ssession] ON [agents]
+(
+        [secureSessionID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+
+SET ANSI_PADDING OFF
+
diff --git a/OpenSim/Data/MSSQL/Resources/Mssql-logs.sql b/OpenSim/Data/MSSQL/Resources/Mssql-logs.sql
new file mode 100644
index 0000000..3b747d8
--- /dev/null
+++ b/OpenSim/Data/MSSQL/Resources/Mssql-logs.sql
@@ -0,0 +1,20 @@
+SET ANSI_NULLS ON
+
+SET QUOTED_IDENTIFIER ON
+
+SET ANSI_PADDING ON
+
+CREATE TABLE [logs] (
+  [logID] [int] NOT NULL,
+  [target] [varchar](36) default NULL,
+  [server] [varchar](64) default NULL,
+  [method] [varchar](64) default NULL,
+  [arguments] [varchar](255) default NULL,
+  [priority] [int] default NULL,
+  [message] [ntext],
+  PRIMARY KEY CLUSTERED
+(
+        [logID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+) ON [PRIMARY]
+
diff --git a/OpenSim/Data/MSSQL/Resources/Mssql-regions.sql b/OpenSim/Data/MSSQL/Resources/Mssql-regions.sql
new file mode 100644
index 0000000..b29a2ab
--- /dev/null
+++ b/OpenSim/Data/MSSQL/Resources/Mssql-regions.sql
@@ -0,0 +1,41 @@
+SET ANSI_NULLS ON
+
+SET QUOTED_IDENTIFIER ON
+
+SET ANSI_PADDING ON
+
+CREATE TABLE [dbo].[regions](
+ [regionHandle] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionName] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [uuid] [varchar](255) COLLATE Latin1_General_CI_AS NOT NULL,
+ [regionRecvKey] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionSecret] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionSendKey] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionDataURI] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [serverIP] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [serverPort] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [serverURI] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [locX] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [locY] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [locZ] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [eastOverrideHandle] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [westOverrideHandle] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [southOverrideHandle] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [northOverrideHandle] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionAssetURI] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionAssetRecvKey] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionAssetSendKey] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionUserURI] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionUserRecvKey] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionUserSendKey] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [regionMapTexture] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [serverHttpPort] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [serverRemotingPort] [varchar](255) COLLATE Latin1_General_CI_AS NULL,
+ [owner_uuid] [varchar](36) COLLATE Latin1_General_CI_AS NULL,
+PRIMARY KEY CLUSTERED 
+(
+ [uuid] ASC
+)WITH (PAD_INDEX  = OFF, IGNORE_DUP_KEY = OFF) ON [PRIMARY]
+) ON [PRIMARY]
+
+SET ANSI_PADDING OFF
diff --git a/OpenSim/Data/MSSQL/Resources/Mssql-users.sql b/OpenSim/Data/MSSQL/Resources/Mssql-users.sql
new file mode 100644
index 0000000..abcc091
--- /dev/null
+++ b/OpenSim/Data/MSSQL/Resources/Mssql-users.sql
@@ -0,0 +1,42 @@
+SET ANSI_NULLS ON
+
+SET QUOTED_IDENTIFIER ON
+
+SET ANSI_PADDING ON
+
+CREATE TABLE [users] (
+  [UUID] [varchar](36) NOT NULL default '',
+  [username] [varchar](32) NOT NULL,
+  [lastname] [varchar](32) NOT NULL,
+  [passwordHash] [varchar](32) NOT NULL,
+  [passwordSalt] [varchar](32) NOT NULL,
+  [homeRegion] [bigint] default NULL,
+  [homeLocationX] [float] default NULL,
+  [homeLocationY] [float] default NULL,
+  [homeLocationZ] [float] default NULL,
+  [homeLookAtX] [float] default NULL,
+  [homeLookAtY] [float] default NULL,
+  [homeLookAtZ] [float] default NULL,
+  [created] [int] NOT NULL,
+  [lastLogin] [int] NOT NULL,
+  [userInventoryURI] [varchar](255) default NULL,
+  [userAssetURI] [varchar](255) default NULL,
+  [profileCanDoMask] [int] default NULL,
+  [profileWantDoMask] [int] default NULL,
+  [profileAboutText] [ntext],
+  [profileFirstText] [ntext],
+  [profileImage] [varchar](36) default NULL,
+  [profileFirstImage] [varchar](36) default NULL,
+  [webLoginKey] [varchar](36) default NULL,
+  PRIMARY KEY CLUSTERED
+(
+        [UUID] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
+) ON [PRIMARY]
+
+
+CREATE NONCLUSTERED INDEX [usernames] ON [users]
+(
+        [username] ASC,
+        [lastname] ASC
+)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, SORT_IN_TEMPDB = OFF, IGNORE_DUP_KEY = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
diff --git a/OpenSim/Data/MSSQLMapper/MSSQLDatabaseMapper.cs b/OpenSim/Data/MSSQLMapper/MSSQLDatabaseMapper.cs
new file mode 100644
index 0000000..81f9631
--- /dev/null
+++ b/OpenSim/Data/MSSQLMapper/MSSQLDatabaseMapper.cs
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Data.Common;
+using System.Data.SqlClient;
+using OpenSim.Framework.Data;
+
+namespace OpenSim.Framework.Data.MSSQLMapper
+{
+    public class MSSQLDatabaseMapper : OpenSimDatabaseConnector
+    {
+        public MSSQLDatabaseMapper(string connectionString)
+            : base(connectionString)
+        {
+        }
+
+        public override DbConnection GetNewConnection()
+        {
+            SqlConnection connection = new SqlConnection(m_connectionString);
+            return connection;
+        }
+
+        public override object ConvertToDbType(object value)
+        {
+            if( value is UInt32 )
+            {
+                UInt32 tmpVal = (UInt32) value;
+                Int64 result = Convert.ToInt64(tmpVal);
+                return result;
+            }
+
+            return base.ConvertToDbType(value);
+        }
+
+        public override string CreateParamName(string fieldName)
+        {
+            return "@" + fieldName;
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Data/MapperFactory/DataMapperFactory.cs b/OpenSim/Data/MapperFactory/DataMapperFactory.cs
new file mode 100644
index 0000000..8995b9e
--- /dev/null
+++ b/OpenSim/Data/MapperFactory/DataMapperFactory.cs
@@ -0,0 +1,27 @@
+using System;
+using OpenSim.Framework.Data.Base;
+using OpenSim.Framework.Data.MSSQLMapper;
+using OpenSim.Framework.Data.MySQLMapper;
+
+namespace OpenSim.Framework.Data.MapperFactory
+{
+    public class DataMapperFactory
+    {
+        public enum MAPPER_TYPE {
+            MySQL,
+            MSSQL,
+        };
+
+        static public BaseDatabaseConnector GetDataBaseMapper(MAPPER_TYPE type, string connectionString)
+        {
+            switch (type) {
+                case MAPPER_TYPE.MySQL:
+                    return new MySQLDatabaseMapper(connectionString);
+                case MAPPER_TYPE.MSSQL:
+                    return new MSSQLDatabaseMapper(connectionString);
+                default:
+                    throw new ArgumentException("Unknown Database Mapper type [" + type + "].");
+            }            
+        }
+    }
+}
diff --git a/OpenSim/Data/MySQL/MySQLAssetData.cs b/OpenSim/Data/MySQL/MySQLAssetData.cs
new file mode 100644
index 0000000..79994ae
--- /dev/null
+++ b/OpenSim/Data/MySQL/MySQLAssetData.cs
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using libsecondlife;
+using MySql.Data.MySqlClient;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.MySQL
+{
+    internal class MySQLAssetData : AssetDataBase, IPlugin
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        private MySQLManager _dbConnection;
+
+        #region IAssetProvider Members
+
+        private void UpgradeAssetsTable(string oldVersion)
+        {
+            // null as the version, indicates that the table didn't exist
+            if (oldVersion == null)
+            {
+                m_log.Info("[ASSETS]: Creating new database tables");
+                _dbConnection.ExecuteResourceSql("CreateAssetsTable.sql");
+                return;
+            }
+        }
+
+        /// <summary>
+        /// Ensure that the assets related tables exists and are at the latest version
+        /// </summary>
+        private void TestTables()
+        {
+            Dictionary<string, string> tableList = new Dictionary<string, string>();
+
+            tableList["assets"] = null;
+            _dbConnection.GetTableVersion(tableList);
+
+            UpgradeAssetsTable(tableList["assets"]);
+        }
+
+        override public AssetBase FetchAsset(LLUUID assetID)
+        {
+            AssetBase asset = null;
+            lock (_dbConnection)
+            {
+                MySqlCommand cmd =
+                    new MySqlCommand(
+                        "SELECT name, description, assetType, invType, local, temporary, data FROM assets WHERE id=?id",
+                        _dbConnection.Connection);
+                MySqlParameter p = cmd.Parameters.Add("?id", MySqlDbType.Binary, 16);
+                p.Value = assetID.GetBytes();
+                
+                try
+                {
+                    using (MySqlDataReader dbReader = cmd.ExecuteReader(CommandBehavior.SingleRow))
+                    {
+                        if (dbReader.Read())
+                        {
+                            asset = new AssetBase();
+                            asset.Data = (byte[]) dbReader["data"];
+                            asset.Description = (string) dbReader["description"];
+                            asset.FullID = assetID;
+                            asset.InvType = (sbyte) dbReader["invType"];
+                            asset.Local = ((sbyte) dbReader["local"]) != 0 ? true : false;
+                            asset.Name = (string) dbReader["name"];
+                            asset.Type = (sbyte) dbReader["assetType"];
+                        }
+                        dbReader.Close();
+                        cmd.Dispose();
+                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat(
+                        "[ASSETS]: MySql failure fetching asset {0}" + Environment.NewLine + e.ToString()
+                        + Environment.NewLine + "Attempting reconnection", assetID);
+                    _dbConnection.Reconnect();
+                }
+            }
+            return asset;
+        }
+
+        override public void CreateAsset(AssetBase asset)
+        {            
+            lock (_dbConnection)
+            {
+                MySqlCommand cmd =
+                    new MySqlCommand(
+                        "REPLACE INTO assets(id, name, description, assetType, invType, local, temporary, data)" +
+                        "VALUES(?id, ?name, ?description, ?assetType, ?invType, ?local, ?temporary, ?data)",
+                        _dbConnection.Connection);
+            
+                // need to ensure we dispose
+                try
+                {            
+                    using (cmd)
+                    {
+                        MySqlParameter p = cmd.Parameters.Add("?id", MySqlDbType.Binary, 16);
+                        p.Value = asset.FullID.GetBytes();
+                        cmd.Parameters.AddWithValue("?name", asset.Name);
+                        cmd.Parameters.AddWithValue("?description", asset.Description);
+                        cmd.Parameters.AddWithValue("?assetType", asset.Type);
+                        cmd.Parameters.AddWithValue("?invType", asset.InvType);
+                        cmd.Parameters.AddWithValue("?local", asset.Local);
+                        cmd.Parameters.AddWithValue("?temporary", asset.Temporary);
+                        cmd.Parameters.AddWithValue("?data", asset.Data);
+                        cmd.ExecuteNonQuery();
+                        cmd.Dispose();
+                    }
+                }
+                catch (Exception e)
+                {
+                    m_log.ErrorFormat(
+                        "[ASSETS]: " +
+                        "MySql failure creating asset {0} with name {1}" + Environment.NewLine + e.ToString()
+                        + Environment.NewLine + "Attempting reconnection", asset.FullID, asset.Name);
+                    _dbConnection.Reconnect();
+                }   
+            }
+        }
+
+        override public void UpdateAsset(AssetBase asset)
+        {
+            CreateAsset(asset);
+        }
+
+        override public bool ExistsAsset(LLUUID uuid)
+        {
+            throw new Exception("The method or operation is not implemented.");
+        }
+
+        /// <summary>
+        /// All writes are immediately commited to the database, so this is a no-op
+        /// </summary>
+        override public void CommitAssets()
+        {
+        }
+
+        #endregion
+
+        #region IPlugin Members
+
+        override public void Initialise()
+        {
+            IniFile GridDataMySqlFile = new IniFile("mysql_connection.ini");
+            string hostname = GridDataMySqlFile.ParseFileReadValue("hostname");
+            string database = GridDataMySqlFile.ParseFileReadValue("database");
+            string username = GridDataMySqlFile.ParseFileReadValue("username");
+            string password = GridDataMySqlFile.ParseFileReadValue("password");
+            string pooling = GridDataMySqlFile.ParseFileReadValue("pooling");
+            string port = GridDataMySqlFile.ParseFileReadValue("port");
+
+            _dbConnection = new MySQLManager(hostname, database, username, password, pooling, port);
+
+            TestTables();
+        }
+
+        override public string Version
+        {
+            get { return _dbConnection.getVersion(); }
+        }
+
+        override public string Name
+        {
+            get { return "MySQL Asset storage engine"; }
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Data/MySQL/MySQLDataStore.cs b/OpenSim/Data/MySQL/MySQLDataStore.cs
new file mode 100644
index 0000000..eaa7f14
--- /dev/null
+++ b/OpenSim/Data/MySQL/MySQLDataStore.cs
@@ -0,0 +1,1722 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Diagnostics;
+using System.IO;
+using libsecondlife;
+using MySql.Data.MySqlClient;
+using OpenSim.Framework.Console;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Scenes;
+
+namespace OpenSim.Framework.Data.MySQL
+{
+    public class MySQLDataStore : IRegionDataStore
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        private const string m_primSelect = "select * from prims";
+        private const string m_shapeSelect = "select * from primshapes";
+        private const string m_itemsSelect = "select * from primitems";
+        private const string m_terrainSelect = "select * from terrain limit 1";
+        private const string m_landSelect = "select * from land";
+        private const string m_landAccessListSelect = "select * from landaccesslist";
+
+        private DataSet m_dataSet;
+        private MySqlDataAdapter m_primDataAdapter;
+        private MySqlDataAdapter m_shapeDataAdapter;
+        private MySqlDataAdapter m_itemsDataAdapter;
+        private MySqlConnection m_connection;
+        private MySqlDataAdapter m_terrainDataAdapter;
+        private MySqlDataAdapter m_landDataAdapter;
+        private MySqlDataAdapter m_landAccessListDataAdapter;
+        
+        private DataTable m_primTable;
+        private DataTable m_shapeTable;
+        private DataTable m_itemsTable;
+        private DataTable m_terrainTable;
+        private DataTable m_landTable;
+        private DataTable m_landAccessListTable;
+        
+        // Temporary attribute while this is experimental
+        private bool persistPrimInventories;        
+
+        /***********************************************************************
+         *
+         *  Public Interface Functions
+         *
+         **********************************************************************/
+
+        // see IRegionDataStore
+        public void Initialise(string connectionstring, bool persistPrimInventories)
+        {
+            m_dataSet = new DataSet();
+            this.persistPrimInventories = persistPrimInventories;
+
+            m_log.Info("[DATASTORE]: MySql - connecting: " + connectionstring);
+            m_connection = new MySqlConnection(connectionstring);
+
+            MySqlCommand primSelectCmd = new MySqlCommand(m_primSelect, m_connection);
+            m_primDataAdapter = new MySqlDataAdapter(primSelectCmd);
+
+            MySqlCommand shapeSelectCmd = new MySqlCommand(m_shapeSelect, m_connection);
+            m_shapeDataAdapter = new MySqlDataAdapter(shapeSelectCmd);
+            
+            MySqlCommand itemsSelectCmd = new MySqlCommand(m_itemsSelect, m_connection);
+            m_itemsDataAdapter = new MySqlDataAdapter(itemsSelectCmd);            
+
+            MySqlCommand terrainSelectCmd = new MySqlCommand(m_terrainSelect, m_connection);
+            m_terrainDataAdapter = new MySqlDataAdapter(terrainSelectCmd);
+
+            MySqlCommand landSelectCmd = new MySqlCommand(m_landSelect, m_connection);
+            m_landDataAdapter = new MySqlDataAdapter(landSelectCmd);
+
+            MySqlCommand landAccessListSelectCmd = new MySqlCommand(m_landAccessListSelect, m_connection);
+            m_landAccessListDataAdapter = new MySqlDataAdapter(landAccessListSelectCmd);
+
+            TestTables(m_connection);
+
+            lock (m_dataSet)
+            {
+                m_primTable = createPrimTable();
+                m_dataSet.Tables.Add(m_primTable);
+                SetupPrimCommands(m_primDataAdapter, m_connection);
+                m_primDataAdapter.Fill(m_primTable);
+
+                m_shapeTable = createShapeTable();
+                m_dataSet.Tables.Add(m_shapeTable);
+                SetupShapeCommands(m_shapeDataAdapter, m_connection);
+                m_shapeDataAdapter.Fill(m_shapeTable);
+                
+                if (persistPrimInventories)
+                {
+                    m_itemsTable = createItemsTable();
+                    m_dataSet.Tables.Add(m_itemsTable);
+                    SetupItemsCommands(m_itemsDataAdapter, m_connection);
+                    m_itemsDataAdapter.Fill(m_itemsTable);                
+                }
+
+                m_terrainTable = createTerrainTable();
+                m_dataSet.Tables.Add(m_terrainTable);
+                SetupTerrainCommands(m_terrainDataAdapter, m_connection);
+                m_terrainDataAdapter.Fill(m_terrainTable);
+
+                m_landTable = createLandTable();
+                m_dataSet.Tables.Add(m_landTable);
+                setupLandCommands(m_landDataAdapter, m_connection);
+                m_landDataAdapter.Fill(m_landTable);
+
+                m_landAccessListTable = createLandAccessListTable();
+                m_dataSet.Tables.Add(m_landAccessListTable);
+                setupLandAccessCommands(m_landAccessListDataAdapter, m_connection);
+                m_landAccessListDataAdapter.Fill(m_landAccessListTable);
+            }
+        }
+
+        public void StoreObject(SceneObjectGroup obj, LLUUID regionUUID)
+        {
+            lock (m_dataSet)
+            {
+                foreach (SceneObjectPart prim in obj.Children.Values)
+                {
+                    if ((prim.ObjectFlags & (uint) LLObject.ObjectFlags.Physics) == 0)
+                    {
+                        m_log.Info("[DATASTORE]: Adding obj: " + obj.UUID + " to region: " + regionUUID);
+                        addPrim(prim, obj.UUID, regionUUID);
+                    }
+                    else
+                    {
+                        // m_log.Info("[DATASTORE]: Ignoring Physical obj: " + obj.UUID + " in region: " + regionUUID);
+                    }
+                }
+                Commit();
+            }
+        }
+
+        public void RemoveObject(LLUUID obj, LLUUID regionUUID)
+        {
+            m_log.InfoFormat("[DATASTORE]: Removing obj: {0} from region: {1}", obj.UUID, regionUUID);
+
+            DataTable prims = m_primTable;
+            DataTable shapes = m_shapeTable;
+
+            string selectExp = "SceneGroupID = '" + Util.ToRawUuidString(obj) + "'";
+            lock (m_dataSet)
+            {
+                DataRow[] primRows = prims.Select(selectExp);
+                foreach (DataRow row in primRows)
+                {
+                    // Remove shapes row
+                    LLUUID uuid = new LLUUID((string) row["UUID"]);
+                    DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(uuid));
+                    if (shapeRow != null)
+                    {
+                        shapeRow.Delete();
+                    }
+                    
+                    if (persistPrimInventories)
+                    {                    
+                        RemoveItems(uuid);
+                    }
+                    
+                    // Remove prim row
+                    row.Delete();
+                }
+                Commit();
+            }
+        }
+
+        /// <summary>
+        /// Remove all persisted items of the given prim.
+        /// The caller must acquire the necessrary synchronization locks and commit or rollback changes.
+        /// </summary>
+        private void RemoveItems(LLUUID uuid)
+        {
+            String sql = String.Format("primID = '{0}'", uuid);            
+            DataRow[] itemRows = m_itemsTable.Select(sql);
+    
+            foreach (DataRow itemRow in itemRows)
+            {
+                itemRow.Delete();
+            }
+        }
+        
+        /// <summary>
+        /// Load persisted objects from region storage.
+        /// </summary>        
+        public List<SceneObjectGroup> LoadObjects(LLUUID regionUUID)
+        {
+            Dictionary<LLUUID, SceneObjectGroup> createdObjects = new Dictionary<LLUUID, SceneObjectGroup>();
+
+            List<SceneObjectGroup> retvals = new List<SceneObjectGroup>();
+
+            DataTable prims = m_primTable;
+            DataTable shapes = m_shapeTable;
+
+            string byRegion = "RegionUUID = '" + Util.ToRawUuidString(regionUUID) + "'";
+            string orderByParent = "ParentID ASC";
+
+            lock (m_dataSet)
+            {
+                DataRow[] primsForRegion = prims.Select(byRegion, orderByParent);
+                m_log.Info("[DATASTORE]: " +
+                                         "Loaded " + primsForRegion.Length + " prims for region: " + regionUUID);
+
+                foreach (DataRow primRow in primsForRegion)
+                {
+                    try                        
+                    {
+                        string uuid = (string) primRow["UUID"];
+                        string objID = (string) primRow["SceneGroupID"];
+                        
+                        SceneObjectPart prim = buildPrim(primRow);
+                        
+                        if (uuid == objID) //is new SceneObjectGroup ?
+                        {
+                            SceneObjectGroup group = new SceneObjectGroup();
+                            
+                            DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(prim.UUID));
+                            if (shapeRow != null)
+                            {
+                                prim.Shape = buildShape(shapeRow);
+                            }
+                            else
+                            {
+                                m_log.Info(
+                                    "No shape found for prim in storage, so setting default box shape");
+                                prim.Shape = PrimitiveBaseShape.Default;
+                            }
+                            group.AddPart(prim);
+                            group.RootPart = prim;
+
+                            createdObjects.Add(group.UUID, group);
+                            retvals.Add(group);
+                        }
+                        else
+                        {
+                            DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(prim.UUID));
+                            if (shapeRow != null)
+                            {
+                                prim.Shape = buildShape(shapeRow);
+                            }
+                            else
+                            {
+                                m_log.Info(
+                                    "No shape found for prim in storage, so setting default box shape");
+                                prim.Shape = PrimitiveBaseShape.Default;
+                            }
+                            createdObjects[new LLUUID(objID)].AddPart(prim);
+                        }
+                        
+                        if (persistPrimInventories)
+                        {
+                            LoadItems(prim);
+                        }                        
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Error("[DATASTORE]: Failed create prim object, exception and data follows");
+                        m_log.Info("[DATASTORE]: " + e.ToString());
+                        foreach (DataColumn col in prims.Columns)
+                        {
+                            m_log.Info("[DATASTORE]: Col: " + col.ColumnName + " => " + primRow[col]);
+                        }
+                    }
+                }
+            }
+            return retvals;
+        }
+        
+        /// <summary>
+        /// Load in a prim's persisted inventory.
+        /// </summary>
+        /// <param name="prim"></param>
+        private void LoadItems(SceneObjectPart prim)
+        {
+            //m_log.InfoFormat("[DATASTORE]: Loading inventory for {0}, {1}", prim.Name, prim.UUID);
+            
+            DataTable dbItems = m_itemsTable;
+            
+            String sql = String.Format("primID = '{0}'", prim.UUID.ToString());            
+            DataRow[] dbItemRows = dbItems.Select(sql);
+            
+            IList<TaskInventoryItem> inventory = new List<TaskInventoryItem>();
+            
+            foreach (DataRow row in dbItemRows)
+            {
+                TaskInventoryItem item = buildItem(row);
+                inventory.Add(item);
+                
+                //m_log.DebugFormat("[DATASTORE]: Restored item {0}, {1}", item.Name, item.ItemID); 
+            }
+            
+            prim.RestoreInventoryItems(inventory);
+            
+            // XXX A nasty little hack to recover the folder id for the prim (which is currently stored in 
+            // every item).  This data should really be stored in the prim table itself.
+            if (dbItemRows.Length > 0)
+            {
+                prim.FolderID = inventory[0].ParentID;
+            }
+        }        
+
+        public void StoreTerrain(double[,] ter, LLUUID regionID)
+        {
+            int revision = Util.UnixTimeSinceEpoch();
+            m_log.Info("[DATASTORE]: Storing terrain revision r" + revision.ToString());
+
+            DataTable terrain = m_dataSet.Tables["terrain"];
+            lock (m_dataSet)
+            {
+                MySqlCommand cmd = new MySqlCommand("insert into terrain(RegionUUID, Revision, Heightfield)" +
+                                                    " values(?RegionUUID, ?Revision, ?Heightfield)", m_connection);
+                using (cmd)
+                {
+                    cmd.Parameters.Add(new MySqlParameter("?RegionUUID", Util.ToRawUuidString(regionID)));
+                    cmd.Parameters.Add(new MySqlParameter("?Revision", revision));
+                    cmd.Parameters.Add(new MySqlParameter("?Heightfield", serializeTerrain(ter)));
+                    cmd.ExecuteNonQuery();
+                }
+            }
+        }
+
+        public double[,] LoadTerrain(LLUUID regionID)
+        {
+            double[,] terret = new double[256,256];
+            terret.Initialize();
+
+            MySqlCommand cmd = new MySqlCommand(
+                @"select RegionUUID, Revision, Heightfield from terrain
+                where RegionUUID=?RegionUUID order by Revision desc limit 1"
+                , m_connection);
+
+            MySqlParameter param = new MySqlParameter();
+            cmd.Parameters.Add(new MySqlParameter("?RegionUUID", Util.ToRawUuidString(regionID)));
+
+            if (m_connection.State != ConnectionState.Open)
+            {
+                m_connection.Open();
+            }
+            
+            lock (m_dataSet) 
+            {
+                using (MySqlDataReader row = cmd.ExecuteReader())
+                {
+                    int rev = 0;
+                    if (row.Read())
+                    {
+                        MemoryStream str = new MemoryStream((byte[]) row["Heightfield"]);
+                        BinaryReader br = new BinaryReader(str);
+                        for (int x = 0; x < 256; x++)
+                        {
+                            for (int y = 0; y < 256; y++)
+                            {
+                                terret[x, y] = br.ReadDouble();
+                            }
+                        }
+                        rev = (int) row["Revision"];
+                    }
+                    else
+                    {
+                        m_log.Info("[DATASTORE]: No terrain found for region");
+                        return null;
+                    }
+                    
+                    m_log.Info("[DATASTORE]: Loaded terrain revision r" + rev.ToString());
+                }
+            }
+            return terret;
+        }
+
+        public void RemoveLandObject(LLUUID globalID)
+        {
+            lock (m_dataSet)
+            {
+                using (MySqlCommand cmd = new MySqlCommand("delete from land where UUID=?UUID", m_connection))
+                {
+                    cmd.Parameters.Add(new MySqlParameter("?UUID", Util.ToRawUuidString(globalID)));
+                    cmd.ExecuteNonQuery();
+                }
+
+                using (
+                    MySqlCommand cmd = new MySqlCommand("delete from landaccesslist where LandUUID=?UUID", m_connection)
+                    )
+                {
+                    cmd.Parameters.Add(new MySqlParameter("?UUID", Util.ToRawUuidString(globalID)));
+                    cmd.ExecuteNonQuery();
+                }
+            }
+        }
+
+        public void StoreLandObject(ILandObject parcel)
+        {
+            lock (m_dataSet)
+            {
+                DataTable land = m_landTable;
+                DataTable landaccesslist = m_landAccessListTable;
+
+                DataRow landRow = land.Rows.Find(Util.ToRawUuidString(parcel.landData.globalID));
+                if (landRow == null)
+                {
+                    landRow = land.NewRow();
+                    fillLandRow(landRow, parcel.landData, parcel.regionUUID);
+                    land.Rows.Add(landRow);
+                }
+                else
+                {
+                    fillLandRow(landRow, parcel.landData, parcel.regionUUID);
+                }
+
+                using (
+                    MySqlCommand cmd =
+                        new MySqlCommand("delete from landaccesslist where LandUUID=?LandUUID", m_connection))
+                {
+                    cmd.Parameters.Add(new MySqlParameter("?LandUUID", Util.ToRawUuidString(parcel.landData.globalID)));
+                    cmd.ExecuteNonQuery();
+                }
+
+                foreach (ParcelManager.ParcelAccessEntry entry in parcel.landData.parcelAccessList)
+                {
+                    DataRow newAccessRow = landaccesslist.NewRow();
+                    fillLandAccessRow(newAccessRow, entry, parcel.landData.globalID);
+                    landaccesslist.Rows.Add(newAccessRow);
+                }
+                
+                Commit();
+            }
+        }
+
+        public List<LandData> LoadLandObjects(LLUUID regionUUID)
+        {
+            List<LandData> landDataForRegion = new List<LandData>();
+            lock (m_dataSet)
+            {
+                DataTable land = m_landTable;
+                DataTable landaccesslist = m_landAccessListTable;
+                string searchExp = "RegionUUID = '" + Util.ToRawUuidString(regionUUID) + "'";
+                DataRow[] rawDataForRegion = land.Select(searchExp);
+                foreach (DataRow rawDataLand in rawDataForRegion)
+                {
+                    LandData newLand = buildLandData(rawDataLand);
+                    string accessListSearchExp = "LandUUID = '" + Util.ToRawUuidString(newLand.globalID) + "'";
+                    DataRow[] rawDataForLandAccessList = landaccesslist.Select(accessListSearchExp);
+                    foreach (DataRow rawDataLandAccess in rawDataForLandAccessList)
+                    {
+                        newLand.parcelAccessList.Add(buildLandAccessData(rawDataLandAccess));
+                    }
+
+                    landDataForRegion.Add(newLand);
+                }
+            }
+            return landDataForRegion;
+        }
+
+// TODO: unused
+//         private void DisplayDataSet(DataSet ds, string title)
+//         {
+//             Debug.WriteLine(title);
+//             //--- Loop through the DataTables
+//             foreach (DataTable table in ds.Tables)
+//             {
+//                 Debug.WriteLine("*** DataTable: " + table.TableName + "***");
+//                 //--- Loop through each DataTable's DataRows
+//                 foreach (DataRow row in table.Rows)
+//                 {
+//                     //--- Display the original values, if there are any.
+//                     if (row.HasVersion(DataRowVersion.Original))
+//                     {
+//                         Debug.Write("Original Row Values ===> ");
+//                         foreach (DataColumn column in table.Columns)
+//                             Debug.Write(column.ColumnName + " = " +
+//                                         row[column, DataRowVersion.Original] + ", ");
+//                         Debug.WriteLine(String.Empty);
+//                     }
+//                     //--- Display the current values, if there are any.
+//                     if (row.HasVersion(DataRowVersion.Current))
+//                     {
+//                         Debug.Write("Current Row Values ====> ");
+//                         foreach (DataColumn column in table.Columns)
+//                             Debug.Write(column.ColumnName + " = " +
+//                                         row[column, DataRowVersion.Current] + ", ");
+//                         Debug.WriteLine(String.Empty);
+//                     }
+//                     Debug.WriteLine(String.Empty);
+//                 }
+//             }
+//         }
+
+        public void Commit()
+        {
+            if (m_connection.State != ConnectionState.Open)
+            {
+                m_connection.Open();
+            }
+
+            lock (m_dataSet)
+            {
+                // DisplayDataSet(m_dataSet, "Region DataSet");
+
+                m_primDataAdapter.Update(m_primTable);
+                m_shapeDataAdapter.Update(m_shapeTable);
+
+                if (persistPrimInventories)
+                {
+                    m_itemsDataAdapter.Update(m_itemsTable);
+                }
+
+                m_terrainDataAdapter.Update(m_terrainTable);
+                m_landDataAdapter.Update(m_landTable);
+                m_landAccessListDataAdapter.Update(m_landAccessListTable);
+
+                m_dataSet.AcceptChanges();
+            }
+        }
+
+
+        public void Shutdown()
+        {
+            Commit();
+        }
+
+        /***********************************************************************
+         *
+         *  Database Definition Functions
+         * 
+         *  This should be db agnostic as we define them in ADO.NET terms
+         *
+         **********************************************************************/
+
+        private DataColumn createCol(DataTable dt, string name, Type type)
+        {
+            DataColumn col = new DataColumn(name, type);
+            dt.Columns.Add(col);
+            return col;
+        }
+
+        private DataTable createTerrainTable()
+        {
+            DataTable terrain = new DataTable("terrain");
+
+            createCol(terrain, "RegionUUID", typeof (String));
+            createCol(terrain, "Revision", typeof (Int32));
+            DataColumn heightField = createCol(terrain, "Heightfield", typeof (Byte[]));
+            return terrain;
+        }
+
+        private DataTable createPrimTable()
+        {
+            DataTable prims = new DataTable("prims");
+
+            createCol(prims, "UUID", typeof (String));
+            createCol(prims, "RegionUUID", typeof (String));
+            createCol(prims, "ParentID", typeof (Int32));
+            createCol(prims, "CreationDate", typeof (Int32));
+            createCol(prims, "Name", typeof (String));
+            createCol(prims, "SceneGroupID", typeof (String));
+            // various text fields
+            createCol(prims, "Text", typeof (String));
+            createCol(prims, "Description", typeof (String));
+            createCol(prims, "SitName", typeof (String));
+            createCol(prims, "TouchName", typeof (String));
+            // permissions
+            createCol(prims, "ObjectFlags", typeof (Int32));
+            createCol(prims, "CreatorID", typeof (String));
+            createCol(prims, "OwnerID", typeof (String));
+            createCol(prims, "GroupID", typeof (String));
+            createCol(prims, "LastOwnerID", typeof (String));
+            createCol(prims, "OwnerMask", typeof (Int32));
+            createCol(prims, "NextOwnerMask", typeof (Int32));
+            createCol(prims, "GroupMask", typeof (Int32));
+            createCol(prims, "EveryoneMask", typeof (Int32));
+            createCol(prims, "BaseMask", typeof (Int32));
+            // vectors
+            createCol(prims, "PositionX", typeof (Double));
+            createCol(prims, "PositionY", typeof (Double));
+            createCol(prims, "PositionZ", typeof (Double));
+            createCol(prims, "GroupPositionX", typeof (Double));
+            createCol(prims, "GroupPositionY", typeof (Double));
+            createCol(prims, "GroupPositionZ", typeof (Double));
+            createCol(prims, "VelocityX", typeof (Double));
+            createCol(prims, "VelocityY", typeof (Double));
+            createCol(prims, "VelocityZ", typeof (Double));
+            createCol(prims, "AngularVelocityX", typeof (Double));
+            createCol(prims, "AngularVelocityY", typeof (Double));
+            createCol(prims, "AngularVelocityZ", typeof (Double));
+            createCol(prims, "AccelerationX", typeof (Double));
+            createCol(prims, "AccelerationY", typeof (Double));
+            createCol(prims, "AccelerationZ", typeof (Double));
+            // quaternions
+            createCol(prims, "RotationX", typeof (Double));
+            createCol(prims, "RotationY", typeof (Double));
+            createCol(prims, "RotationZ", typeof (Double));
+            createCol(prims, "RotationW", typeof (Double));
+            // sit target
+            createCol(prims, "SitTargetOffsetX", typeof (Double));
+            createCol(prims, "SitTargetOffsetY", typeof (Double));
+            createCol(prims, "SitTargetOffsetZ", typeof (Double));
+
+            createCol(prims, "SitTargetOrientW", typeof (Double));
+            createCol(prims, "SitTargetOrientX", typeof (Double));
+            createCol(prims, "SitTargetOrientY", typeof (Double));
+            createCol(prims, "SitTargetOrientZ", typeof (Double));
+
+
+            // Add in contraints
+            prims.PrimaryKey = new DataColumn[] {prims.Columns["UUID"]};
+
+            return prims;
+        }
+
+        private DataTable createLandTable()
+        {
+            DataTable land = new DataTable("land");
+            createCol(land, "UUID", typeof (String));
+            createCol(land, "RegionUUID", typeof (String));
+            createCol(land, "LocalLandID", typeof (Int32));
+
+            // Bitmap is a byte[512]
+            createCol(land, "Bitmap", typeof (Byte[]));
+
+            createCol(land, "Name", typeof (String));
+            createCol(land, "Description", typeof (String));
+            createCol(land, "OwnerUUID", typeof (String));
+            createCol(land, "IsGroupOwned", typeof (Int32));
+            createCol(land, "Area", typeof (Int32));
+            createCol(land, "AuctionID", typeof (Int32)); //Unemplemented
+            createCol(land, "Category", typeof (Int32)); //Enum libsecondlife.Parcel.ParcelCategory
+            createCol(land, "ClaimDate", typeof (Int32));
+            createCol(land, "ClaimPrice", typeof (Int32));
+            createCol(land, "GroupUUID", typeof (String));
+            createCol(land, "SalePrice", typeof (Int32));
+            createCol(land, "LandStatus", typeof (Int32)); //Enum. libsecondlife.Parcel.ParcelStatus
+            createCol(land, "LandFlags", typeof (Int32));
+            createCol(land, "LandingType", typeof (Int32));
+            createCol(land, "MediaAutoScale", typeof (Int32));
+            createCol(land, "MediaTextureUUID", typeof (String));
+            createCol(land, "MediaURL", typeof (String));
+            createCol(land, "MusicURL", typeof (String));
+            createCol(land, "PassHours", typeof (Double));
+            createCol(land, "PassPrice", typeof (Int32));
+            createCol(land, "SnapshotUUID", typeof (String));
+            createCol(land, "UserLocationX", typeof (Double));
+            createCol(land, "UserLocationY", typeof (Double));
+            createCol(land, "UserLocationZ", typeof (Double));
+            createCol(land, "UserLookAtX", typeof (Double));
+            createCol(land, "UserLookAtY", typeof (Double));
+            createCol(land, "UserLookAtZ", typeof (Double));
+
+            land.PrimaryKey = new DataColumn[] {land.Columns["UUID"]};
+
+            return land;
+        }
+
+        private DataTable createLandAccessListTable()
+        {
+            DataTable landaccess = new DataTable("landaccesslist");
+            createCol(landaccess, "LandUUID", typeof (String));
+            createCol(landaccess, "AccessUUID", typeof (String));
+            createCol(landaccess, "Flags", typeof (Int32));
+
+            return landaccess;
+        }
+
+        private DataTable createShapeTable()
+        {
+            DataTable shapes = new DataTable("primshapes");
+            createCol(shapes, "UUID", typeof (String));
+            // shape is an enum
+            createCol(shapes, "Shape", typeof (Int32));
+            // vectors
+            createCol(shapes, "ScaleX", typeof (Double));
+            createCol(shapes, "ScaleY", typeof (Double));
+            createCol(shapes, "ScaleZ", typeof (Double));
+            // paths
+            createCol(shapes, "PCode", typeof (Int32));
+            createCol(shapes, "PathBegin", typeof (Int32));
+            createCol(shapes, "PathEnd", typeof (Int32));
+            createCol(shapes, "PathScaleX", typeof (Int32));
+            createCol(shapes, "PathScaleY", typeof (Int32));
+            createCol(shapes, "PathShearX", typeof (Int32));
+            createCol(shapes, "PathShearY", typeof (Int32));
+            createCol(shapes, "PathSkew", typeof (Int32));
+            createCol(shapes, "PathCurve", typeof (Int32));
+            createCol(shapes, "PathRadiusOffset", typeof (Int32));
+            createCol(shapes, "PathRevolutions", typeof (Int32));
+            createCol(shapes, "PathTaperX", typeof (Int32));
+            createCol(shapes, "PathTaperY", typeof (Int32));
+            createCol(shapes, "PathTwist", typeof (Int32));
+            createCol(shapes, "PathTwistBegin", typeof (Int32));
+            // profile
+            createCol(shapes, "ProfileBegin", typeof (Int32));
+            createCol(shapes, "ProfileEnd", typeof (Int32));
+            createCol(shapes, "ProfileCurve", typeof (Int32));
+            createCol(shapes, "ProfileHollow", typeof (Int32));
+            createCol(shapes, "State", typeof(Int32));
+            createCol(shapes, "Texture", typeof (Byte[]));
+            createCol(shapes, "ExtraParams", typeof (Byte[]));
+
+            shapes.PrimaryKey = new DataColumn[] {shapes.Columns["UUID"]};
+
+            return shapes;
+        }
+        
+        private DataTable createItemsTable()
+        {
+            DataTable items = new DataTable("primitems");
+
+            createCol(items, "itemID", typeof (String));
+            createCol(items, "primID", typeof (String));
+            createCol(items, "assetID", typeof (String));
+            createCol(items, "parentFolderID", typeof (String));
+            
+            createCol(items, "invType", typeof (Int32));            
+            createCol(items, "assetType", typeof (Int32));
+
+            createCol(items, "name", typeof (String));
+            createCol(items, "description", typeof (String));
+
+            createCol(items, "creationDate", typeof (Int64));
+            createCol(items, "creatorID", typeof (String));
+            createCol(items, "ownerID", typeof (String));
+            createCol(items, "lastOwnerID", typeof (String));
+            createCol(items, "groupID", typeof (String));
+
+            createCol(items, "nextPermissions", typeof (Int32));
+            createCol(items, "currentPermissions", typeof (Int32));
+            createCol(items, "basePermissions", typeof (Int32));
+            createCol(items, "everyonePermissions", typeof (Int32));
+            createCol(items, "groupPermissions", typeof (Int32));
+
+            items.PrimaryKey = new DataColumn[] {items.Columns["itemID"]};
+
+            return items;
+        }        
+
+        /***********************************************************************
+         *  
+         *  Convert between ADO.NET <=> OpenSim Objects
+         *
+         *  These should be database independant
+         *
+         **********************************************************************/
+
+        private SceneObjectPart buildPrim(DataRow row)
+        {
+            SceneObjectPart prim = new SceneObjectPart();
+            prim.UUID = new LLUUID((String) row["UUID"]);
+            // explicit conversion of integers is required, which sort
+            // of sucks.  No idea if there is a shortcut here or not.
+            prim.ParentID = Convert.ToUInt32(row["ParentID"]);
+            prim.CreationDate = Convert.ToInt32(row["CreationDate"]);
+            prim.Name = (String) row["Name"];
+            // various text fields
+            prim.Text = (String) row["Text"];
+            prim.Description = (String) row["Description"];
+            prim.SitName = (String) row["SitName"];
+            prim.TouchName = (String) row["TouchName"];
+            // permissions
+            prim.ObjectFlags = Convert.ToUInt32(row["ObjectFlags"]);
+            prim.CreatorID = new LLUUID((String) row["CreatorID"]);
+            prim.OwnerID = new LLUUID((String) row["OwnerID"]);
+            prim.GroupID = new LLUUID((String) row["GroupID"]);
+            prim.LastOwnerID = new LLUUID((String) row["LastOwnerID"]);
+            prim.OwnerMask = Convert.ToUInt32(row["OwnerMask"]);
+            prim.NextOwnerMask = Convert.ToUInt32(row["NextOwnerMask"]);
+            prim.GroupMask = Convert.ToUInt32(row["GroupMask"]);
+            prim.EveryoneMask = Convert.ToUInt32(row["EveryoneMask"]);
+            prim.BaseMask = Convert.ToUInt32(row["BaseMask"]);
+            // vectors
+            prim.OffsetPosition = new LLVector3(
+                Convert.ToSingle(row["PositionX"]),
+                Convert.ToSingle(row["PositionY"]),
+                Convert.ToSingle(row["PositionZ"])
+                );
+            prim.GroupPosition = new LLVector3(
+                Convert.ToSingle(row["GroupPositionX"]),
+                Convert.ToSingle(row["GroupPositionY"]),
+                Convert.ToSingle(row["GroupPositionZ"])
+                );
+            prim.Velocity = new LLVector3(
+                Convert.ToSingle(row["VelocityX"]),
+                Convert.ToSingle(row["VelocityY"]),
+                Convert.ToSingle(row["VelocityZ"])
+                );
+            prim.AngularVelocity = new LLVector3(
+                Convert.ToSingle(row["AngularVelocityX"]),
+                Convert.ToSingle(row["AngularVelocityY"]),
+                Convert.ToSingle(row["AngularVelocityZ"])
+                );
+            prim.Acceleration = new LLVector3(
+                Convert.ToSingle(row["AccelerationX"]),
+                Convert.ToSingle(row["AccelerationY"]),
+                Convert.ToSingle(row["AccelerationZ"])
+                );
+            // quaternions
+            prim.RotationOffset = new LLQuaternion(
+                Convert.ToSingle(row["RotationX"]),
+                Convert.ToSingle(row["RotationY"]),
+                Convert.ToSingle(row["RotationZ"]),
+                Convert.ToSingle(row["RotationW"])
+                );
+            try
+            {
+                prim.SetSitTargetLL(new LLVector3(
+                                        Convert.ToSingle(row["SitTargetOffsetX"]),
+                                        Convert.ToSingle(row["SitTargetOffsetY"]),
+                                        Convert.ToSingle(row["SitTargetOffsetZ"])), new LLQuaternion(
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientX"]),
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientY"]),
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientZ"]),
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientW"])));
+            }
+            catch (InvalidCastException)
+            {
+                // Database table was created before we got here and needs to be created! :P
+
+                using (
+                    MySqlCommand cmd =
+                        new MySqlCommand(
+                            "ALTER TABLE `prims` ADD COLUMN `SitTargetOffsetX` float NOT NULL default 0,  ADD COLUMN `SitTargetOffsetY` float NOT NULL default 0, ADD COLUMN `SitTargetOffsetZ` float NOT NULL default 0, ADD COLUMN `SitTargetOrientW` float NOT NULL default 0, ADD COLUMN `SitTargetOrientX` float NOT NULL default 0, ADD COLUMN `SitTargetOrientY` float NOT NULL default 0, ADD COLUMN `SitTargetOrientZ` float NOT NULL default 0;",
+                            m_connection))
+                {
+                    cmd.ExecuteNonQuery();
+                }
+            }
+            return prim;
+        }
+        
+        
+        /// <summary>
+        /// Build a prim inventory item from the persisted data.
+        /// </summary>
+        /// <param name="row"></param>
+        /// <returns></returns>
+        private TaskInventoryItem buildItem(DataRow row)
+        {
+            TaskInventoryItem taskItem = new TaskInventoryItem();
+            
+            taskItem.ItemID        = new LLUUID((String)row["itemID"]); 
+            taskItem.ParentPartID  = new LLUUID((String)row["primID"]);
+            taskItem.AssetID       = new LLUUID((String)row["assetID"]);
+            taskItem.ParentID      = new LLUUID((String)row["parentFolderID"]);
+            
+            taskItem.InvType       = Convert.ToInt32(row["invType"]);
+            taskItem.Type          = Convert.ToInt32(row["assetType"]);
+            
+            taskItem.Name          = (String)row["name"];
+            taskItem.Description   = (String)row["description"];
+            taskItem.CreationDate  = Convert.ToUInt32(row["creationDate"]);
+            taskItem.CreatorID     = new LLUUID((String)row["creatorID"]);
+            taskItem.OwnerID       = new LLUUID((String)row["ownerID"]);
+            taskItem.LastOwnerID   = new LLUUID((String)row["lastOwnerID"]);
+            taskItem.GroupID       = new LLUUID((String)row["groupID"]);
+            
+            taskItem.NextOwnerMask = Convert.ToUInt32(row["nextPermissions"]);
+            taskItem.OwnerMask     = Convert.ToUInt32(row["currentPermissions"]);
+            taskItem.BaseMask      = Convert.ToUInt32(row["basePermissions"]);
+            taskItem.EveryoneMask  = Convert.ToUInt32(row["everyonePermissions"]);
+            taskItem.GroupMask     = Convert.ToUInt32(row["groupPermissions"]);
+            
+            return taskItem;
+        }        
+
+        private LandData buildLandData(DataRow row)
+        {
+            LandData newData = new LandData();
+
+            newData.globalID = new LLUUID((String) row["UUID"]);
+            newData.localID = Convert.ToInt32(row["LocalLandID"]);
+
+            // Bitmap is a byte[512]
+            newData.landBitmapByteArray = (Byte[]) row["Bitmap"];
+
+            newData.landName = (String) row["Name"];
+            newData.landDesc = (String) row["Description"];
+            newData.ownerID = (String) row["OwnerUUID"];
+            newData.isGroupOwned = Convert.ToBoolean(row["IsGroupOwned"]);
+            newData.area = Convert.ToInt32(row["Area"]);
+            newData.auctionID = Convert.ToUInt32(row["AuctionID"]); //Unemplemented
+            newData.category = (Parcel.ParcelCategory) Convert.ToInt32(row["Category"]);
+                //Enum libsecondlife.Parcel.ParcelCategory
+            newData.claimDate = Convert.ToInt32(row["ClaimDate"]);
+            newData.claimPrice = Convert.ToInt32(row["ClaimPrice"]);
+            newData.groupID = new LLUUID((String) row["GroupUUID"]);
+            newData.salePrice = Convert.ToInt32(row["SalePrice"]);
+            newData.landStatus = (Parcel.ParcelStatus) Convert.ToInt32(row["LandStatus"]);
+                //Enum. libsecondlife.Parcel.ParcelStatus
+            newData.landFlags = Convert.ToUInt32(row["LandFlags"]);
+            newData.landingType = Convert.ToByte(row["LandingType"]);
+            newData.mediaAutoScale = Convert.ToByte(row["MediaAutoScale"]);
+            newData.mediaID = new LLUUID((String) row["MediaTextureUUID"]);
+            newData.mediaURL = (String) row["MediaURL"];
+            newData.musicURL = (String) row["MusicURL"];
+            newData.passHours = Convert.ToSingle(row["PassHours"]);
+            newData.passPrice = Convert.ToInt32(row["PassPrice"]);
+            newData.snapshotID = (String) row["SnapshotUUID"];
+
+            newData.userLocation =
+                new LLVector3(Convert.ToSingle(row["UserLocationX"]), Convert.ToSingle(row["UserLocationY"]),
+                              Convert.ToSingle(row["UserLocationZ"]));
+            newData.userLookAt =
+                new LLVector3(Convert.ToSingle(row["UserLookAtX"]), Convert.ToSingle(row["UserLookAtY"]),
+                              Convert.ToSingle(row["UserLookAtZ"]));
+            newData.parcelAccessList = new List<ParcelManager.ParcelAccessEntry>();
+
+            return newData;
+        }
+
+        private ParcelManager.ParcelAccessEntry buildLandAccessData(DataRow row)
+        {
+            ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry();
+            entry.AgentID = new LLUUID((string) row["AccessUUID"]);
+            entry.Flags = (ParcelManager.AccessList) Convert.ToInt32(row["Flags"]);
+            entry.Time = new DateTime();
+            return entry;
+        }
+
+        private Array serializeTerrain(double[,] val)
+        {
+            MemoryStream str = new MemoryStream(65536*sizeof (double));
+            BinaryWriter bw = new BinaryWriter(str);
+
+            // TODO: COMPATIBILITY - Add byte-order conversions
+            for (int x = 0; x < 256; x++)
+                for (int y = 0; y < 256; y++)
+                    bw.Write(val[x, y]);
+
+            return str.ToArray();
+        }
+
+        private void fillPrimRow(DataRow row, SceneObjectPart prim, LLUUID sceneGroupID, LLUUID regionUUID)
+        {
+            row["UUID"] = Util.ToRawUuidString(prim.UUID);
+            row["RegionUUID"] = Util.ToRawUuidString(regionUUID);
+            row["ParentID"] = prim.ParentID;
+            row["CreationDate"] = prim.CreationDate;
+            row["Name"] = prim.Name;
+            row["SceneGroupID"] = Util.ToRawUuidString(sceneGroupID);
+                // the UUID of the root part for this SceneObjectGroup
+            // various text fields
+            row["Text"] = prim.Text;
+            row["Description"] = prim.Description;
+            row["SitName"] = prim.SitName;
+            row["TouchName"] = prim.TouchName;
+            // permissions
+            row["ObjectFlags"] = prim.ObjectFlags;
+            row["CreatorID"] = Util.ToRawUuidString(prim.CreatorID);
+            row["OwnerID"] = Util.ToRawUuidString(prim.OwnerID);
+            row["GroupID"] = Util.ToRawUuidString(prim.GroupID);
+            row["LastOwnerID"] = Util.ToRawUuidString(prim.LastOwnerID);
+            row["OwnerMask"] = prim.OwnerMask;
+            row["NextOwnerMask"] = prim.NextOwnerMask;
+            row["GroupMask"] = prim.GroupMask;
+            row["EveryoneMask"] = prim.EveryoneMask;
+            row["BaseMask"] = prim.BaseMask;
+            // vectors
+            row["PositionX"] = prim.OffsetPosition.X;
+            row["PositionY"] = prim.OffsetPosition.Y;
+            row["PositionZ"] = prim.OffsetPosition.Z;
+            row["GroupPositionX"] = prim.GroupPosition.X;
+            row["GroupPositionY"] = prim.GroupPosition.Y;
+            row["GroupPositionZ"] = prim.GroupPosition.Z;
+            row["VelocityX"] = prim.Velocity.X;
+            row["VelocityY"] = prim.Velocity.Y;
+            row["VelocityZ"] = prim.Velocity.Z;
+            row["AngularVelocityX"] = prim.AngularVelocity.X;
+            row["AngularVelocityY"] = prim.AngularVelocity.Y;
+            row["AngularVelocityZ"] = prim.AngularVelocity.Z;
+            row["AccelerationX"] = prim.Acceleration.X;
+            row["AccelerationY"] = prim.Acceleration.Y;
+            row["AccelerationZ"] = prim.Acceleration.Z;
+            // quaternions
+            row["RotationX"] = prim.RotationOffset.X;
+            row["RotationY"] = prim.RotationOffset.Y;
+            row["RotationZ"] = prim.RotationOffset.Z;
+            row["RotationW"] = prim.RotationOffset.W;
+
+            try
+            {
+                // Sit target
+                LLVector3 sitTargetPos = prim.GetSitTargetPositionLL();
+                row["SitTargetOffsetX"] = sitTargetPos.X;
+                row["SitTargetOffsetY"] = sitTargetPos.Y;
+                row["SitTargetOffsetZ"] = sitTargetPos.Z;
+
+                LLQuaternion sitTargetOrient = prim.GetSitTargetOrientationLL();
+                row["SitTargetOrientW"] = sitTargetOrient.W;
+                row["SitTargetOrientX"] = sitTargetOrient.X;
+                row["SitTargetOrientY"] = sitTargetOrient.Y;
+                row["SitTargetOrientZ"] = sitTargetOrient.Z;
+            }
+            catch (MySqlException)
+            {
+                // Database table was created before we got here and needs to be created! :P
+
+                using (
+                    MySqlCommand cmd =
+                        new MySqlCommand(
+                            "ALTER TABLE `prims` ADD COLUMN `SitTargetOffsetX` float NOT NULL default 0,  ADD COLUMN `SitTargetOffsetY` float NOT NULL default 0, ADD COLUMN `SitTargetOffsetZ` float NOT NULL default 0, ADD COLUMN `SitTargetOrientW` float NOT NULL default 0, ADD COLUMN `SitTargetOrientX` float NOT NULL default 0, ADD COLUMN `SitTargetOrientY` float NOT NULL default 0, ADD COLUMN `SitTargetOrientZ` float NOT NULL default 0;",
+                            m_connection))
+                {
+                    cmd.ExecuteNonQuery();
+                }
+            }
+        }
+        
+        private void fillItemRow(DataRow row, TaskInventoryItem taskItem)
+        {
+            row["itemID"] = taskItem.ItemID;
+            row["primID"] = taskItem.ParentPartID;
+            row["assetID"] = taskItem.AssetID;
+            row["parentFolderID"] = taskItem.ParentID;
+            
+            row["invType"] = taskItem.InvType;
+            row["assetType"] = taskItem.Type;
+            
+            row["name"] = taskItem.Name;
+            row["description"] = taskItem.Description;
+            row["creationDate"] = taskItem.CreationDate;
+            row["creatorID"] = taskItem.CreatorID;
+            row["ownerID"] = taskItem.OwnerID;
+            row["lastOwnerID"] = taskItem.LastOwnerID;
+            row["groupID"] = taskItem.GroupID;
+            row["nextPermissions"] = taskItem.NextOwnerMask;
+            row["currentPermissions"] = taskItem.OwnerMask;
+            row["basePermissions"] = taskItem.BaseMask;
+            row["everyonePermissions"] = taskItem.EveryoneMask;
+            row["groupPermissions"] = taskItem.GroupMask;
+        }        
+
+        private void fillLandRow(DataRow row, LandData land, LLUUID regionUUID)
+        {
+            row["UUID"] = Util.ToRawUuidString(land.globalID);
+            row["RegionUUID"] = Util.ToRawUuidString(regionUUID);
+            row["LocalLandID"] = land.localID;
+
+            // Bitmap is a byte[512]
+            row["Bitmap"] = land.landBitmapByteArray;
+
+            row["Name"] = land.landName;
+            row["Description"] = land.landDesc;
+            row["OwnerUUID"] = Util.ToRawUuidString(land.ownerID);
+            row["IsGroupOwned"] = land.isGroupOwned;
+            row["Area"] = land.area;
+            row["AuctionID"] = land.auctionID; //Unemplemented
+            row["Category"] = land.category; //Enum libsecondlife.Parcel.ParcelCategory
+            row["ClaimDate"] = land.claimDate;
+            row["ClaimPrice"] = land.claimPrice;
+            row["GroupUUID"] = Util.ToRawUuidString(land.groupID);
+            row["SalePrice"] = land.salePrice;
+            row["LandStatus"] = land.landStatus; //Enum. libsecondlife.Parcel.ParcelStatus
+            row["LandFlags"] = land.landFlags;
+            row["LandingType"] = land.landingType;
+            row["MediaAutoScale"] = land.mediaAutoScale;
+            row["MediaTextureUUID"] = Util.ToRawUuidString(land.mediaID);
+            row["MediaURL"] = land.mediaURL;
+            row["MusicURL"] = land.musicURL;
+            row["PassHours"] = land.passHours;
+            row["PassPrice"] = land.passPrice;
+            row["SnapshotUUID"] = Util.ToRawUuidString(land.snapshotID);
+            row["UserLocationX"] = land.userLocation.X;
+            row["UserLocationY"] = land.userLocation.Y;
+            row["UserLocationZ"] = land.userLocation.Z;
+            row["UserLookAtX"] = land.userLookAt.X;
+            row["UserLookAtY"] = land.userLookAt.Y;
+            row["UserLookAtZ"] = land.userLookAt.Z;
+        }
+
+        private void fillLandAccessRow(DataRow row, ParcelManager.ParcelAccessEntry entry, LLUUID parcelID)
+        {
+            row["LandUUID"] = Util.ToRawUuidString(parcelID);
+            row["AccessUUID"] = Util.ToRawUuidString(entry.AgentID);
+            row["Flags"] = entry.Flags;
+        }
+
+        private PrimitiveBaseShape buildShape(DataRow row)
+        {
+            PrimitiveBaseShape s = new PrimitiveBaseShape();
+            s.Scale = new LLVector3(
+                Convert.ToSingle(row["ScaleX"]),
+                Convert.ToSingle(row["ScaleY"]),
+                Convert.ToSingle(row["ScaleZ"])
+                );
+            // paths
+            s.PCode = Convert.ToByte(row["PCode"]);
+            s.PathBegin = Convert.ToUInt16(row["PathBegin"]);
+            s.PathEnd = Convert.ToUInt16(row["PathEnd"]);
+            s.PathScaleX = Convert.ToByte(row["PathScaleX"]);
+            s.PathScaleY = Convert.ToByte(row["PathScaleY"]);
+            s.PathShearX = Convert.ToByte(row["PathShearX"]);
+            s.PathShearY = Convert.ToByte(row["PathShearY"]);
+            s.PathSkew = Convert.ToSByte(row["PathSkew"]);
+            s.PathCurve = Convert.ToByte(row["PathCurve"]);
+            s.PathRadiusOffset = Convert.ToSByte(row["PathRadiusOffset"]);
+            s.PathRevolutions = Convert.ToByte(row["PathRevolutions"]);
+            s.PathTaperX = Convert.ToSByte(row["PathTaperX"]);
+            s.PathTaperY = Convert.ToSByte(row["PathTaperY"]);
+            s.PathTwist = Convert.ToSByte(row["PathTwist"]);
+            s.PathTwistBegin = Convert.ToSByte(row["PathTwistBegin"]);
+            // profile
+            s.ProfileBegin = Convert.ToUInt16(row["ProfileBegin"]);
+            s.ProfileEnd = Convert.ToUInt16(row["ProfileEnd"]);
+            s.ProfileCurve = Convert.ToByte(row["ProfileCurve"]);
+            s.ProfileHollow = Convert.ToUInt16(row["ProfileHollow"]);
+
+            byte[] textureEntry = (byte[]) row["Texture"];
+            s.TextureEntry = textureEntry;
+
+            s.ExtraParams = (byte[]) row["ExtraParams"];
+
+            try
+            {
+                s.State = Convert.ToByte(row["State"]);
+            }
+            catch (InvalidCastException)
+            {
+                // Database table was created before we got here and needs to be created! :P
+
+                using (
+                    MySqlCommand cmd =
+                        new MySqlCommand(
+                            "ALTER TABLE `primshapes` ADD COLUMN `State` int NOT NULL default 0;",
+                            m_connection))
+                {
+                    cmd.ExecuteNonQuery();
+                }
+            }
+
+            return s;
+        }
+
+        private void fillShapeRow(DataRow row, SceneObjectPart prim)
+        {
+            PrimitiveBaseShape s = prim.Shape;
+            row["UUID"] = Util.ToRawUuidString(prim.UUID);
+            // shape is an enum
+            row["Shape"] = 0;
+            // vectors
+            row["ScaleX"] = s.Scale.X;
+            row["ScaleY"] = s.Scale.Y;
+            row["ScaleZ"] = s.Scale.Z;
+            // paths
+            row["PCode"] = s.PCode;
+            row["PathBegin"] = s.PathBegin;
+            row["PathEnd"] = s.PathEnd;
+            row["PathScaleX"] = s.PathScaleX;
+            row["PathScaleY"] = s.PathScaleY;
+            row["PathShearX"] = s.PathShearX;
+            row["PathShearY"] = s.PathShearY;
+            row["PathSkew"] = s.PathSkew;
+            row["PathCurve"] = s.PathCurve;
+            row["PathRadiusOffset"] = s.PathRadiusOffset;
+            row["PathRevolutions"] = s.PathRevolutions;
+            row["PathTaperX"] = s.PathTaperX;
+            row["PathTaperY"] = s.PathTaperY;
+            row["PathTwist"] = s.PathTwist;
+            row["PathTwistBegin"] = s.PathTwistBegin;
+            // profile
+            row["ProfileBegin"] = s.ProfileBegin;
+            row["ProfileEnd"] = s.ProfileEnd;
+            row["ProfileCurve"] = s.ProfileCurve;
+            row["ProfileHollow"] = s.ProfileHollow;
+            row["Texture"] = s.TextureEntry;
+            row["ExtraParams"] = s.ExtraParams;
+            try
+            {
+                row["State"] = s.State;
+            }
+            catch (MySqlException)
+            {
+                // Database table was created before we got here and needs to be created! :P
+                using (
+                    MySqlCommand cmd =
+                        new MySqlCommand(
+                            "ALTER TABLE `primshapes` ADD COLUMN `State` int NOT NULL default 0;",
+                            m_connection))
+                {
+                    cmd.ExecuteNonQuery();
+                }
+            }
+        }
+
+        private void addPrim(SceneObjectPart prim, LLUUID sceneGroupID, LLUUID regionUUID)
+        {
+            DataTable prims = m_dataSet.Tables["prims"];
+            DataTable shapes = m_dataSet.Tables["primshapes"];
+
+            DataRow primRow = prims.Rows.Find(Util.ToRawUuidString(prim.UUID));
+            if (primRow == null)
+            {
+                primRow = prims.NewRow();
+                fillPrimRow(primRow, prim, sceneGroupID, regionUUID);
+                prims.Rows.Add(primRow);
+            }
+            else
+            {
+                fillPrimRow(primRow, prim, sceneGroupID, regionUUID);
+            }
+
+            DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(prim.UUID));
+            if (shapeRow == null)
+            {
+                shapeRow = shapes.NewRow();
+                fillShapeRow(shapeRow, prim);
+                shapes.Rows.Add(shapeRow);
+            }
+            else
+            {
+                fillShapeRow(shapeRow, prim);
+            }           
+        }
+        
+        // see IRegionDatastore
+        public void StorePrimInventory(LLUUID primID, ICollection<TaskInventoryItem> items)
+        {
+            if (!persistPrimInventories)
+                return;
+                     
+            m_log.InfoFormat("[DATASTORE]: Persisting Prim Inventory with prim ID {0}", primID);
+            
+            // For now, we're just going to crudely remove all the previous inventory items 
+            // no matter whether they have changed or not, and replace them with the current set.
+            lock (m_dataSet)
+            {                              
+                RemoveItems(primID);              
+                
+                // repalce with current inventory details
+                foreach (TaskInventoryItem newItem in items)
+                {
+//                    m_log.InfoFormat(
+//                        "[DATASTORE]: " +
+//                        "Adding item {0}, {1} to prim ID {2}", 
+//                        newItem.Name, newItem.ItemID, newItem.ParentPartID);
+                    
+                    DataRow newItemRow = m_itemsTable.NewRow();
+                    fillItemRow(newItemRow, newItem);
+                    m_itemsTable.Rows.Add(newItemRow);                
+                }
+            }
+            
+            Commit();
+        }        
+
+        /***********************************************************************
+         *
+         *  SQL Statement Creation Functions
+         *
+         *  These functions create SQL statements for update, insert, and create.
+         *  They can probably be factored later to have a db independant
+         *  portion and a db specific portion
+         *
+         **********************************************************************/
+
+        private MySqlCommand createInsertCommand(string table, DataTable dt)
+        {
+            /**
+             *  This is subtle enough to deserve some commentary.
+             *  Instead of doing *lots* and *lots of hardcoded strings
+             *  for database definitions we'll use the fact that
+             *  realistically all insert statements look like "insert
+             *  into A(b, c) values(:b, :c) on the parameterized query
+             *  front.  If we just have a list of b, c, etc... we can
+             *  generate these strings instead of typing them out.
+             */
+            string[] cols = new string[dt.Columns.Count];
+            for (int i = 0; i < dt.Columns.Count; i++)
+            {
+                DataColumn col = dt.Columns[i];
+                cols[i] = col.ColumnName;
+            }
+
+            string sql = "insert into " + table + "(";
+            sql += String.Join(", ", cols);
+            // important, the first ':' needs to be here, the rest get added in the join
+            sql += ") values (?";
+            sql += String.Join(", ?", cols);
+            sql += ")";
+            MySqlCommand cmd = new MySqlCommand(sql);
+
+            // this provides the binding for all our parameters, so
+            // much less code than it used to be
+            foreach (DataColumn col in dt.Columns)
+            {
+                cmd.Parameters.Add(createMySqlParameter(col.ColumnName, col.DataType));
+            }
+            return cmd;
+        }
+
+        private MySqlCommand createUpdateCommand(string table, string pk, DataTable dt)
+        {
+            string sql = "update " + table + " set ";
+            string subsql = String.Empty;
+            foreach (DataColumn col in dt.Columns)
+            {
+                if (subsql.Length > 0)
+                {
+                    // a map function would rock so much here
+                    subsql += ", ";
+                }
+                subsql += col.ColumnName + "=?" + col.ColumnName;
+            }
+            sql += subsql;
+            sql += " where " + pk;
+            MySqlCommand cmd = new MySqlCommand(sql);
+
+            // this provides the binding for all our parameters, so
+            // much less code than it used to be
+
+            foreach (DataColumn col in dt.Columns)
+            {
+                cmd.Parameters.Add(createMySqlParameter(col.ColumnName, col.DataType));
+            }
+            return cmd;
+        }
+
+        private string defineTable(DataTable dt)
+        {
+            string sql = "create table " + dt.TableName + "(";
+            string subsql = String.Empty;
+            foreach (DataColumn col in dt.Columns)
+            {
+                if (subsql.Length > 0)
+                {
+                    // a map function would rock so much here
+                    subsql += ",\n";
+                }
+                subsql += col.ColumnName + " " + MySqlType(col.DataType);
+                if (dt.PrimaryKey.Length > 0 && col == dt.PrimaryKey[0])
+                {
+                    subsql += " primary key";
+                }
+            }
+            sql += subsql;
+            sql += ")";
+            
+            //m_log.InfoFormat("[DATASTORE]: defineTable() sql {0}", sql);
+            
+            return sql;
+        }
+
+        /***********************************************************************
+         *
+         *  Database Binding functions
+         *
+         *  These will be db specific due to typing, and minor differences
+         *  in databases.
+         *
+         **********************************************************************/
+
+        ///<summary>
+        /// This is a convenience function that collapses 5 repetitive
+        /// lines for defining MySqlParameters to 2 parameters:
+        /// column name and database type.
+        ///        
+        /// It assumes certain conventions like ?param as the param
+        /// name to replace in parametrized queries, and that source
+        /// version is always current version, both of which are fine
+        /// for us.
+        ///</summary>
+        ///<returns>a built MySql parameter</returns>
+        private MySqlParameter createMySqlParameter(string name, Type type)
+        {
+            MySqlParameter param = new MySqlParameter();
+            param.ParameterName = "?" + name;
+            param.DbType = dbtypeFromType(type);
+            param.SourceColumn = name;
+            param.SourceVersion = DataRowVersion.Current;
+            return param;
+        }
+
+// TODO: unused
+//         private MySqlParameter createParamWithValue(string name, Type type, Object o)
+//         {
+//             MySqlParameter param = createMySqlParameter(name, type);
+//             param.Value = o;
+//             return param;
+//         }
+
+        private void SetupPrimCommands(MySqlDataAdapter da, MySqlConnection conn)
+        {
+            MySqlCommand insertCommand = createInsertCommand("prims", m_primTable);
+            insertCommand.Connection = conn;
+            da.InsertCommand = insertCommand;
+
+            MySqlCommand updateCommand = createUpdateCommand("prims", "UUID=?UUID", m_primTable);
+            updateCommand.Connection = conn;
+            da.UpdateCommand = updateCommand;
+
+            MySqlCommand delete = new MySqlCommand("delete from prims where UUID=?UUID");
+            delete.Parameters.Add(createMySqlParameter("UUID", typeof (String)));
+            delete.Connection = conn;
+            da.DeleteCommand = delete;
+        }
+        
+        private void SetupItemsCommands(MySqlDataAdapter da, MySqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("primitems", m_itemsTable);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("primitems", "itemID = ?itemID", m_itemsTable);
+            da.UpdateCommand.Connection = conn;
+
+            MySqlCommand delete = new MySqlCommand("delete from primitems where itemID = ?itemID");
+            delete.Parameters.Add(createMySqlParameter("itemID", typeof (String)));
+            delete.Connection = conn;
+            da.DeleteCommand = delete;
+        }        
+
+        private void SetupTerrainCommands(MySqlDataAdapter da, MySqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("terrain", m_dataSet.Tables["terrain"]);
+            da.InsertCommand.Connection = conn;
+        }
+
+        private void setupLandCommands(MySqlDataAdapter da, MySqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("land", m_dataSet.Tables["land"]);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("land", "UUID=?UUID", m_dataSet.Tables["land"]);
+            da.UpdateCommand.Connection = conn;
+        }
+
+        private void setupLandAccessCommands(MySqlDataAdapter da, MySqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("landaccesslist", m_dataSet.Tables["landaccesslist"]);
+            da.InsertCommand.Connection = conn;
+        }
+
+        private void SetupShapeCommands(MySqlDataAdapter da, MySqlConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("primshapes", m_dataSet.Tables["primshapes"]);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("primshapes", "UUID=?UUID", m_dataSet.Tables["primshapes"]);
+            da.UpdateCommand.Connection = conn;
+
+            MySqlCommand delete = new MySqlCommand("delete from primshapes where UUID = ?UUID");
+            delete.Parameters.Add(createMySqlParameter("UUID", typeof (String)));
+            delete.Connection = conn;
+            da.DeleteCommand = delete;
+        }
+
+        private void InitDB(MySqlConnection conn)
+        {
+            string createPrims = defineTable(createPrimTable());
+            string createShapes = defineTable(createShapeTable());
+            string createItems = defineTable(createItemsTable());
+            string createTerrain = defineTable(createTerrainTable());
+            string createLand = defineTable(createLandTable());
+            string createLandAccessList = defineTable(createLandAccessListTable());
+
+            MySqlCommand pcmd = new MySqlCommand(createPrims, conn);
+            MySqlCommand scmd = new MySqlCommand(createShapes, conn);
+            MySqlCommand icmd = new MySqlCommand(createItems, conn);
+            MySqlCommand tcmd = new MySqlCommand(createTerrain, conn);
+            MySqlCommand lcmd = new MySqlCommand(createLand, conn);
+            MySqlCommand lalcmd = new MySqlCommand(createLandAccessList, conn);
+
+            if (conn.State != ConnectionState.Open)
+            {
+                try
+                {
+                    conn.Open();
+                }
+                catch (Exception ex)
+                {
+                    m_log.Error("[MySql]: Error connecting to MySQL server: " + ex.Message);
+                    m_log.Error("[MySql]: Application is terminating!");
+                    System.Threading.Thread.CurrentThread.Abort();
+                }
+            }
+
+            try
+            {
+                pcmd.ExecuteNonQuery();
+            }
+            catch (MySqlException e)
+            {
+                m_log.WarnFormat("[MySql]: Primitives Table Already Exists: {0}", e);
+            }
+
+            try
+            {
+                scmd.ExecuteNonQuery();
+            }
+            catch (MySqlException e)
+            {
+                m_log.WarnFormat("[MySql]: Shapes Table Already Exists: {0}", e);
+            }
+            
+            try
+            {
+                icmd.ExecuteNonQuery();
+            }
+            catch (MySqlException e)
+            {
+                m_log.WarnFormat("[MySql]: Items Table Already Exists: {0}", e);
+            }            
+
+            try
+            {
+                tcmd.ExecuteNonQuery();
+            }
+            catch (MySqlException e)
+            {
+                m_log.WarnFormat("[MySql]: Terrain Table Already Exists: {0}", e);
+            }
+
+            try
+            {
+                lcmd.ExecuteNonQuery();
+            }
+            catch (MySqlException e)
+            {
+                m_log.WarnFormat("[MySql]: Land Table Already Exists: {0}", e);
+            }
+
+            try
+            {
+                lalcmd.ExecuteNonQuery();
+            }
+            catch (MySqlException e)
+            {
+                m_log.WarnFormat("[MySql]: LandAccessList Table Already Exists: {0}", e);
+            }
+            conn.Close();
+        }
+
+        private bool TestTables(MySqlConnection conn)
+        {
+            MySqlCommand primSelectCmd = new MySqlCommand(m_primSelect, conn);
+            MySqlDataAdapter pDa = new MySqlDataAdapter(primSelectCmd);
+            MySqlCommand shapeSelectCmd = new MySqlCommand(m_shapeSelect, conn);
+            MySqlDataAdapter sDa = new MySqlDataAdapter(shapeSelectCmd);
+            MySqlCommand itemsSelectCmd = new MySqlCommand(m_itemsSelect, conn);
+            MySqlDataAdapter iDa = new MySqlDataAdapter(itemsSelectCmd);            
+            MySqlCommand terrainSelectCmd = new MySqlCommand(m_terrainSelect, conn);
+            MySqlDataAdapter tDa = new MySqlDataAdapter(terrainSelectCmd);
+            MySqlCommand landSelectCmd = new MySqlCommand(m_landSelect, conn);
+            MySqlDataAdapter lDa = new MySqlDataAdapter(landSelectCmd);
+            MySqlCommand landAccessListSelectCmd = new MySqlCommand(m_landAccessListSelect, conn);
+            MySqlDataAdapter lalDa = new MySqlDataAdapter(landAccessListSelectCmd);
+
+            DataSet tmpDS = new DataSet();
+            try
+            {
+                pDa.Fill(tmpDS, "prims");
+                sDa.Fill(tmpDS, "primshapes");
+                
+                if (persistPrimInventories)
+                    iDa.Fill(tmpDS, "primitems");
+                
+                tDa.Fill(tmpDS, "terrain");
+                lDa.Fill(tmpDS, "land");
+                lalDa.Fill(tmpDS, "landaccesslist");
+            }
+            catch (MySqlException)
+            {
+                m_log.Info("[DATASTORE]: MySql Database doesn't exist... creating");
+                InitDB(conn);
+            }
+
+            pDa.Fill(tmpDS, "prims");
+            sDa.Fill(tmpDS, "primshapes");
+            
+            if (persistPrimInventories)
+                iDa.Fill(tmpDS, "primitems");
+            
+            tDa.Fill(tmpDS, "terrain");
+            lDa.Fill(tmpDS, "land");
+            lalDa.Fill(tmpDS, "landaccesslist");
+
+            foreach (DataColumn col in createPrimTable().Columns)
+            {
+                if (!tmpDS.Tables["prims"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing required column:" + col.ColumnName);
+                    return false;
+                }
+            }
+            
+            foreach (DataColumn col in createShapeTable().Columns)
+            {
+                if (!tmpDS.Tables["primshapes"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing required column:" + col.ColumnName);
+                    return false;
+                }
+            }
+            
+            // XXX primitems should probably go here eventually
+            
+            foreach (DataColumn col in createTerrainTable().Columns)
+            {
+                if (!tmpDS.Tables["terrain"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing require column:" + col.ColumnName);
+                    return false;
+                }
+            }
+            
+            foreach (DataColumn col in createLandTable().Columns)
+            {
+                if (!tmpDS.Tables["land"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing require column:" + col.ColumnName);
+                    return false;
+                }
+            }
+            
+            foreach (DataColumn col in createLandAccessListTable().Columns)
+            {
+                if (!tmpDS.Tables["landaccesslist"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing require column:" + col.ColumnName);
+                    return false;
+                }
+            }
+            
+            return true;
+        }
+
+        /***********************************************************************
+         *
+         *  Type conversion functions
+         *
+         **********************************************************************/
+
+        private DbType dbtypeFromType(Type type)
+        {
+            if (type == typeof (String))
+            {
+                return DbType.String;
+            }
+            else if (type == typeof (Int32))
+            {
+                return DbType.Int32;
+            }
+            else if (type == typeof (Double))
+            {
+                return DbType.Double;
+            }
+            else if (type == typeof (Byte))
+            {
+                return DbType.Byte;
+            }
+            else if (type == typeof (Double))
+            {
+                return DbType.Double;
+            }
+            else if (type == typeof (Byte[]))
+            {
+                return DbType.Binary;
+            }
+            else
+            {
+                return DbType.String;
+            }
+        }
+
+        // this is something we'll need to implement for each db
+        // slightly differently.
+        private string MySqlType(Type type)
+        {
+            if (type == typeof (String))
+            {
+                return "varchar(255)";
+            }
+            else if (type == typeof (Int32))
+            {
+                return "integer";
+            }
+            else if (type == typeof (Int64))
+            {
+                return "bigint";
+            }            
+            else if (type == typeof (Double))
+            {
+                return "float";
+            }
+            else if (type == typeof (Byte[]))
+            {
+                return "longblob";
+            }
+            else
+            {
+                return "string";
+            }
+        }
+    }
+}
diff --git a/OpenSim/Data/MySQL/MySQLGridData.cs b/OpenSim/Data/MySQL/MySQLGridData.cs
new file mode 100644
index 0000000..61ab067
--- /dev/null
+++ b/OpenSim/Data/MySQL/MySQLGridData.cs
@@ -0,0 +1,402 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.RegularExpressions;
+using libsecondlife;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.MySQL
+{
+    /// <summary>
+    /// A MySQL Interface for the Grid Server
+    /// </summary>
+    public class MySQLGridData : GridDataBase
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// MySQL Database Manager
+        /// </summary>
+        private MySQLManager database;
+
+        /// <summary>
+        /// Initialises the Grid Interface
+        /// </summary>
+        override public void Initialise()
+        {
+            IniFile GridDataMySqlFile = new IniFile("mysql_connection.ini");
+            string settingHostname = GridDataMySqlFile.ParseFileReadValue("hostname");
+            string settingDatabase = GridDataMySqlFile.ParseFileReadValue("database");
+            string settingUsername = GridDataMySqlFile.ParseFileReadValue("username");
+            string settingPassword = GridDataMySqlFile.ParseFileReadValue("password");
+            string settingPooling = GridDataMySqlFile.ParseFileReadValue("pooling");
+            string settingPort = GridDataMySqlFile.ParseFileReadValue("port");
+
+            database =
+                new MySQLManager(settingHostname, settingDatabase, settingUsername, settingPassword, settingPooling,
+                                 settingPort);
+
+            TestTables();
+        }
+
+        #region Test and initialization code
+
+        /// <summary>
+        /// Ensure that the user related tables exists and are at the latest version
+        /// </summary>
+        private void TestTables()
+        {
+            Dictionary<string, string> tableList = new Dictionary<string, string>();
+
+            tableList["regions"] = null;
+            database.GetTableVersion(tableList);
+
+            UpgradeRegionsTable(tableList["regions"]);
+        }
+
+        /// <summary>
+        /// Create or upgrade the table if necessary
+        /// </summary>
+        /// <param name="oldVersion">A null indicates that the table does not
+        /// currently exist</param>
+        private void UpgradeRegionsTable(string oldVersion)
+        {
+            // null as the version, indicates that the table didn't exist
+            if (oldVersion == null)
+            {
+                database.ExecuteResourceSql("CreateRegionsTable.sql");
+                return;
+            }
+            if (oldVersion.Contains("Rev. 1"))
+            {
+                database.ExecuteResourceSql("UpgradeRegionsTableToVersion2.sql");
+                return;
+            }
+            if (oldVersion.Contains("Rev. 2"))
+            {
+                database.ExecuteResourceSql("UpgradeRegionsTableToVersion3.sql");
+                return;
+            }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Shuts down the grid interface
+        /// </summary>
+        override public void Close()
+        {
+            database.Close();
+        }
+
+        /// <summary>
+        /// Returns the plugin name
+        /// </summary>
+        /// <returns>Plugin name</returns>
+        override public string getName()
+        {
+            return "MySql OpenGridData";
+        }
+
+        /// <summary>
+        /// Returns the plugin version
+        /// </summary>
+        /// <returns>Plugin version</returns>
+        override public string getVersion()
+        {
+            return "0.1";
+        }
+
+        /// <summary>
+        /// Returns all the specified region profiles within coordates -- coordinates are inclusive
+        /// </summary>
+        /// <param name="xmin">Minimum X coordinate</param>
+        /// <param name="ymin">Minimum Y coordinate</param>
+        /// <param name="xmax">Maximum X coordinate</param>
+        /// <param name="ymax">Maximum Y coordinate</param>
+        /// <returns></returns>
+        override public RegionProfileData[] GetProfilesInRange(uint xmin, uint ymin, uint xmax, uint ymax)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["?xmin"] = xmin.ToString();
+                    param["?ymin"] = ymin.ToString();
+                    param["?xmax"] = xmax.ToString();
+                    param["?ymax"] = ymax.ToString();
+
+                    IDbCommand result =
+                        database.Query(
+                            "SELECT * FROM regions WHERE locX >= ?xmin AND locX <= ?xmax AND locY >= ?ymin AND locY <= ?ymax",
+                            param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    RegionProfileData row;
+
+                    List<RegionProfileData> rows = new List<RegionProfileData>();
+
+                    while ((row = database.readSimRow(reader)) != null)
+                    {
+                        rows.Add(row);
+                    }
+                    reader.Close();
+                    result.Dispose();
+
+                    return rows.ToArray();
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a sim profile from it's location
+        /// </summary>
+        /// <param name="handle">Region location handle</param>
+        /// <returns>Sim profile</returns>
+        override public RegionProfileData GetProfileByHandle(ulong handle)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["?handle"] = handle.ToString();
+
+                    IDbCommand result = database.Query("SELECT * FROM regions WHERE regionHandle = ?handle", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    RegionProfileData row = database.readSimRow(reader);
+                    reader.Close();
+                    result.Dispose();
+
+                    return row;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+       
+        /// <summary>
+        /// Returns a sim profile from it's UUID
+        /// </summary>
+        /// <param name="uuid">The region UUID</param>
+        /// <returns>The sim profile</returns>
+        override public RegionProfileData GetProfileByLLUUID(LLUUID uuid)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["?uuid"] = uuid.ToString();
+
+                    IDbCommand result = database.Query("SELECT * FROM regions WHERE uuid = ?uuid", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    RegionProfileData row = database.readSimRow(reader);
+                    reader.Close();
+                    result.Dispose();
+
+                    return row;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a sim profile from it's Region name string
+        /// </summary>
+        /// <param name="uuid">The region name search query</param>
+        /// <returns>The sim profile</returns>
+        override public RegionProfileData GetProfileByString(string regionName)
+        {
+            if (regionName.Length > 2)
+            {
+                try
+                {
+                    lock (database)
+                    {
+                        Dictionary<string, string> param = new Dictionary<string, string>();
+                        // Add % because this is a like query.
+                        param["?regionName"] = regionName + "%";
+                        // Order by statement will return shorter matches first.  Only returns one record or no record.
+                        IDbCommand result = database.Query("SELECT * FROM regions WHERE regionName like ?regionName order by LENGTH(regionName) asc LIMIT 1", param);
+                        IDataReader reader = result.ExecuteReader();
+
+                        RegionProfileData row = database.readSimRow(reader);
+                        reader.Close();
+                        result.Dispose();
+
+                        return row;
+                    }
+                }
+                catch (Exception e)
+                {
+                    database.Reconnect();
+                    m_log.Error(e.ToString());
+                    return null;
+                }
+            }
+            else
+            {
+                m_log.Error("[DATABASE]: Searched for a Region Name shorter then 3 characters");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Adds a new profile to the database
+        /// </summary>
+        /// <param name="profile">The profile to add</param>
+        /// <returns>Successful?</returns>
+        override public DataResponse AddProfile(RegionProfileData profile)
+        {
+            lock (database)
+            {
+                if (database.insertRegion(profile))
+                {
+                    return DataResponse.RESPONSE_OK;
+                }
+                else
+                {
+                    return DataResponse.RESPONSE_ERROR;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Deletes a profile from the database
+        /// </summary>
+        /// <param name="profile">The profile to delete</param>
+        /// <returns>Successful?</returns>
+        //public DataResponse DeleteProfile(RegionProfileData profile)
+        public DataResponse DeleteProfile(string uuid)
+        {
+            lock (database)
+            {
+                if (database.deleteRegion(uuid))
+                {
+                    return DataResponse.RESPONSE_OK;
+                }
+                else
+                {
+                    return DataResponse.RESPONSE_ERROR;
+                }
+            }
+        }
+
+        /// <summary>
+        /// DEPRECATED. Attempts to authenticate a region by comparing a shared secret.
+        /// </summary>
+        /// <param name="uuid">The UUID of the challenger</param>
+        /// <param name="handle">The attempted regionHandle of the challenger</param>
+        /// <param name="authkey">The secret</param>
+        /// <returns>Whether the secret and regionhandle match the database entry for UUID</returns>
+        override public bool AuthenticateSim(LLUUID uuid, ulong handle, string authkey)
+        {
+            bool throwHissyFit = false; // Should be true by 1.0
+
+            if (throwHissyFit)
+                throw new Exception("CRYPTOWEAK AUTHENTICATE: Refusing to authenticate due to replay potential.");
+
+            RegionProfileData data = GetProfileByLLUUID(uuid);
+
+            return (handle == data.regionHandle && authkey == data.regionSecret);
+        }
+
+        /// <summary>
+        /// NOT YET FUNCTIONAL. Provides a cryptographic authentication of a region
+        /// </summary>
+        /// <remarks>This requires a security audit.</remarks>
+        /// <param name="uuid"></param>
+        /// <param name="handle"></param>
+        /// <param name="authhash"></param>
+        /// <param name="challenge"></param>
+        /// <returns></returns>
+        public bool AuthenticateSim(LLUUID uuid, ulong handle, string authhash, string challenge)
+        {
+            SHA512Managed HashProvider = new SHA512Managed();
+            ASCIIEncoding TextProvider = new ASCIIEncoding();
+
+            byte[] stream = TextProvider.GetBytes(uuid.ToString() + ":" + handle.ToString() + ":" + challenge);
+            byte[] hash = HashProvider.ComputeHash(stream);
+
+            return false;
+        }
+
+        override public ReservationData GetReservationAtPoint(uint x, uint y)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["?x"] = x.ToString();
+                    param["?y"] = y.ToString();
+                    IDbCommand result =
+                        database.Query(
+                            "SELECT * FROM reservations WHERE resXMin <= ?x AND resXMax >= ?x AND resYMin <= ?y AND resYMax >= ?y",
+                            param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    ReservationData row = database.readReservationRow(reader);
+                    reader.Close();
+                    result.Dispose();
+
+                    return row;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+    }
+}
diff --git a/OpenSim/Data/MySQL/MySQLInventoryData.cs b/OpenSim/Data/MySQL/MySQLInventoryData.cs
new file mode 100644
index 0000000..4165d8f
--- /dev/null
+++ b/OpenSim/Data/MySQL/MySQLInventoryData.cs
@@ -0,0 +1,648 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using libsecondlife;
+using MySql.Data.MySqlClient;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.MySQL
+{
+    /// <summary>
+    /// A MySQL interface for the inventory server
+    /// </summary>
+    public class MySQLInventoryData : IInventoryData
+    {
+        private static readonly log4net.ILog m_log 
+            = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// The database manager
+        /// </summary>
+        private MySQLManager database;
+
+        /// <summary>
+        /// Loads and initialises this database plugin
+        /// </summary>
+        public void Initialise()
+        {
+            IniFile GridDataMySqlFile = new IniFile("mysql_connection.ini");
+            string settingHostname = GridDataMySqlFile.ParseFileReadValue("hostname");
+            string settingDatabase = GridDataMySqlFile.ParseFileReadValue("database");
+            string settingUsername = GridDataMySqlFile.ParseFileReadValue("username");
+            string settingPassword = GridDataMySqlFile.ParseFileReadValue("password");
+            string settingPooling = GridDataMySqlFile.ParseFileReadValue("pooling");
+            string settingPort = GridDataMySqlFile.ParseFileReadValue("port");
+
+            database =
+                new MySQLManager(settingHostname, settingDatabase, settingUsername, settingPassword, settingPooling,
+                                 settingPort);
+            TestTables(database.Connection);
+        }
+
+        #region Test and initialization code
+
+        private void UpgradeFoldersTable(string oldVersion)
+        {
+            // null as the version, indicates that the table didn't exist
+            if (oldVersion == null)
+            {
+                database.ExecuteResourceSql("CreateFoldersTable.sql");
+                return;
+            }
+
+            // if the table is already at the current version, then we can exit immediately
+//             if (oldVersion == "Rev. 2")
+//                 return;
+
+//             database.ExecuteResourceSql("UpgradeFoldersTableToVersion2.sql");
+        }
+
+        private void UpgradeItemsTable(string oldVersion)
+        {
+            // null as the version, indicates that the table didn't exist
+            if (oldVersion == null)
+            {
+                database.ExecuteResourceSql("CreateItemsTable.sql");
+                return;
+            }
+
+            // if the table is already at the current version, then we can exit immediately
+//             if (oldVersion == "Rev. 2")
+//                 return;
+
+//             database.ExecuteResourceSql("UpgradeItemsTableToVersion2.sql");
+        }
+
+        private void TestTables(MySqlConnection conn)
+        {
+            Dictionary<string, string> tableList = new Dictionary<string, string>();
+
+            tableList["inventoryfolders"] = null;
+            tableList["inventoryitems"] = null;
+
+            database.GetTableVersion(tableList);
+            m_log.Info("[MYSQL]: Inventory Folder Version: " + tableList["inventoryfolders"]);
+            m_log.Info("[MYSQL]: Inventory Items Version: " + tableList["inventoryitems"]);
+
+            UpgradeFoldersTable(tableList["inventoryfolders"]);
+            UpgradeItemsTable(tableList["inventoryitems"]);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// The name of this DB provider
+        /// </summary>
+        /// <returns>Name of DB provider</returns>
+        public string getName()
+        {
+            return "MySQL Inventory Data Interface";
+        }
+
+        /// <summary>
+        /// Closes this DB provider
+        /// </summary>
+        public void Close()
+        {
+            // Do nothing.
+        }
+
+        /// <summary>
+        /// Returns the version of this DB provider
+        /// </summary>
+        /// <returns>A string containing the DB provider</returns>
+        public string getVersion()
+        {
+            return database.getVersion();
+        }
+
+        /// <summary>
+        /// Returns a list of items in a specified folder
+        /// </summary>
+        /// <param name="folderID">The folder to search</param>
+        /// <returns>A list containing inventory items</returns>
+        public List<InventoryItemBase> getInventoryInFolder(LLUUID folderID)
+        {
+            try
+            {
+                lock (database)
+                {
+                    List<InventoryItemBase> items = new List<InventoryItemBase>();
+
+                    MySqlCommand result =
+                        new MySqlCommand("SELECT * FROM inventoryitems WHERE parentFolderID = ?uuid",
+                                         database.Connection);
+                    result.Parameters.AddWithValue("?uuid", folderID.ToString());
+                    MySqlDataReader reader = result.ExecuteReader();
+
+                    while (reader.Read())
+                        items.Add(readInventoryItem(reader));
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return items;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a list of the root folders within a users inventory
+        /// </summary>
+        /// <param name="user">The user whos inventory is to be searched</param>
+        /// <returns>A list of folder objects</returns>
+        public List<InventoryFolderBase> getUserRootFolders(LLUUID user)
+        {
+            try
+            {
+                lock (database)
+                {
+                    MySqlCommand result =
+                        new MySqlCommand(
+                            "SELECT * FROM inventoryfolders WHERE parentFolderID = ?zero AND agentID = ?uuid",
+                            database.Connection);
+                    result.Parameters.AddWithValue("?uuid", user.ToString());
+                    result.Parameters.AddWithValue("?zero", LLUUID.Zero.ToString());
+                    MySqlDataReader reader = result.ExecuteReader();
+
+                    List<InventoryFolderBase> items = new List<InventoryFolderBase>();
+                    while (reader.Read())
+                        items.Add(readInventoryFolder(reader));
+
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return items;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        // see InventoryItemBase.getUserRootFolder
+        public InventoryFolderBase getUserRootFolder(LLUUID user)
+        {
+            try
+            {
+                lock (database)
+                {
+                    MySqlCommand result =
+                        new MySqlCommand(
+                            "SELECT * FROM inventoryfolders WHERE parentFolderID = ?zero AND agentID = ?uuid",
+                            database.Connection);
+                    result.Parameters.AddWithValue("?uuid", user.ToString());
+                    result.Parameters.AddWithValue("?zero", LLUUID.Zero.ToString());
+
+                    MySqlDataReader reader = result.ExecuteReader();
+
+                    List<InventoryFolderBase> items = new List<InventoryFolderBase>();
+                    while (reader.Read())
+                        items.Add(readInventoryFolder(reader));
+
+                    InventoryFolderBase rootFolder = null;
+
+                    // There should only ever be one root folder for a user.  However, if there's more
+                    // than one we'll simply use the first one rather than failing.  It would be even
+                    // nicer to print some message to this effect, but this feels like it's too low a 
+                    // to put such a message out, and it's too minor right now to spare the time to
+                    // suitably refactor.
+                    if (items.Count > 0)
+                    {
+                        rootFolder = items[0];
+                    }
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return rootFolder;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Return a list of folders in a users inventory contained within the specified folder.
+        /// This method is only used in tests - in normal operation the user always have one,
+        /// and only one, root folder.
+        /// </summary>
+        /// <param name="parentID">The folder to search</param>
+        /// <returns>A list of inventory folders</returns>
+        public List<InventoryFolderBase> getInventoryFolders(LLUUID parentID)
+        {
+            try
+            {
+                lock (database)
+                {
+                    MySqlCommand result =
+                        new MySqlCommand("SELECT * FROM inventoryfolders WHERE parentFolderID = ?uuid",
+                                         database.Connection);
+                    result.Parameters.AddWithValue("?uuid", parentID.ToString());
+                    MySqlDataReader reader = result.ExecuteReader();
+
+                    List<InventoryFolderBase> items = new List<InventoryFolderBase>();
+
+                    while (reader.Read())
+                        items.Add(readInventoryFolder(reader));
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return items;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Reads a one item from an SQL result
+        /// </summary>
+        /// <param name="reader">The SQL Result</param>
+        /// <returns>the item read</returns>
+        private InventoryItemBase readInventoryItem(MySqlDataReader reader)
+        {
+            try
+            {
+                InventoryItemBase item = new InventoryItemBase();
+
+                item.inventoryID = new LLUUID((string) reader["inventoryID"]);
+                item.assetID = new LLUUID((string) reader["assetID"]);
+                item.assetType = (int) reader["assetType"];
+                item.parentFolderID = new LLUUID((string) reader["parentFolderID"]);
+                item.avatarID = new LLUUID((string) reader["avatarID"]);
+                item.inventoryName = (string) reader["inventoryName"];
+                item.inventoryDescription = (string) reader["inventoryDescription"];
+                item.inventoryNextPermissions = (uint) reader["inventoryNextPermissions"];
+                item.inventoryCurrentPermissions = (uint) reader["inventoryCurrentPermissions"];
+                item.invType = (int) reader["invType"];
+                item.creatorsID = new LLUUID((string) reader["creatorID"]);
+                item.inventoryBasePermissions = (uint) reader["inventoryBasePermissions"];
+                item.inventoryEveryOnePermissions = (uint) reader["inventoryEveryOnePermissions"];
+                return item;
+            }
+            catch (MySqlException e)
+            {
+                m_log.Error(e.ToString());
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a specified inventory item
+        /// </summary>
+        /// <param name="item">The item to return</param>
+        /// <returns>An inventory item</returns>
+        public InventoryItemBase getInventoryItem(LLUUID itemID)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+
+                    MySqlCommand result =
+                        new MySqlCommand("SELECT * FROM inventoryitems WHERE inventoryID = ?uuid", database.Connection);
+                    result.Parameters.AddWithValue("?uuid", itemID.ToString());
+                    MySqlDataReader reader = result.ExecuteReader();
+
+                    InventoryItemBase item = null;
+                    if (reader.Read())
+                        item = readInventoryItem(reader);
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return item;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Reads a list of inventory folders returned by a query.
+        /// </summary>
+        /// <param name="reader">A MySQL Data Reader</param>
+        /// <returns>A List containing inventory folders</returns>
+        protected InventoryFolderBase readInventoryFolder(MySqlDataReader reader)
+        {
+            try
+            {
+                InventoryFolderBase folder = new InventoryFolderBase();
+                folder.agentID = new LLUUID((string) reader["agentID"]);
+                folder.parentID = new LLUUID((string) reader["parentFolderID"]);
+                folder.folderID = new LLUUID((string) reader["folderID"]);
+                folder.name = (string) reader["folderName"];
+                folder.type = (short) reader["type"];
+                folder.version = (ushort) ((int) reader["version"]);
+                return folder;
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+            }
+
+            return null;
+        }
+
+
+        /// <summary>
+        /// Returns a specified inventory folder
+        /// </summary>
+        /// <param name="folder">The folder to return</param>
+        /// <returns>A folder class</returns>
+        public InventoryFolderBase getInventoryFolder(LLUUID folderID)
+        {
+            try
+            {
+                lock (database)
+                {
+                    MySqlCommand result =
+                        new MySqlCommand("SELECT * FROM inventoryfolders WHERE folderID = ?uuid", database.Connection);
+                    result.Parameters.AddWithValue("?uuid", folderID.ToString());
+                    MySqlDataReader reader = result.ExecuteReader();
+
+                    reader.Read();
+                    InventoryFolderBase folder = readInventoryFolder(reader);
+                    reader.Close();
+                    result.Dispose();
+
+                    return folder;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Adds a specified item to the database
+        /// </summary>
+        /// <param name="item">The inventory item</param>
+        public void addInventoryItem(InventoryItemBase item)
+        {
+            string sql =
+                "REPLACE INTO inventoryitems (inventoryID, assetID, assetType, parentFolderID, avatarID, inventoryName, inventoryDescription, inventoryNextPermissions, inventoryCurrentPermissions, invType, creatorID, inventoryBasePermissions, inventoryEveryOnePermissions) VALUES ";
+            sql +=
+                "(?inventoryID, ?assetID, ?assetType, ?parentFolderID, ?avatarID, ?inventoryName, ?inventoryDescription, ?inventoryNextPermissions, ?inventoryCurrentPermissions, ?invType, ?creatorID, ?inventoryBasePermissions, ?inventoryEveryOnePermissions)";
+
+            try
+            {
+                MySqlCommand result = new MySqlCommand(sql, database.Connection);
+                result.Parameters.AddWithValue("?inventoryID", item.inventoryID.ToString());
+                result.Parameters.AddWithValue("?assetID", item.assetID.ToString());
+                result.Parameters.AddWithValue("?assetType", item.assetType.ToString());
+                result.Parameters.AddWithValue("?parentFolderID", item.parentFolderID.ToString());
+                result.Parameters.AddWithValue("?avatarID", item.avatarID.ToString());
+                result.Parameters.AddWithValue("?inventoryName", item.inventoryName);
+                result.Parameters.AddWithValue("?inventoryDescription", item.inventoryDescription);
+                result.Parameters.AddWithValue("?inventoryNextPermissions", item.inventoryNextPermissions.ToString());
+                result.Parameters.AddWithValue("?inventoryCurrentPermissions",
+                                               item.inventoryCurrentPermissions.ToString());
+                result.Parameters.AddWithValue("?invType", item.invType);
+                result.Parameters.AddWithValue("?creatorID", item.creatorsID.ToString());
+                result.Parameters.AddWithValue("?inventoryBasePermissions", item.inventoryBasePermissions);
+                result.Parameters.AddWithValue("?inventoryEveryOnePermissions", item.inventoryEveryOnePermissions);
+                result.ExecuteNonQuery();
+                result.Dispose();
+            }
+            catch (MySqlException e)
+            {
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Updates the specified inventory item
+        /// </summary>
+        /// <param name="item">Inventory item to update</param>
+        public void updateInventoryItem(InventoryItemBase item)
+        {
+            addInventoryItem(item);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="item"></param>
+        public void deleteInventoryItem(LLUUID itemID)
+        {
+            try
+            {
+                MySqlCommand cmd =
+                    new MySqlCommand("DELETE FROM inventoryitems WHERE inventoryID=?uuid", database.Connection);
+                cmd.Parameters.AddWithValue("?uuid", itemID.ToString());
+                cmd.ExecuteNonQuery();
+            }
+            catch (MySqlException e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Creates a new inventory folder
+        /// </summary>
+        /// <param name="folder">Folder to create</param>
+        public void addInventoryFolder(InventoryFolderBase folder)
+        {
+            string sql =
+                "REPLACE INTO inventoryfolders (folderID, agentID, parentFolderID, folderName, type, version) VALUES ";
+            sql += "(?folderID, ?agentID, ?parentFolderID, ?folderName, ?type, ?version)";
+
+            MySqlCommand cmd = new MySqlCommand(sql, database.Connection);
+            cmd.Parameters.AddWithValue("?folderID", folder.folderID.ToString());
+            cmd.Parameters.AddWithValue("?agentID", folder.agentID.ToString());
+            cmd.Parameters.AddWithValue("?parentFolderID", folder.parentID.ToString());
+            cmd.Parameters.AddWithValue("?folderName", folder.name);
+            cmd.Parameters.AddWithValue("?type", (short) folder.type);
+            cmd.Parameters.AddWithValue("?version", folder.version);
+
+            try
+            {
+                lock (database)
+                {
+                    cmd.ExecuteNonQuery();
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Updates an inventory folder
+        /// </summary>
+        /// <param name="folder">Folder to update</param>
+        public void updateInventoryFolder(InventoryFolderBase folder)
+        {
+            addInventoryFolder(folder);
+        }
+
+        /// Creates a new inventory folder
+        /// </summary>
+        /// <param name="folder">Folder to create</param>
+        public void moveInventoryFolder(InventoryFolderBase folder)
+        {
+            string sql =
+                "UPDATE inventoryfolders SET parentFolderID=?parentFolderID WHERE folderID=?folderID";
+
+            MySqlCommand cmd = new MySqlCommand(sql, database.Connection);
+            cmd.Parameters.AddWithValue("?folderID", folder.folderID.ToString());
+            cmd.Parameters.AddWithValue("?parentFolderID", folder.parentID.ToString());
+
+            try
+            {
+                lock (database)
+                {
+                    cmd.ExecuteNonQuery();
+                }
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Append a list of all the child folders of a parent folder 
+        /// </summary>
+        /// <param name="folders">list where folders will be appended</param>
+        /// <param name="parentID">ID of parent</param>
+        protected void getInventoryFolders(ref List<InventoryFolderBase> folders, LLUUID parentID)
+        {
+            List<InventoryFolderBase> subfolderList = getInventoryFolders(parentID);
+
+            foreach (InventoryFolderBase f in subfolderList)
+                folders.Add(f);
+        }
+
+        // See IInventoryData
+        public List<InventoryFolderBase> getFolderHierarchy(LLUUID parentID)
+        {
+            List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
+            getInventoryFolders(ref folders, parentID);
+
+            for (int i = 0; i < folders.Count; i++)
+                getInventoryFolders(ref folders, folders[i].folderID);
+
+            return folders;
+        }
+
+        protected void deleteOneFolder(LLUUID folderID)
+        {
+            try
+            {                
+                MySqlCommand cmd =
+                    new MySqlCommand("DELETE FROM inventoryfolders WHERE folderID=?uuid", database.Connection);
+                cmd.Parameters.AddWithValue("?uuid", folderID.ToString());
+                
+                lock (database)
+                {
+                    cmd.ExecuteNonQuery();
+                }
+            }
+            catch (MySqlException e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+        }
+
+        protected void deleteItemsInFolder(LLUUID folderID)
+        {
+            try
+            {
+                MySqlCommand cmd =
+                    new MySqlCommand("DELETE FROM inventoryitems WHERE parentFolderID=?uuid", database.Connection);
+                cmd.Parameters.AddWithValue("?uuid", folderID.ToString());
+                
+                lock (database)
+                {
+                    cmd.ExecuteNonQuery();
+                }
+            }
+            catch (MySqlException e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Delete an inventory folder
+        /// </summary>
+        /// <param name="folderId">Id of folder to delete</param>
+        public void deleteInventoryFolder(LLUUID folderID)
+        {
+            List<InventoryFolderBase> subFolders = getFolderHierarchy(folderID);
+
+            //Delete all sub-folders
+            foreach (InventoryFolderBase f in subFolders)
+            {
+                deleteOneFolder(f.folderID);
+                deleteItemsInFolder(f.folderID);
+            }
+
+            //Delete the actual row
+            deleteOneFolder(folderID);
+            deleteItemsInFolder(folderID);
+        }
+    }
+}
diff --git a/OpenSim/Data/MySQL/MySQLLogData.cs b/OpenSim/Data/MySQL/MySQLLogData.cs
new file mode 100644
index 0000000..480446f
--- /dev/null
+++ b/OpenSim/Data/MySQL/MySQLLogData.cs
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+namespace OpenSim.Framework.Data.MySQL
+{
+    /// <summary>
+    /// An interface to the log database for MySQL
+    /// </summary>
+    internal class MySQLLogData : ILogData
+    {
+        /// <summary>
+        /// The database manager
+        /// </summary>
+        public MySQLManager database;
+
+        /// <summary>
+        /// Artificial constructor called when the plugin is loaded
+        /// </summary>
+        public void Initialise()
+        {
+            IniFile GridDataMySqlFile = new IniFile("mysql_connection.ini");
+            string settingHostname = GridDataMySqlFile.ParseFileReadValue("hostname");
+            string settingDatabase = GridDataMySqlFile.ParseFileReadValue("database");
+            string settingUsername = GridDataMySqlFile.ParseFileReadValue("username");
+            string settingPassword = GridDataMySqlFile.ParseFileReadValue("password");
+            string settingPooling = GridDataMySqlFile.ParseFileReadValue("pooling");
+            string settingPort = GridDataMySqlFile.ParseFileReadValue("port");
+
+            database =
+                new MySQLManager(settingHostname, settingDatabase, settingUsername, settingPassword, settingPooling,
+                                 settingPort);
+        }
+
+        /// <summary>
+        /// Saves a log item to the database
+        /// </summary>
+        /// <param name="serverDaemon">The daemon triggering the event</param>
+        /// <param name="target">The target of the action (region / agent UUID, etc)</param>
+        /// <param name="methodCall">The method call where the problem occured</param>
+        /// <param name="arguments">The arguments passed to the method</param>
+        /// <param name="priority">How critical is this?</param>
+        /// <param name="logMessage">The message to log</param>
+        public void saveLog(string serverDaemon, string target, string methodCall, string arguments, int priority,
+                            string logMessage)
+        {
+            try
+            {
+                database.insertLogRow(serverDaemon, target, methodCall, arguments, priority, logMessage);
+            }
+            catch
+            {
+                database.Reconnect();
+            }
+        }
+
+        /// <summary>
+        /// Returns the name of this DB provider
+        /// </summary>
+        /// <returns>A string containing the DB provider name</returns>
+        public string getName()
+        {
+            return "MySQL Logdata Interface";
+        }
+
+        /// <summary>
+        /// Closes the database provider
+        /// </summary>
+        public void Close()
+        {
+            // Do nothing.
+        }
+
+        /// <summary>
+        /// Returns the version of this DB provider
+        /// </summary>
+        /// <returns>A string containing the provider version</returns>
+        public string getVersion()
+        {
+            return "0.1";
+        }
+    }
+}
diff --git a/OpenSim/Data/MySQL/MySQLManager.cs b/OpenSim/Data/MySQL/MySQLManager.cs
new file mode 100644
index 0000000..579667b
--- /dev/null
+++ b/OpenSim/Data/MySQL/MySQLManager.cs
@@ -0,0 +1,909 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SqlClient;
+using System.IO;
+using System.Reflection;
+using libsecondlife;
+using MySql.Data.MySqlClient;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.MySQL
+{
+    /// <summary>
+    /// A MySQL Database manager
+    /// </summary>
+    internal class MySQLManager
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// The database connection object
+        /// </summary>
+        private MySqlConnection dbcon;
+
+        /// <summary>
+        /// Connection string for ADO.net
+        /// </summary>
+        private string connectionString;
+
+        /// <summary>
+        /// Initialises and creates a new MySQL connection and maintains it.
+        /// </summary>
+        /// <param name="hostname">The MySQL server being connected to</param>
+        /// <param name="database">The name of the MySQL database being used</param>
+        /// <param name="username">The username logging into the database</param>
+        /// <param name="password">The password for the user logging in</param>
+        /// <param name="cpooling">Whether to use connection pooling or not, can be one of the following: 'yes', 'true', 'no' or 'false', if unsure use 'false'.</param>
+        public MySQLManager(string hostname, string database, string username, string password, string cpooling,
+                            string port)
+        {
+            try
+            {
+                connectionString = "Server=" + hostname + ";Port=" + port + ";Database=" + database + ";User ID=" +
+                                   username + ";Password=" + password + ";Pooling=" + cpooling + ";";
+                dbcon = new MySqlConnection(connectionString);
+
+                try
+                {
+                    dbcon.Open();
+                }
+                catch(Exception e)
+                {
+                    throw new Exception( "Connection error while using connection string ["+connectionString+"]", e );
+                }
+
+                m_log.Info("[MYSQL]: Connection established");
+            }
+            catch (Exception e)
+            {
+                throw new Exception("Error initialising MySql Database: " + e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Get the connection being used
+        /// </summary>
+        public MySqlConnection Connection
+        {
+            get { return dbcon; }
+        }
+
+        /// <summary>
+        /// Shuts down the database connection
+        /// </summary>
+        public void Close()
+        {
+            dbcon.Close();
+            dbcon = null;
+        }
+
+        /// <summary>
+        /// Reconnects to the database
+        /// </summary>
+        public void Reconnect()
+        {
+            lock (dbcon)
+            {
+                try
+                {
+                    // Close the DB connection
+                    dbcon.Close();
+                    // Try reopen it
+                    dbcon = new MySqlConnection(connectionString);
+                    dbcon.Open();
+                }
+                catch (Exception e)
+                {
+                    m_log.Error("Unable to reconnect to database " + e.ToString());
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns the version of this DB provider
+        /// </summary>
+        /// <returns>A string containing the DB provider</returns>
+        public string getVersion()
+        {
+            Module module = GetType().Module;
+            string dllName = module.Assembly.ManifestModule.Name;
+            Version dllVersion = module.Assembly.GetName().Version;
+
+            return
+                string.Format("{0}.{1}.{2}.{3}", dllVersion.Major, dllVersion.Minor, dllVersion.Build,
+                              dllVersion.Revision);
+        }
+
+        /// <summary>
+        /// Extract a named string resource from the embedded resources
+        /// </summary>
+        /// <param name="name">name of embedded resource</param>
+        /// <returns>string contained within the embedded resource</returns>
+        private string getResourceString(string name)
+        {
+            Assembly assem = GetType().Assembly;
+            string[] names = assem.GetManifestResourceNames();
+
+            foreach (string s in names)
+            {
+                if (s.EndsWith(name))
+                {
+                    using (Stream resource = assem.GetManifestResourceStream(s))
+                    {
+                        using (StreamReader resourceReader = new StreamReader(resource))
+                        {
+                            string resourceString = resourceReader.ReadToEnd();
+                            return resourceString;
+                        }
+                    }
+                }
+            }
+            throw new Exception(string.Format("Resource '{0}' was not found", name));
+        }
+
+        /// <summary>
+        /// Execute a SQL statement stored in a resource, as a string
+        /// </summary>
+        /// <param name="name"></param>
+        public void ExecuteResourceSql(string name)
+        {
+            MySqlCommand cmd = new MySqlCommand(getResourceString(name), dbcon);
+            cmd.ExecuteNonQuery();
+        }
+
+        /// <summary>
+        /// Given a list of tables, return the version of the tables, as seen in the database
+        /// </summary>
+        /// <param name="tableList"></param>
+        public void GetTableVersion(Dictionary<string, string> tableList)
+        {
+            lock (dbcon)
+            {
+                MySqlCommand tablesCmd =
+                    new MySqlCommand(
+                        "SELECT TABLE_NAME, TABLE_COMMENT FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA=?dbname",
+                        dbcon);
+                tablesCmd.Parameters.AddWithValue("?dbname", dbcon.Database);
+                using (MySqlDataReader tables = tablesCmd.ExecuteReader())
+                {
+                    while (tables.Read())
+                    {
+                        try
+                        {
+                            string tableName = (string) tables["TABLE_NAME"];
+                            string comment = (string) tables["TABLE_COMMENT"];
+                            if (tableList.ContainsKey(tableName))
+                            {
+                                tableList[tableName] = comment;
+                            }
+                        }
+                        catch (Exception e)
+                        {
+                            m_log.Error(e.ToString());
+                        }
+                    }
+                    tables.Close();
+                }
+            }
+        }
+
+        // TODO: at some time this code should be cleaned up
+
+        /// <summary>
+        /// Runs a query with protection against SQL Injection by using parameterised input.
+        /// </summary>
+        /// <param name="sql">The SQL string - replace any variables such as WHERE x = "y" with WHERE x = @y</param>
+        /// <param name="parameters">The parameters - index so that @y is indexed as 'y'</param>
+        /// <returns>A MySQL DB Command</returns>
+        public IDbCommand Query(string sql, Dictionary<string, string> parameters)
+        {
+            try
+            {
+                MySqlCommand dbcommand = (MySqlCommand) dbcon.CreateCommand();
+                dbcommand.CommandText = sql;
+                foreach (KeyValuePair<string, string> param in parameters)
+                {
+                    dbcommand.Parameters.AddWithValue(param.Key, param.Value);
+                }
+
+                return (IDbCommand) dbcommand;
+            }
+            catch
+            {
+                lock (dbcon)
+                {
+                    // Close the DB connection
+                    try
+                    {
+                        dbcon.Close();
+                    }
+                    catch
+                    {
+                    }
+
+                    // Try to reopen it
+                    try
+                    {
+                        dbcon = new MySqlConnection(connectionString);
+                        dbcon.Open();
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Error("Unable to reconnect to database " + e.ToString());
+                    }
+
+                    // Run the query again
+                    try
+                    {
+                        MySqlCommand dbcommand = (MySqlCommand) dbcon.CreateCommand();
+                        dbcommand.CommandText = sql;
+                        foreach (KeyValuePair<string, string> param in parameters)
+                        {
+                            dbcommand.Parameters.AddWithValue(param.Key, param.Value);
+                        }
+
+                        return (IDbCommand) dbcommand;
+                    }
+                    catch (Exception e)
+                    {
+                        // Return null if it fails.
+                        m_log.Error("Failed during Query generation: " + e.ToString());
+                        return null;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reads a region row from a database reader
+        /// </summary>
+        /// <param name="reader">An active database reader</param>
+        /// <returns>A region profile</returns>
+        public RegionProfileData readSimRow(IDataReader reader)
+        {
+            RegionProfileData retval = new RegionProfileData();
+
+            if (reader.Read())
+            {
+                // Region Main gotta-have-or-we-return-null parts
+                if (!UInt64.TryParse(reader["regionHandle"].ToString(), out retval.regionHandle))
+                    return null;
+                if (!LLUUID.TryParse((string)reader["uuid"], out retval.UUID))
+                    return null;
+
+                // non-critical parts
+                retval.regionName = (string)reader["regionName"];
+                retval.originUUID = new LLUUID((string) reader["originUUID"]); 
+
+                // Secrets
+                retval.regionRecvKey = (string) reader["regionRecvKey"];
+                retval.regionSecret = (string) reader["regionSecret"];
+                retval.regionSendKey = (string) reader["regionSendKey"];
+
+                // Region Server
+                retval.regionDataURI = (string) reader["regionDataURI"];
+                retval.regionOnline = false; // Needs to be pinged before this can be set.
+                retval.serverIP = (string) reader["serverIP"];
+                retval.serverPort = (uint) reader["serverPort"];
+                retval.serverURI = (string) reader["serverURI"];
+                retval.httpPort = Convert.ToUInt32(reader["serverHttpPort"].ToString());
+                retval.remotingPort = Convert.ToUInt32(reader["serverRemotingPort"].ToString());
+
+                // Location
+                retval.regionLocX = Convert.ToUInt32(reader["locX"].ToString());
+                retval.regionLocY = Convert.ToUInt32(reader["locY"].ToString());
+                retval.regionLocZ = Convert.ToUInt32(reader["locZ"].ToString());
+
+                // Neighbours - 0 = No Override
+                retval.regionEastOverrideHandle = Convert.ToUInt64(reader["eastOverrideHandle"].ToString());
+                retval.regionWestOverrideHandle = Convert.ToUInt64(reader["westOverrideHandle"].ToString());
+                retval.regionSouthOverrideHandle = Convert.ToUInt64(reader["southOverrideHandle"].ToString());
+                retval.regionNorthOverrideHandle = Convert.ToUInt64(reader["northOverrideHandle"].ToString());
+
+                // Assets
+                retval.regionAssetURI = (string) reader["regionAssetURI"];
+                retval.regionAssetRecvKey = (string) reader["regionAssetRecvKey"];
+                retval.regionAssetSendKey = (string) reader["regionAssetSendKey"];
+
+                // Userserver
+                retval.regionUserURI = (string) reader["regionUserURI"];
+                retval.regionUserRecvKey = (string) reader["regionUserRecvKey"];
+                retval.regionUserSendKey = (string) reader["regionUserSendKey"];
+
+                // World Map Addition
+                LLUUID.TryParse((string)reader["regionMapTexture"], out retval.regionMapTextureID);
+                LLUUID.TryParse((string)reader["owner_uuid"], out retval.owner_uuid);            
+            }        
+            else
+            {
+                return null;
+            }
+            return retval;
+        }
+
+        /// <summary>
+        /// Reads a reservation row from a database reader
+        /// </summary>
+        /// <param name="reader">An active database reader</param>
+        /// <returns>A reservation data object</returns>
+        public ReservationData readReservationRow(IDataReader reader)
+        {
+            ReservationData retval = new ReservationData();
+            if (reader.Read())
+            {
+                retval.gridRecvKey = (string) reader["gridRecvKey"];
+                retval.gridSendKey = (string) reader["gridSendKey"];
+                retval.reservationCompany = (string) reader["resCompany"];
+                retval.reservationMaxX = Convert.ToInt32(reader["resXMax"].ToString());
+                retval.reservationMaxY = Convert.ToInt32(reader["resYMax"].ToString());
+                retval.reservationMinX = Convert.ToInt32(reader["resXMin"].ToString());
+                retval.reservationMinY = Convert.ToInt32(reader["resYMin"].ToString());
+                retval.reservationName = (string) reader["resName"];
+                retval.status = Convert.ToInt32(reader["status"].ToString()) == 1;
+                LLUUID.TryParse((string) reader["userUUID"], out retval.userUUID);
+            }
+            else
+            {
+                return null;
+            }
+            return retval;
+        }
+
+        /// <summary>
+        /// Reads an agent row from a database reader
+        /// </summary>
+        /// <param name="reader">An active database reader</param>
+        /// <returns>A user session agent</returns>
+        public UserAgentData readAgentRow(IDataReader reader)
+        {
+            UserAgentData retval = new UserAgentData();
+
+            if (reader.Read())
+            {
+                // Agent IDs
+                if (!LLUUID.TryParse((string)reader["UUID"], out retval.UUID))
+                    return null;
+                LLUUID.TryParse((string) reader["sessionID"], out retval.sessionID);
+                LLUUID.TryParse((string)reader["secureSessionID"], out retval.secureSessionID);
+
+                // Agent Who?
+                retval.agentIP = (string) reader["agentIP"];
+                retval.agentPort = Convert.ToUInt32(reader["agentPort"].ToString());
+                retval.agentOnline = Convert.ToBoolean(Convert.ToInt16(reader["agentOnline"].ToString()));
+
+                // Login/Logout times (UNIX Epoch)
+                retval.loginTime = Convert.ToInt32(reader["loginTime"].ToString());
+                retval.logoutTime = Convert.ToInt32(reader["logoutTime"].ToString());
+
+                // Current position
+                retval.currentRegion = new LLUUID((string)reader["currentRegion"]);
+                retval.currentHandle = Convert.ToUInt64(reader["currentHandle"].ToString());
+                LLVector3.TryParse((string) reader["currentPos"], out retval.currentPos);
+            }
+            else
+            {
+                return null;
+            }
+            return retval;
+        }
+
+        /// <summary>
+        /// Reads a user profile from an active data reader
+        /// </summary>
+        /// <param name="reader">An active database reader</param>
+        /// <returns>A user profile</returns>
+        public UserProfileData readUserRow(IDataReader reader)
+        {
+            UserProfileData retval = new UserProfileData();
+
+            if (reader.Read())
+            {
+                if (!LLUUID.TryParse((string)reader["UUID"], out retval.UUID))
+                    return null;
+                retval.username = (string) reader["username"];
+                retval.surname = (string) reader["lastname"];
+
+                retval.passwordHash = (string) reader["passwordHash"];
+                retval.passwordSalt = (string) reader["passwordSalt"];
+
+                retval.homeRegion = Convert.ToUInt64(reader["homeRegion"].ToString());
+                retval.homeLocation = new LLVector3(
+                    Convert.ToSingle(reader["homeLocationX"].ToString()),
+                    Convert.ToSingle(reader["homeLocationY"].ToString()),
+                    Convert.ToSingle(reader["homeLocationZ"].ToString()));
+                retval.homeLookAt = new LLVector3(
+                    Convert.ToSingle(reader["homeLookAtX"].ToString()),
+                    Convert.ToSingle(reader["homeLookAtY"].ToString()),
+                    Convert.ToSingle(reader["homeLookAtZ"].ToString()));
+
+                retval.created = Convert.ToInt32(reader["created"].ToString());
+                retval.lastLogin = Convert.ToInt32(reader["lastLogin"].ToString());
+
+                retval.userInventoryURI = (string) reader["userInventoryURI"];
+                retval.userAssetURI = (string) reader["userAssetURI"];
+
+                retval.profileCanDoMask = Convert.ToUInt32(reader["profileCanDoMask"].ToString());
+                retval.profileWantDoMask = Convert.ToUInt32(reader["profileWantDoMask"].ToString());
+
+                if (reader.IsDBNull(reader.GetOrdinal("profileAboutText")))
+                    retval.profileAboutText = "";
+                else 
+                    retval.profileAboutText = (string) reader["profileAboutText"];
+
+                if (reader.IsDBNull(reader.GetOrdinal("profileFirstText")))
+                    retval.profileFirstText = "";
+                else
+                    retval.profileFirstText = (string)reader["profileFirstText"];
+
+                if (reader.IsDBNull(reader.GetOrdinal("profileImage")))
+                    retval.profileImage = LLUUID.Zero;
+                else 
+                    LLUUID.TryParse((string)reader["profileImage"], out retval.profileImage);
+
+                if (reader.IsDBNull(reader.GetOrdinal("profileFirstImage")))
+                    retval.profileFirstImage = LLUUID.Zero;
+                else 
+                    LLUUID.TryParse((string)reader["profileFirstImage"], out retval.profileFirstImage);
+                
+                if(reader.IsDBNull(reader.GetOrdinal("webLoginKey")))
+                {
+                    retval.webLoginKey = LLUUID.Zero;
+                }
+                else
+                {
+                    LLUUID.TryParse((string)reader["webLoginKey"], out retval.webLoginKey);
+                }
+            }
+            else
+            {
+                return null;
+            }
+            return retval;
+        }
+
+        /// <summary>
+        /// Inserts a new row into the log database
+        /// </summary>
+        /// <param name="serverDaemon">The daemon which triggered this event</param>
+        /// <param name="target">Who were we operating on when this occured (region UUID, user UUID, etc)</param>
+        /// <param name="methodCall">The method call where the problem occured</param>
+        /// <param name="arguments">The arguments passed to the method</param>
+        /// <param name="priority">How critical is this?</param>
+        /// <param name="logMessage">Extra message info</param>
+        /// <returns>Saved successfully?</returns>
+        public bool insertLogRow(string serverDaemon, string target, string methodCall, string arguments, int priority,
+                                 string logMessage)
+        {
+            string sql = "INSERT INTO logs (`target`, `server`, `method`, `arguments`, `priority`, `message`) VALUES ";
+            sql += "(?target, ?server, ?method, ?arguments, ?priority, ?message)";
+
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+            parameters["?server"] = serverDaemon;
+            parameters["?target"] = target;
+            parameters["?method"] = methodCall;
+            parameters["?arguments"] = arguments;
+            parameters["?priority"] = priority.ToString();
+            parameters["?message"] = logMessage;
+
+            bool returnval = false;
+
+            try
+            {
+                IDbCommand result = Query(sql, parameters);
+
+                if (result.ExecuteNonQuery() == 1)
+                    returnval = true;
+
+                result.Dispose();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+                return false;
+            }
+
+            return returnval;
+        }
+
+        /// <summary>
+        /// Creates a new user and inserts it into the database
+        /// </summary>
+        /// <param name="uuid">User ID</param>
+        /// <param name="username">First part of the login</param>
+        /// <param name="lastname">Second part of the login</param>
+        /// <param name="passwordHash">A salted hash of the users password</param>
+        /// <param name="passwordSalt">The salt used for the password hash</param>
+        /// <param name="homeRegion">A regionHandle of the users home region</param>
+        /// <param name="homeLocX">Home region position vector</param>
+        /// <param name="homeLocY">Home region position vector</param>
+        /// <param name="homeLocZ">Home region position vector</param>
+        /// <param name="homeLookAtX">Home region 'look at' vector</param>
+        /// <param name="homeLookAtY">Home region 'look at' vector</param>
+        /// <param name="homeLookAtZ">Home region 'look at' vector</param>
+        /// <param name="created">Account created (unix timestamp)</param>
+        /// <param name="lastlogin">Last login (unix timestamp)</param>
+        /// <param name="inventoryURI">Users inventory URI</param>
+        /// <param name="assetURI">Users asset URI</param>
+        /// <param name="canDoMask">I can do mask</param>
+        /// <param name="wantDoMask">I want to do mask</param>
+        /// <param name="aboutText">Profile text</param>
+        /// <param name="firstText">Firstlife text</param>
+        /// <param name="profileImage">UUID for profile image</param>
+        /// <param name="firstImage">UUID for firstlife image</param>
+        /// <returns>Success?</returns>
+        public bool insertUserRow(LLUUID uuid, string username, string lastname, string passwordHash,
+                                  string passwordSalt, UInt64 homeRegion, float homeLocX, float homeLocY, float homeLocZ,
+                                  float homeLookAtX, float homeLookAtY, float homeLookAtZ, int created, int lastlogin,
+                                  string inventoryURI, string assetURI, uint canDoMask, uint wantDoMask,
+                                  string aboutText, string firstText,
+                                  LLUUID profileImage, LLUUID firstImage, LLUUID webLoginKey)
+        {
+            m_log.Debug("[MySQLManager]: Fetching profile for " + uuid.ToString());
+            string sql =
+                "INSERT INTO users (`UUID`, `username`, `lastname`, `passwordHash`, `passwordSalt`, `homeRegion`, ";
+            sql +=
+                "`homeLocationX`, `homeLocationY`, `homeLocationZ`, `homeLookAtX`, `homeLookAtY`, `homeLookAtZ`, `created`, ";
+            sql +=
+                "`lastLogin`, `userInventoryURI`, `userAssetURI`, `profileCanDoMask`, `profileWantDoMask`, `profileAboutText`, ";
+            sql += "`profileFirstText`, `profileImage`, `profileFirstImage`, `webLoginKey`) VALUES ";
+
+            sql += "(?UUID, ?username, ?lastname, ?passwordHash, ?passwordSalt, ?homeRegion, ";
+            sql +=
+                "?homeLocationX, ?homeLocationY, ?homeLocationZ, ?homeLookAtX, ?homeLookAtY, ?homeLookAtZ, ?created, ";
+            sql +=
+                "?lastLogin, ?userInventoryURI, ?userAssetURI, ?profileCanDoMask, ?profileWantDoMask, ?profileAboutText, ";
+            sql += "?profileFirstText, ?profileImage, ?profileFirstImage, ?webLoginKey)";
+
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+            parameters["?UUID"] = uuid.ToString();
+            parameters["?username"] = username.ToString();
+            parameters["?lastname"] = lastname.ToString();
+            parameters["?passwordHash"] = passwordHash.ToString();
+            parameters["?passwordSalt"] = passwordSalt.ToString();
+            parameters["?homeRegion"] = homeRegion.ToString();
+            parameters["?homeLocationX"] = homeLocX.ToString();
+            parameters["?homeLocationY"] = homeLocY.ToString();
+            parameters["?homeLocationZ"] = homeLocZ.ToString();
+            parameters["?homeLookAtX"] = homeLookAtX.ToString();
+            parameters["?homeLookAtY"] = homeLookAtY.ToString();
+            parameters["?homeLookAtZ"] = homeLookAtZ.ToString();
+            parameters["?created"] = created.ToString();
+            parameters["?lastLogin"] = lastlogin.ToString();
+            parameters["?userInventoryURI"] = String.Empty;
+            parameters["?userAssetURI"] = String.Empty;
+            parameters["?profileCanDoMask"] = "0";
+            parameters["?profileWantDoMask"] = "0";
+            parameters["?profileAboutText"] = aboutText;
+            parameters["?profileFirstText"] = firstText;
+            parameters["?profileImage"] = profileImage.ToString();
+            parameters["?profileFirstImage"] = firstImage.ToString();
+            parameters["?webLoginKey"] = string.Empty;
+
+            bool returnval = false;
+
+            try
+            {
+                IDbCommand result = Query(sql, parameters);
+
+                if (result.ExecuteNonQuery() == 1)
+                    returnval = true;
+
+                result.Dispose();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+                return false;
+            }
+
+            m_log.Debug("[MySQLManager]: Fetch user retval == " + returnval.ToString());
+            return returnval;
+        }
+
+        /// <summary>
+        /// Creates a new user and inserts it into the database
+        /// </summary>
+        /// <param name="uuid">User ID</param>
+        /// <param name="username">First part of the login</param>
+        /// <param name="lastname">Second part of the login</param>
+        /// <param name="passwordHash">A salted hash of the users password</param>
+        /// <param name="passwordSalt">The salt used for the password hash</param>
+        /// <param name="homeRegion">A regionHandle of the users home region</param>
+        /// <param name="homeLocX">Home region position vector</param>
+        /// <param name="homeLocY">Home region position vector</param>
+        /// <param name="homeLocZ">Home region position vector</param>
+        /// <param name="homeLookAtX">Home region 'look at' vector</param>
+        /// <param name="homeLookAtY">Home region 'look at' vector</param>
+        /// <param name="homeLookAtZ">Home region 'look at' vector</param>
+        /// <param name="created">Account created (unix timestamp)</param>
+        /// <param name="lastlogin">Last login (unix timestamp)</param>
+        /// <param name="inventoryURI">Users inventory URI</param>
+        /// <param name="assetURI">Users asset URI</param>
+        /// <param name="canDoMask">I can do mask</param>
+        /// <param name="wantDoMask">I want to do mask</param>
+        /// <param name="aboutText">Profile text</param>
+        /// <param name="firstText">Firstlife text</param>
+        /// <param name="profileImage">UUID for profile image</param>
+        /// <param name="firstImage">UUID for firstlife image</param>
+        /// <returns>Success?</returns>
+        public bool updateUserRow(LLUUID uuid, string username, string lastname, string passwordHash,
+                                  string passwordSalt, UInt64 homeRegion, float homeLocX, float homeLocY, float homeLocZ,
+                                  float homeLookAtX, float homeLookAtY, float homeLookAtZ, int created, int lastlogin,
+                                  string inventoryURI, string assetURI, uint canDoMask, uint wantDoMask,
+                                  string aboutText, string firstText,
+                                  LLUUID profileImage, LLUUID firstImage, LLUUID webLoginKey)
+        {
+            string sql = "UPDATE users SET `username` = ?username , `lastname` = ?lastname ";
+            sql += ", `passwordHash` = ?passwordHash , `passwordSalt` = ?passwordSalt , ";
+            sql += "`homeRegion` = ?homeRegion , `homeLocationX` = ?homeLocationX , ";
+            sql += "`homeLocationY`  = ?homeLocationY , `homeLocationZ` = ?homeLocationZ , ";
+            sql += "`homeLookAtX` = ?homeLookAtX , `homeLookAtY` = ?homeLookAtY , ";
+            sql += "`homeLookAtZ` = ?homeLookAtZ , `created` = ?created , `lastLogin` = ?lastLogin , ";
+            sql += "`userInventoryURI` = ?userInventoryURI , `userAssetURI` = ?userAssetURI , ";
+            sql += "`profileCanDoMask` = ?profileCanDoMask , `profileWantDoMask` = ?profileWantDoMask , ";
+            sql += "`profileAboutText` = ?profileAboutText , `profileFirstText` = ?profileFirstText, ";
+            sql += "`profileImage` = ?profileImage , `profileFirstImage` = ?profileFirstImage , ";
+            sql += "`webLoginKey` = ?webLoginKey WHERE UUID = ?UUID";
+
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+            parameters["?UUID"] = uuid.ToString();
+            parameters["?username"] = username.ToString();
+            parameters["?lastname"] = lastname.ToString();
+            parameters["?passwordHash"] = passwordHash.ToString();
+            parameters["?passwordSalt"] = passwordSalt.ToString();
+            parameters["?homeRegion"] = homeRegion.ToString();
+            parameters["?homeLocationX"] = homeLocX.ToString();
+            parameters["?homeLocationY"] = homeLocY.ToString();
+            parameters["?homeLocationZ"] = homeLocZ.ToString();
+            parameters["?homeLookAtX"] = homeLookAtX.ToString();
+            parameters["?homeLookAtY"] = homeLookAtY.ToString();
+            parameters["?homeLookAtZ"] = homeLookAtZ.ToString();
+            parameters["?created"] = created.ToString();
+            parameters["?lastLogin"] = lastlogin.ToString();
+            parameters["?userInventoryURI"] = inventoryURI;
+            parameters["?userAssetURI"] = assetURI;
+            parameters["?profileCanDoMask"] = "0";
+            parameters["?profileWantDoMask"] = "0";
+            parameters["?profileAboutText"] = aboutText;
+            parameters["?profileFirstText"] = firstText;
+            parameters["?profileImage"] = profileImage.ToString();
+            parameters["?profileFirstImage"] = firstImage.ToString();
+            parameters["?webLoginKey"] = webLoginKey.ToString();
+
+            bool returnval = false;
+            try
+            {
+                IDbCommand result = Query(sql, parameters);
+
+                if (result.ExecuteNonQuery() == 1)
+                    returnval = true;
+
+                result.Dispose();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+                return false;
+            }
+
+            m_log.Debug("[MySQLManager]: update user retval == " + returnval.ToString());
+            return returnval;
+        }
+
+        /// <summary>
+        /// Inserts a new region into the database
+        /// </summary>
+        /// <param name="profile">The region to insert</param>
+        /// <returns>Success?</returns>
+        public bool insertRegion(RegionProfileData regiondata)
+        {
+            bool GRID_ONLY_UPDATE_NECESSARY_DATA = false;
+
+            string sql = String.Empty;
+            if (GRID_ONLY_UPDATE_NECESSARY_DATA)
+            {
+                sql += "INSERT INTO ";
+            }
+            else
+            {
+                sql += "REPLACE INTO ";
+            }
+
+            sql += "regions (regionHandle, regionName, uuid, regionRecvKey, regionSecret, regionSendKey, regionDataURI, ";
+            sql +=
+                "serverIP, serverPort, serverURI, locX, locY, locZ, eastOverrideHandle, westOverrideHandle, southOverrideHandle, northOverrideHandle, regionAssetURI, regionAssetRecvKey, ";
+
+            // part of an initial brutish effort to provide accurate information (as per the xml region spec)
+            // wrt the ownership of a given region
+            // the (very bad) assumption is that this value is being read and handled inconsistently or
+            // not at all. Current strategy is to put the code in place to support the validity of this information
+            // and to roll forward debugging any issues from that point
+            //
+            // this particular section of the mod attempts to implement the commit of a supplied value
+            // server for the UUID of the region's owner (master avatar). It consists of the addition of the column and value to the relevant sql,
+            // as well as the related parameterization
+            sql +=
+                "regionAssetSendKey, regionUserURI, regionUserRecvKey, regionUserSendKey, regionMapTexture, serverHttpPort, serverRemotingPort, owner_uuid, originUUID) VALUES ";
+
+            sql += "(?regionHandle, ?regionName, ?uuid, ?regionRecvKey, ?regionSecret, ?regionSendKey, ?regionDataURI, ";
+            sql +=
+                "?serverIP, ?serverPort, ?serverURI, ?locX, ?locY, ?locZ, ?eastOverrideHandle, ?westOverrideHandle, ?southOverrideHandle, ?northOverrideHandle, ?regionAssetURI, ?regionAssetRecvKey, ";
+            sql +=
+                "?regionAssetSendKey, ?regionUserURI, ?regionUserRecvKey, ?regionUserSendKey, ?regionMapTexture, ?serverHttpPort, ?serverRemotingPort, ?owner_uuid, ?originUUID)";
+
+            if (GRID_ONLY_UPDATE_NECESSARY_DATA)
+            {
+                sql += "ON DUPLICATE KEY UPDATE serverIP = ?serverIP, serverPort = ?serverPort, serverURI = ?serverURI, owner_uuid - ?owner_uuid;";
+            }
+            else
+            {
+                sql += ";";
+            }
+
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+
+            parameters["?regionHandle"] = regiondata.regionHandle.ToString();
+            parameters["?regionName"] = regiondata.regionName.ToString();
+            parameters["?uuid"] = regiondata.UUID.ToString();
+            parameters["?regionRecvKey"] = regiondata.regionRecvKey.ToString();
+            parameters["?regionSecret"] = regiondata.regionSecret.ToString();
+            parameters["?regionSendKey"] = regiondata.regionSendKey.ToString();
+            parameters["?regionDataURI"] = regiondata.regionDataURI.ToString();
+            parameters["?serverIP"] = regiondata.serverIP.ToString();
+            parameters["?serverPort"] = regiondata.serverPort.ToString();
+            parameters["?serverURI"] = regiondata.serverURI.ToString();
+            parameters["?locX"] = regiondata.regionLocX.ToString();
+            parameters["?locY"] = regiondata.regionLocY.ToString();
+            parameters["?locZ"] = regiondata.regionLocZ.ToString();
+            parameters["?eastOverrideHandle"] = regiondata.regionEastOverrideHandle.ToString();
+            parameters["?westOverrideHandle"] = regiondata.regionWestOverrideHandle.ToString();
+            parameters["?northOverrideHandle"] = regiondata.regionNorthOverrideHandle.ToString();
+            parameters["?southOverrideHandle"] = regiondata.regionSouthOverrideHandle.ToString();
+            parameters["?regionAssetURI"] = regiondata.regionAssetURI.ToString();
+            parameters["?regionAssetRecvKey"] = regiondata.regionAssetRecvKey.ToString();
+            parameters["?regionAssetSendKey"] = regiondata.regionAssetSendKey.ToString();
+            parameters["?regionUserURI"] = regiondata.regionUserURI.ToString();
+            parameters["?regionUserRecvKey"] = regiondata.regionUserRecvKey.ToString();
+            parameters["?regionUserSendKey"] = regiondata.regionUserSendKey.ToString();
+            parameters["?regionMapTexture"] = regiondata.regionMapTextureID.ToString();
+            parameters["?serverHttpPort"] = regiondata.httpPort.ToString();
+            parameters["?serverRemotingPort"] = regiondata.remotingPort.ToString();
+            parameters["?owner_uuid"] = regiondata.owner_uuid.ToString();
+            parameters["?originUUID"] = regiondata.originUUID.ToString();
+
+            bool returnval = false;
+
+            try
+            {
+                IDbCommand result = Query(sql, parameters);
+
+                //Console.WriteLine(result.CommandText);
+                int x;
+                if ((x = result.ExecuteNonQuery()) > 0)
+                {
+                    returnval = true;
+                }
+                result.Dispose();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+                return false;
+            }
+
+            return returnval;
+        }
+
+        /// <summary>
+        /// Delete a region from the database
+        /// </summary>
+        /// <param name="profile">The region to insert</param>
+        /// <returns>Success?</returns>
+        //public bool deleteRegion(RegionProfileData regiondata)
+        public bool deleteRegion(string uuid)
+        {
+            bool returnval = false;
+
+            string sql = "DELETE FROM regions WHERE uuid = ?uuid;";
+
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+
+            try
+            {
+                parameters["?uuid"] = uuid;
+
+                IDbCommand result = Query(sql, parameters);
+
+                int x;
+                if ((x = result.ExecuteNonQuery()) > 0)
+                {
+                    returnval = true;
+                }
+                result.Dispose();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+                return false;
+            }
+
+            return returnval;
+        }
+
+        /// <summary>
+        /// Creates a new agent and inserts it into the database
+        /// </summary>
+        /// <param name="agentdata">The agent data to be inserted</param>
+        /// <returns>Success?</returns>
+        public bool insertAgentRow(UserAgentData agentdata)
+        {
+            string sql = String.Empty;
+            sql += "REPLACE INTO ";
+            sql += "agents (UUID, sessionID, secureSessionID, agentIP, agentPort, agentOnline, loginTime, logoutTime, currentRegion, currentHandle, currentPos) VALUES ";
+            sql += "(?UUID, ?sessionID, ?secureSessionID, ?agentIP, ?agentPort, ?agentOnline, ?loginTime, ?logoutTime, ?currentRegion, ?currentHandle, ?currentPos);";
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+
+            parameters["?UUID"] = agentdata.UUID.ToString();
+            parameters["?sessionID"] = agentdata.sessionID.ToString();
+            parameters["?secureSessionID"] = agentdata.secureSessionID.ToString();
+            parameters["?agentIP"] = agentdata.agentIP.ToString();
+            parameters["?agentPort"] = agentdata.agentPort.ToString();
+            parameters["?agentOnline"] = (agentdata.agentOnline == true) ? "1" : "0";
+            parameters["?loginTime"] = agentdata.loginTime.ToString();
+            parameters["?logoutTime"] = agentdata.logoutTime.ToString();
+            parameters["?currentRegion"] = agentdata.currentRegion.ToString();
+            parameters["?currentHandle"] = agentdata.currentHandle.ToString();
+            parameters["?currentPos"] = "<" + ((int)agentdata.currentPos.X).ToString() + "," + ((int)agentdata.currentPos.Y).ToString() + "," + ((int)agentdata.currentPos.Z).ToString() + ">";
+
+            bool returnval = false;
+
+            try
+            {
+                IDbCommand result = Query(sql, parameters);
+
+                //Console.WriteLine(result.CommandText);
+                int x;
+                if ((x = result.ExecuteNonQuery()) > 0)
+                {
+                    returnval = true;
+                }
+                result.Dispose();
+            }
+            catch (Exception e)
+            {
+                m_log.Error(e.ToString());
+                return false;
+            }
+
+            return returnval;
+        }
+    }
+}
diff --git a/OpenSim/Data/MySQL/MySQLUserData.cs b/OpenSim/Data/MySQL/MySQLUserData.cs
new file mode 100644
index 0000000..fd640ec
--- /dev/null
+++ b/OpenSim/Data/MySQL/MySQLUserData.cs
@@ -0,0 +1,643 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Text.RegularExpressions;
+using libsecondlife;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.MySQL
+{
+    /// <summary>
+    /// A database interface class to a user profile storage system
+    /// </summary>
+    internal class MySQLUserData : UserDataBase
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// Database manager for MySQL
+        /// </summary>
+        public MySQLManager database;
+
+        private string m_agentsTableName;
+        private string m_usersTableName;
+        private string m_userFriendsTableName;
+
+        /// <summary>
+        /// Loads and initialises the MySQL storage plugin
+        /// </summary>
+        override public void Initialise()
+        {
+            // Load from an INI file connection details
+            // TODO: move this to XML? Yes, PLEASE!
+            
+            IniFile iniFile = new IniFile("mysql_connection.ini");
+            string settingHostname = iniFile.ParseFileReadValue("hostname");
+            string settingDatabase = iniFile.ParseFileReadValue("database");
+            string settingUsername = iniFile.ParseFileReadValue("username");
+            string settingPassword = iniFile.ParseFileReadValue("password");
+            string settingPooling = iniFile.ParseFileReadValue("pooling");
+            string settingPort = iniFile.ParseFileReadValue("port");
+            
+            m_usersTableName = iniFile.ParseFileReadValue("userstablename");
+            if( m_usersTableName == null )
+            {
+                m_usersTableName = "users";
+            }
+
+            m_userFriendsTableName = iniFile.ParseFileReadValue("userfriendstablename");
+            if (m_userFriendsTableName == null)
+            {
+                m_userFriendsTableName = "userfriends";
+            }
+
+            m_agentsTableName = iniFile.ParseFileReadValue("agentstablename");
+            if (m_agentsTableName == null)
+            {
+                m_agentsTableName = "agents";
+            }
+
+            database =
+                new MySQLManager(settingHostname, settingDatabase, settingUsername, settingPassword, settingPooling,
+                                 settingPort);
+
+            TestTables();
+        }
+
+        #region Test and initialization code
+
+        /// <summary>
+        /// Ensure that the user related tables exists and are at the latest version
+        /// </summary>
+        private void TestTables()
+        {
+            Dictionary<string, string> tableList = new Dictionary<string, string>();
+
+            tableList[m_agentsTableName] = null;
+            tableList[m_usersTableName] = null;
+            tableList[m_userFriendsTableName] = null;
+            database.GetTableVersion(tableList);
+
+            UpgradeAgentsTable(tableList[m_agentsTableName]);
+            UpgradeUsersTable(tableList[m_usersTableName]);
+            UpgradeFriendsTable(tableList[m_userFriendsTableName]);
+        }
+
+        /// <summary>
+        /// Create or upgrade the table if necessary
+        /// </summary>
+        /// <param name="oldVersion">A null indicates that the table does not
+        /// currently exist</param>
+        private void UpgradeAgentsTable(string oldVersion)
+        {
+            // null as the version, indicates that the table didn't exist
+            if (oldVersion == null)
+            {
+                database.ExecuteResourceSql("CreateAgentsTable.sql");
+                return;
+            }
+        }
+
+        /// <summary>
+        /// Create or upgrade the table if necessary
+        /// </summary>
+        /// <param name="oldVersion">A null indicates that the table does not
+        /// currently exist</param>
+        private void UpgradeUsersTable(string oldVersion)
+        {
+            // null as the version, indicates that the table didn't exist
+            if (oldVersion == null)
+            {
+                database.ExecuteResourceSql("CreateUsersTable.sql");
+                return;
+            }
+            else if (oldVersion.Contains("Rev. 1"))
+            {
+                database.ExecuteResourceSql("UpgradeUsersTableToVersion2.sql");
+                return;
+            }
+            //m_log.Info("[DB]: DBVers:" + oldVersion);
+        }
+
+        /// <summary>
+        /// Create or upgrade the table if necessary
+        /// </summary>
+        /// <param name="oldVersion">A null indicates that the table does not
+        /// currently exist</param>
+        private void UpgradeFriendsTable(string oldVersion)
+        {
+            // null as the version, indicates that the table didn't exist
+            if (oldVersion == null)
+            {
+                database.ExecuteResourceSql("CreateUserFriendsTable.sql");
+                return;
+            }
+        }
+
+        #endregion
+
+        // see IUserData
+        override public UserProfileData GetUserByName(string user, string last)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["?first"] = user;
+                    param["?second"] = last;
+
+                    IDbCommand result =
+                        database.Query("SELECT * FROM " + m_usersTableName + " WHERE username = ?first AND lastname = ?second", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    UserProfileData row = database.readUserRow(reader);
+
+                    reader.Close();
+                    result.Dispose();
+                    return row;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        #region User Friends List Data
+
+        override public void AddNewUserFriend(LLUUID friendlistowner, LLUUID friend, uint perms)
+        {
+            int dtvalue = Util.UnixTimeSinceEpoch();
+
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["?ownerID"] = friendlistowner.UUID.ToString();
+            param["?friendID"] = friend.UUID.ToString();
+            param["?friendPerms"] = perms.ToString();
+            param["?datetimestamp"] = dtvalue.ToString();
+            
+            try 
+            {
+                lock (database)
+                {
+                    IDbCommand adder =
+                        database.Query(
+                        "INSERT INTO `" + m_userFriendsTableName + "` " +
+                        "(`ownerID`,`friendID`,`friendPerms`,`datetimestamp`) " + 
+                        "VALUES " +
+                        "(?ownerID,?friendID,?friendPerms,?datetimestamp)",
+                            param);
+                    adder.ExecuteNonQuery();
+
+                    adder =
+                        database.Query(
+                        "INSERT INTO `" + m_userFriendsTableName + "` " +
+                        "(`ownerID`,`friendID`,`friendPerms`,`datetimestamp`) " +
+                        "VALUES " +
+                        "(?friendID,?ownerID,?friendPerms,?datetimestamp)",
+                            param);
+                    adder.ExecuteNonQuery();
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return;
+            }
+        }
+
+        override public void RemoveUserFriend(LLUUID friendlistowner, LLUUID friend)
+        {
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["?ownerID"] = friendlistowner.UUID.ToString();
+            param["?friendID"] = friend.UUID.ToString();
+
+            try
+            {
+                lock (database)
+                {
+                    IDbCommand updater =
+                        database.Query(
+                            "delete from " + m_userFriendsTableName + " where ownerID = ?ownerID and friendID = ?friendID",
+                            param);
+                    updater.ExecuteNonQuery();
+
+                    updater =
+                        database.Query(
+                            "delete from " + m_userFriendsTableName + " where ownerID = ?friendID and friendID = ?ownerID",
+                            param);
+                    updater.ExecuteNonQuery();
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return;
+            }
+        }
+
+        override public void UpdateUserFriendPerms(LLUUID friendlistowner, LLUUID friend, uint perms)
+        {
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["?ownerID"] = friendlistowner.UUID.ToString();
+            param["?friendID"] = friend.UUID.ToString();
+            param["?friendPerms"] = perms.ToString();
+
+            try
+            {
+                lock (database)
+                {
+                    IDbCommand updater =
+                        database.Query(
+                            "update " + m_userFriendsTableName +
+                            " SET friendPerms = ?friendPerms " +
+                            "where ownerID = ?ownerID and friendID = ?friendID",
+                            param);
+                    updater.ExecuteNonQuery();
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return;
+            }
+        }
+
+        override public List<FriendListItem> GetUserFriendList(LLUUID friendlistowner)
+        {
+            List<FriendListItem> Lfli = new List<FriendListItem>();
+
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["?ownerID"] = friendlistowner.UUID.ToString();
+
+            try
+            {
+                lock (database)
+                {
+                    //Left Join userfriends to itself
+                    IDbCommand result =
+                        database.Query(
+                            "select a.ownerID,a.friendID,a.friendPerms,b.friendPerms as ownerperms from " + m_userFriendsTableName + " as a, " + m_userFriendsTableName + " as b" +
+                            " where a.ownerID = ?ownerID and b.ownerID = a.friendID and b.friendID = a.ownerID",
+                            param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    while (reader.Read())
+                    {
+                        FriendListItem fli = new FriendListItem();
+                        fli.FriendListOwner = new LLUUID((string)reader["ownerID"]);
+                        fli.Friend = new LLUUID((string)reader["friendID"]);
+                        fli.FriendPerms = (uint)Convert.ToInt32(reader["friendPerms"]);
+
+                        // This is not a real column in the database table, it's a joined column from the opposite record
+                        fli.FriendListOwnerPerms = (uint)Convert.ToInt32(reader["ownerperms"]);
+                        
+                        Lfli.Add(fli);
+                    }
+                    reader.Close();
+                    result.Dispose();
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return Lfli;
+            }
+
+            return Lfli;
+        }
+
+        #endregion
+
+        override public void UpdateUserCurrentRegion(LLUUID avatarid, LLUUID regionuuid)
+        {
+            m_log.Info("[USER]: Stub UpdateUserCUrrentRegion called");
+        }
+
+        override public List<Framework.AvatarPickerAvatar> GeneratePickerResults(LLUUID queryID, string query)
+        {
+            List<Framework.AvatarPickerAvatar> returnlist = new List<Framework.AvatarPickerAvatar>();
+
+            Regex objAlphaNumericPattern = new Regex("[^a-zA-Z0-9]");
+
+            string[] querysplit;
+            querysplit = query.Split(' ');
+            if (querysplit.Length == 2)
+            {
+                Dictionary<string, string> param = new Dictionary<string, string>();
+                param["?first"] = objAlphaNumericPattern.Replace(querysplit[0], String.Empty) + "%";
+                param["?second"] = objAlphaNumericPattern.Replace(querysplit[1], String.Empty) + "%";
+                try
+                {
+                    lock (database)
+                    {
+                        IDbCommand result =
+                            database.Query(
+                                "SELECT UUID,username,lastname FROM " + m_usersTableName + " WHERE username like ?first AND lastname like ?second LIMIT 100",
+                                param);
+                        IDataReader reader = result.ExecuteReader();
+
+                        while (reader.Read())
+                        {
+                            Framework.AvatarPickerAvatar user = new Framework.AvatarPickerAvatar();
+                            user.AvatarID = new LLUUID((string) reader["UUID"]);
+                            user.firstName = (string) reader["username"];
+                            user.lastName = (string) reader["lastname"];
+                            returnlist.Add(user);
+                        }
+                        reader.Close();
+                        result.Dispose();
+                    }
+                }
+                catch (Exception e)
+                {
+                    database.Reconnect();
+                    m_log.Error(e.ToString());
+                    return returnlist;
+                }
+            }
+            else if (querysplit.Length == 1)
+            {
+                try
+                {
+                    lock (database)
+                    {
+                        Dictionary<string, string> param = new Dictionary<string, string>();
+                        param["?first"] = objAlphaNumericPattern.Replace(querysplit[0], String.Empty) + "%";
+
+                        IDbCommand result =
+                            database.Query(
+                                "SELECT UUID,username,lastname FROM " + m_usersTableName + " WHERE username like ?first OR lastname like ?first LIMIT 100",
+                                param);
+                        IDataReader reader = result.ExecuteReader();
+
+                        while (reader.Read())
+                        {
+                            Framework.AvatarPickerAvatar user = new Framework.AvatarPickerAvatar();
+                            user.AvatarID = new LLUUID((string) reader["UUID"]);
+                            user.firstName = (string) reader["username"];
+                            user.lastName = (string) reader["lastname"];
+                            returnlist.Add(user);
+                        }
+                        reader.Close();
+                        result.Dispose();
+                    }
+                }
+                catch (Exception e)
+                {
+                    database.Reconnect();
+                    m_log.Error(e.ToString());
+                    return returnlist;
+                }
+            }
+            return returnlist;
+        }
+
+        // see IUserData
+        override public UserProfileData GetUserByUUID(LLUUID uuid)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["?uuid"] = uuid.ToString();
+
+                    IDbCommand result = database.Query("SELECT * FROM " + m_usersTableName + " WHERE UUID = ?uuid", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    UserProfileData row = database.readUserRow(reader);
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return row;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a user session searching by name
+        /// </summary>
+        /// <param name="name">The account name</param>
+        /// <returns>The users session</returns>
+        override public UserAgentData GetAgentByName(string name)
+        {
+            return GetAgentByName(name.Split(' ')[0], name.Split(' ')[1]);
+        }
+
+        /// <summary>
+        /// Returns a user session by account name
+        /// </summary>
+        /// <param name="user">First part of the users account name</param>
+        /// <param name="last">Second part of the users account name</param>
+        /// <returns>The users session</returns>
+        override public UserAgentData GetAgentByName(string user, string last)
+        {
+            UserProfileData profile = GetUserByName(user, last);
+            return GetAgentByUUID(profile.UUID);
+        }
+
+        override public void StoreWebLoginKey(LLUUID AgentID, LLUUID WebLoginKey)
+        {
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["?UUID"] = AgentID.UUID.ToString();
+            param["?webLoginKey"] = WebLoginKey.UUID.ToString();
+
+            try
+            {
+                lock (database)
+                {
+                    IDbCommand updater =
+                        database.Query(
+                            "update " + m_usersTableName + " SET webLoginKey = ?webLoginKey " +
+                            "where UUID = ?UUID",
+                            param);
+                    updater.ExecuteNonQuery();
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return;
+            }
+        }
+
+        /// <summary>
+        /// Returns an agent session by account UUID
+        /// </summary>
+        /// <param name="uuid">The accounts UUID</param>
+        /// <returns>The users session</returns>
+        override public UserAgentData GetAgentByUUID(LLUUID uuid)
+        {
+            try
+            {
+                lock (database)
+                {
+                    Dictionary<string, string> param = new Dictionary<string, string>();
+                    param["?uuid"] = uuid.ToString();
+
+                    IDbCommand result = database.Query("SELECT * FROM " + m_agentsTableName + " WHERE UUID = ?uuid", param);
+                    IDataReader reader = result.ExecuteReader();
+
+                    UserAgentData row = database.readAgentRow(reader);
+
+                    reader.Close();
+                    result.Dispose();
+
+                    return row;
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new users profile
+        /// </summary>
+        /// <param name="user">The user profile to create</param>
+        override public void AddNewUserProfile(UserProfileData user)
+        {
+            try
+            {
+                lock (database)
+                {
+                    database.insertUserRow(user.UUID, user.username, user.surname, user.passwordHash, user.passwordSalt,
+                                           user.homeRegion, user.homeLocation.X, user.homeLocation.Y,
+                                           user.homeLocation.Z,
+                                           user.homeLookAt.X, user.homeLookAt.Y, user.homeLookAt.Z, user.created,
+                                           user.lastLogin, user.userInventoryURI, user.userAssetURI,
+                                           user.profileCanDoMask, user.profileWantDoMask,
+                                           user.profileAboutText, user.profileFirstText, user.profileImage,
+                                           user.profileFirstImage, user.webLoginKey);
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Creates a new agent
+        /// </summary>
+        /// <param name="agent">The agent to create</param>
+        override public void AddNewUserAgent(UserAgentData agent)
+        {
+            try
+            {
+                lock (database)
+                {
+                    database.insertAgentRow(agent);
+                }
+            }
+            catch (Exception e)
+            {
+                database.Reconnect();
+                m_log.Error(e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Updates a user profile stored in the DB
+        /// </summary>
+        /// <param name="user">The profile data to use to update the DB</param>
+        override public bool UpdateUserProfile(UserProfileData user)
+        {
+            database.updateUserRow(user.UUID, user.username, user.surname, user.passwordHash, user.passwordSalt,
+                                   user.homeRegion, user.homeLocation.X, user.homeLocation.Y, user.homeLocation.Z, user.homeLookAt.X,
+                                   user.homeLookAt.Y, user.homeLookAt.Z, user.created, user.lastLogin, user.userInventoryURI,
+                                   user.userAssetURI, user.profileCanDoMask, user.profileWantDoMask, user.profileAboutText,
+                                   user.profileFirstText, user.profileImage, user.profileFirstImage, user.webLoginKey);
+            return true;
+        }
+
+        /// <summary>
+        /// Performs a money transfer request between two accounts
+        /// </summary>
+        /// <param name="from">The senders account ID</param>
+        /// <param name="to">The receivers account ID</param>
+        /// <param name="amount">The amount to transfer</param>
+        /// <returns>Success?</returns>
+        override public bool MoneyTransferRequest(LLUUID from, LLUUID to, uint amount)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Performs an inventory transfer request between two accounts
+        /// </summary>
+        /// <remarks>TODO: Move to inventory server</remarks>
+        /// <param name="from">The senders account ID</param>
+        /// <param name="to">The receivers account ID</param>
+        /// <param name="item">The item to transfer</param>
+        /// <returns>Success?</returns>
+        override public bool InventoryTransferRequest(LLUUID from, LLUUID to, LLUUID item)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Database provider name
+        /// </summary>
+        /// <returns>Provider name</returns>
+        override public string getName()
+        {
+            return "MySQL Userdata Interface";
+        }
+
+        /// <summary>
+        /// Database provider version
+        /// </summary>
+        /// <returns>provider version</returns>
+        override public string GetVersion()
+        {
+            return "0.1";
+        }
+    }
+}
diff --git a/OpenSim/Data/MySQL/Properties/AssemblyInfo.cs b/OpenSim/Data/MySQL/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..060e26c
--- /dev/null
+++ b/OpenSim/Data/MySQL/Properties/AssemblyInfo.cs
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly : AssemblyTitle("OpenSim.Framework.Data.MySQL")]
+[assembly : AssemblyDescription("")]
+[assembly : AssemblyConfiguration("")]
+[assembly : AssemblyCompany("")]
+[assembly : AssemblyProduct("OpenSim.Framework.Data.MySQL")]
+[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2008")]
+[assembly : AssemblyTrademark("")]
+[assembly : AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+
+[assembly : ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+
+[assembly : Guid("e49826b2-dcef-41be-a5bd-596733fa3304")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly : AssemblyVersion("1.0.0.0")]
+[assembly : AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Data/MySQL/Resources/AvatarAppearance.sql b/OpenSim/Data/MySQL/Resources/AvatarAppearance.sql
new file mode 100644
index 0000000..b638ee2
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/AvatarAppearance.sql
@@ -0,0 +1,42 @@
+--
+-- Create schema avatar_appearance
+--
+
+CREATE DATABASE IF NOT EXISTS avatar_appearance;
+USE avatar_appearance;
+
+DROP TABLE IF EXISTS `avatarappearance`;
+CREATE TABLE `avatarappearance` (
+  `UUID` char(36) NOT NULL,
+  `Serial` int(10) unsigned NOT NULL,
+  `WearableItem0` char(36) NOT NULL,
+  `WearableAsset0` char(36) NOT NULL,
+  `WearableItem1` char(36) NOT NULL,
+  `WearableAsset1` char(36) NOT NULL,
+  `WearableItem2` char(36) NOT NULL,
+  `WearableAsset2` char(36) NOT NULL,
+  `WearableItem3` char(36) NOT NULL,
+  `WearableAsset3` char(36) NOT NULL,
+  `WearableItem4` char(36) NOT NULL,
+  `WearableAsset4` char(36) NOT NULL,
+  `WearableItem5` char(36) NOT NULL,
+  `WearableAsset5` char(36) NOT NULL,
+  `WearableItem6` char(36) NOT NULL,
+  `WearableAsset6` char(36) NOT NULL,
+  `WearableItem7` char(36) NOT NULL,
+  `WearableAsset7` char(36) NOT NULL,
+  `WearableItem8` char(36) NOT NULL,
+  `WearableAsset8` char(36) NOT NULL,
+  `WearableItem9` char(36) NOT NULL,
+  `WearableAsset9` char(36) NOT NULL,
+  `WearableItem10` char(36) NOT NULL,
+  `WearableAsset10` char(36) NOT NULL,
+  `WearableItem11` char(36) NOT NULL,
+  `WearableAsset11` char(36) NOT NULL,
+  `WearableItem12` char(36) NOT NULL,
+  `WearableAsset12` char(36) NOT NULL,
+
+
+  PRIMARY KEY  (`UUID`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+
diff --git a/OpenSim/Data/MySQL/Resources/CreateAgentsTable.sql b/OpenSim/Data/MySQL/Resources/CreateAgentsTable.sql
new file mode 100644
index 0000000..3ef7bc9
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/CreateAgentsTable.sql
@@ -0,0 +1,24 @@
+SET FOREIGN_KEY_CHECKS=0;
+-- ----------------------------
+-- Table structure for agents
+-- ----------------------------
+CREATE TABLE `agents` (
+  `UUID` varchar(36) NOT NULL,
+  `sessionID` varchar(36) NOT NULL,
+  `secureSessionID` varchar(36) NOT NULL,
+  `agentIP` varchar(16) NOT NULL,
+  `agentPort` int(11) NOT NULL,
+  `agentOnline` tinyint(4) NOT NULL,
+  `loginTime` int(11) NOT NULL,
+  `logoutTime` int(11) NOT NULL,
+  `currentRegion` varchar(36) NOT NULL,
+  `currentHandle` bigint(20) unsigned NOT NULL,
+  `currentPos` varchar(64) NOT NULL,
+  PRIMARY KEY  (`UUID`),
+  UNIQUE KEY `session` (`sessionID`),
+  UNIQUE KEY `ssession` (`secureSessionID`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Rev. 1';
+
+-- ----------------------------
+-- Records 
+-- ----------------------------
diff --git a/OpenSim/Data/MySQL/Resources/CreateAssetsTable.sql b/OpenSim/Data/MySQL/Resources/CreateAssetsTable.sql
new file mode 100644
index 0000000..2c750fe
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/CreateAssetsTable.sql
@@ -0,0 +1,11 @@
+CREATE TABLE `assets` (
+  `id` binary(16) NOT NULL,
+  `name` varchar(64) NOT NULL,
+  `description` varchar(64) NOT NULL,
+  `assetType` tinyint(4) NOT NULL,
+  `invType` tinyint(4) NOT NULL,
+  `local` tinyint(1) NOT NULL,
+  `temporary` tinyint(1) NOT NULL,
+  `data` longblob NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Rev. 1';
\ No newline at end of file
diff --git a/OpenSim/Data/MySQL/Resources/CreateFoldersTable.sql b/OpenSim/Data/MySQL/Resources/CreateFoldersTable.sql
new file mode 100644
index 0000000..b5bddde
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/CreateFoldersTable.sql
@@ -0,0 +1,11 @@
+CREATE TABLE `inventoryfolders` (
+  `folderID` varchar(36) NOT NULL default '',
+  `agentID` varchar(36) default NULL,
+  `parentFolderID` varchar(36) default NULL,
+  `folderName` varchar(64) default NULL,
+  `type` smallint NOT NULL default 0,
+  `version` int NOT NULL default 0,
+  PRIMARY KEY  (`folderID`),
+  KEY `owner` (`agentID`),
+  KEY `parent` (`parentFolderID`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Rev. 2';
diff --git a/OpenSim/Data/MySQL/Resources/CreateItemsTable.sql b/OpenSim/Data/MySQL/Resources/CreateItemsTable.sql
new file mode 100644
index 0000000..1723ee3
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/CreateItemsTable.sql
@@ -0,0 +1,18 @@
+CREATE TABLE `inventoryitems` (
+  `inventoryID` varchar(36) NOT NULL default '',
+  `assetID` varchar(36) default NULL,
+  `assetType` int(11) default NULL,
+  `parentFolderID` varchar(36) default NULL,
+  `avatarID` varchar(36) default NULL,
+  `inventoryName` varchar(64) default NULL,
+  `inventoryDescription` varchar(128) default NULL,
+  `inventoryNextPermissions` int(10) unsigned default NULL,
+  `inventoryCurrentPermissions` int(10) unsigned default NULL,
+  `invType` int(11) default NULL,
+  `creatorID` varchar(36) default NULL,
+  `inventoryBasePermissions` int(10) unsigned NOT NULL default 0,
+  `inventoryEveryOnePermissions` int(10) unsigned NOT NULL default 0,
+  PRIMARY KEY  (`inventoryID`),
+  KEY `owner` (`avatarID`),
+  KEY `folder` (`parentFolderID`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Rev. 2';
diff --git a/OpenSim/Data/MySQL/Resources/CreateLogsTable.sql b/OpenSim/Data/MySQL/Resources/CreateLogsTable.sql
new file mode 100644
index 0000000..64b3a80
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/CreateLogsTable.sql
@@ -0,0 +1,10 @@
+CREATE TABLE `logs` (
+  `logID` int(10) unsigned NOT NULL auto_increment,
+  `target` varchar(36) default NULL,
+  `server` varchar(64) default NULL,
+  `method` varchar(64) default NULL,
+  `arguments` varchar(255) default NULL,
+  `priority` int(11) default NULL,
+  `message` text,
+  PRIMARY KEY  (`logID`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Rev. 1';
diff --git a/OpenSim/Data/MySQL/Resources/CreateRegionsTable.sql b/OpenSim/Data/MySQL/Resources/CreateRegionsTable.sql
new file mode 100644
index 0000000..cb0f9bd
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/CreateRegionsTable.sql
@@ -0,0 +1,32 @@
+CREATE TABLE `regions` (
+  `uuid` varchar(36) NOT NULL,
+  `regionHandle` bigint(20) unsigned NOT NULL,
+  `regionName` varchar(32) default NULL,
+  `regionRecvKey` varchar(128) default NULL,
+  `regionSendKey` varchar(128) default NULL,
+  `regionSecret` varchar(128) default NULL,
+  `regionDataURI` varchar(255) default NULL,
+  `serverIP` varchar(64) default NULL,
+  `serverPort` int(10) unsigned default NULL,
+  `serverURI` varchar(255) default NULL,
+  `locX` int(10) unsigned default NULL,
+  `locY` int(10) unsigned default NULL,
+  `locZ` int(10) unsigned default NULL,
+  `eastOverrideHandle` bigint(20) unsigned default NULL,
+  `westOverrideHandle` bigint(20) unsigned default NULL,
+  `southOverrideHandle` bigint(20) unsigned default NULL,
+  `northOverrideHandle` bigint(20) unsigned default NULL,
+  `regionAssetURI` varchar(255) default NULL,
+  `regionAssetRecvKey` varchar(128) default NULL,
+  `regionAssetSendKey` varchar(128) default NULL,
+  `regionUserURI` varchar(255) default NULL,
+  `regionUserRecvKey` varchar(128) default NULL,
+  `regionUserSendKey` varchar(128) default NULL, `regionMapTexture` varchar(36) default NULL,
+  `serverHttpPort` int(10) default NULL, `serverRemotingPort` int(10) default NULL,
+  `owner_uuid` varchar(36) default '00000000-0000-0000-0000-000000000000' not null,
+  `originUUID` varchar(36),
+  PRIMARY KEY  (`uuid`),
+  KEY `regionName` (`regionName`),
+  KEY `regionHandle` (`regionHandle`),
+  KEY `overrideHandles` (`eastOverrideHandle`,`westOverrideHandle`,`southOverrideHandle`,`northOverrideHandle`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=FIXED COMMENT='Rev. 3';
diff --git a/OpenSim/Data/MySQL/Resources/CreateUserFriendsTable.sql b/OpenSim/Data/MySQL/Resources/CreateUserFriendsTable.sql
new file mode 100644
index 0000000..8480d48
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/CreateUserFriendsTable.sql
@@ -0,0 +1,11 @@
+SET FOREIGN_KEY_CHECKS=0;
+-- ----------------------------
+-- Table structure for users
+-- ----------------------------
+CREATE TABLE `userfriends` (
+   `ownerID` VARCHAR(37) NOT NULL,
+   `friendID` VARCHAR(37) NOT NULL,
+   `friendPerms` INT NOT NULL,
+   `datetimestamp` INT NOT NULL,
+         UNIQUE KEY  (`ownerID`, `friendID`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Rev.1';
\ No newline at end of file
diff --git a/OpenSim/Data/MySQL/Resources/CreateUsersTable.sql b/OpenSim/Data/MySQL/Resources/CreateUsersTable.sql
new file mode 100644
index 0000000..d9e8ae2
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/CreateUsersTable.sql
@@ -0,0 +1,35 @@
+SET FOREIGN_KEY_CHECKS=0;
+-- ----------------------------
+-- Table structure for users
+-- ----------------------------
+CREATE TABLE `users` (
+  `UUID` varchar(36) NOT NULL default '',
+  `username` varchar(32) NOT NULL,
+  `lastname` varchar(32) NOT NULL,
+  `passwordHash` varchar(32) NOT NULL,
+  `passwordSalt` varchar(32) NOT NULL,
+  `homeRegion` bigint(20) unsigned default NULL,
+  `homeLocationX` float default NULL,
+  `homeLocationY` float default NULL,
+  `homeLocationZ` float default NULL,
+  `homeLookAtX` float default NULL,
+  `homeLookAtY` float default NULL,
+  `homeLookAtZ` float default NULL,
+  `created` int(11) NOT NULL,
+  `lastLogin` int(11) NOT NULL,
+  `userInventoryURI` varchar(255) default NULL,
+  `userAssetURI` varchar(255) default NULL,
+  `profileCanDoMask` int(10) unsigned default NULL,
+  `profileWantDoMask` int(10) unsigned default NULL,
+  `profileAboutText` text,
+  `profileFirstText` text,
+  `profileImage` varchar(36) default NULL,
+  `profileFirstImage` varchar(36) default NULL,
+  `webLoginKey` varchar(36) default NULL,
+  PRIMARY KEY  (`UUID`),
+  UNIQUE KEY `usernames` (`username`,`lastname`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Rev. 2';
+
+-- ----------------------------
+-- Records 
+-- ----------------------------
diff --git a/OpenSim/Data/MySQL/Resources/UpgradeFoldersTableToVersion2.sql b/OpenSim/Data/MySQL/Resources/UpgradeFoldersTableToVersion2.sql
new file mode 100644
index 0000000..b5a7964
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/UpgradeFoldersTableToVersion2.sql
@@ -0,0 +1,4 @@
+ALTER TABLE `inventoryfolders` 
+        ADD COLUMN `type` smallint NOT NULL default 0,
+        ADD COLUMN `version` int NOT NULL default 0,
+COMMENT='Rev. 2';
diff --git a/OpenSim/Data/MySQL/Resources/UpgradeItemsTableToVersion2.sql b/OpenSim/Data/MySQL/Resources/UpgradeItemsTableToVersion2.sql
new file mode 100644
index 0000000..d1ef504
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/UpgradeItemsTableToVersion2.sql
@@ -0,0 +1,9 @@
+ALTER TABLE `inventoryitems` 
+        CHANGE COLUMN `type` `assetType` int(11) default NULL,
+        ADD COLUMN `invType` int(11) default NULL,
+        ADD COLUMN `creatorID` varchar(36) default NULL,
+        ADD COLUMN `inventoryBasePermissions` int(10) unsigned NOT NULL default 0,
+        ADD COLUMN `inventoryEveryOnePermissions` int(10) unsigned NOT NULL default 0,
+COMMENT='Rev. 2';
+
+UPDATE `inventoryitems` SET invType=assetType;
diff --git a/OpenSim/Data/MySQL/Resources/UpgradeRegionsTableToVersion2.sql b/OpenSim/Data/MySQL/Resources/UpgradeRegionsTableToVersion2.sql
new file mode 100644
index 0000000..034b755
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/UpgradeRegionsTableToVersion2.sql
@@ -0,0 +1,4 @@
+ALTER TABLE `regions` 
+        ADD COLUMN `originUUID` varchar(36),
+COMMENT='Rev. 2';
+UPDATE `regions` SET originUUID=uuid;
diff --git a/OpenSim/Data/MySQL/Resources/UpgradeRegionsTableToVersion3.sql b/OpenSim/Data/MySQL/Resources/UpgradeRegionsTableToVersion3.sql
new file mode 100644
index 0000000..b48afec
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/UpgradeRegionsTableToVersion3.sql
@@ -0,0 +1,18 @@
+DROP PROCEDURE IF EXISTS upgraderegions3;
+
+create procedure upgraderegions3()
+BEGIN
+DECLARE db_name varchar(64);
+select database() into db_name;
+IF ((select count(*) from information_schema.columns where table_name='regions' and column_name='owner_uuid' and table_schema=db_name) > 0)
+THEN
+    ALTER TABLE `regions`, COMMENT='Rev. 3';
+ELSE
+    ALTER TABLE `regions`
+        ADD COLUMN `owner_uuid` varchar(36) default '00000000-0000-0000-0000-000000000000' not null after serverRemotingPort, COMMENT='Rev. 3';
+END IF;
+END; 
+
+call upgraderegions3();
+
+
diff --git a/OpenSim/Data/MySQL/Resources/UpgradeUsersTableToVersion2.sql b/OpenSim/Data/MySQL/Resources/UpgradeUsersTableToVersion2.sql
new file mode 100644
index 0000000..dd21a66
--- /dev/null
+++ b/OpenSim/Data/MySQL/Resources/UpgradeUsersTableToVersion2.sql
@@ -0,0 +1,3 @@
+ALTER TABLE `users` 
+        ADD COLUMN `webLoginKey` varchar(36) default '00000000-0000-0000-0000-000000000000' NOT NULL,
+COMMENT='Rev. 2';
\ No newline at end of file
diff --git a/OpenSim/Data/MySQLMapper/MySQLDataReader.cs b/OpenSim/Data/MySQLMapper/MySQLDataReader.cs
new file mode 100644
index 0000000..9fd50f6
--- /dev/null
+++ b/OpenSim/Data/MySQLMapper/MySQLDataReader.cs
@@ -0,0 +1,15 @@
+using System;

+using System.Collections.Generic;

+using System.Data;

+using System.Text;

+using OpenSim.Framework.Data.Base;

+

+namespace OpenSim.Framework.Data.MySQLMapper

+{

+    public class MySQLDataReader : OpenSimDataReader

+    {

+        public MySQLDataReader(IDataReader source) : base(source)

+        {

+        }

+    }

+}

diff --git a/OpenSim/Data/MySQLMapper/MySQLDatabaseMapper.cs b/OpenSim/Data/MySQLMapper/MySQLDatabaseMapper.cs
new file mode 100644
index 0000000..3f5b18f
--- /dev/null
+++ b/OpenSim/Data/MySQLMapper/MySQLDatabaseMapper.cs
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Data;
+using System.Data.Common;
+using MySql.Data.MySqlClient;
+using OpenSim.Framework.Data;
+using OpenSim.Framework.Data.Base;
+
+namespace OpenSim.Framework.Data.MySQLMapper
+{
+    public class MySQLDatabaseMapper : OpenSimDatabaseConnector
+    {
+        public MySQLDatabaseMapper(string connectionString)
+            : base(connectionString)
+        {
+        }
+
+        public override DbConnection GetNewConnection()
+        {
+            MySqlConnection connection = new MySqlConnection(m_connectionString);
+            return connection;
+        }
+
+        public override string CreateParamName(string fieldName)
+        {
+            return "?" + fieldName;
+        }
+
+        public override BaseDataReader CreateReader(IDataReader reader)
+        {
+            return new MySQLDataReader( reader );
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Data/SQLite/Properties/AssemblyInfo.cs b/OpenSim/Data/SQLite/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..600405e
--- /dev/null
+++ b/OpenSim/Data/SQLite/Properties/AssemblyInfo.cs
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly : AssemblyTitle("OpenSim.Framework.Data.SQLite")]
+[assembly : AssemblyDescription("")]
+[assembly : AssemblyConfiguration("")]
+[assembly : AssemblyCompany("")]
+[assembly : AssemblyProduct("OpenSim.Framework.Data.SQLite")]
+[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2008")]
+[assembly : AssemblyTrademark("")]
+[assembly : AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+
+[assembly : ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+
+[assembly : Guid("6113d5ce-4547-49f4-9236-0dcc503457b1")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+
+[assembly : AssemblyVersion("1.0.0.0")]
+[assembly : AssemblyFileVersion("1.0.0.0")]
diff --git a/OpenSim/Data/SQLite/Resources/001_AssetStore.sql b/OpenSim/Data/SQLite/Resources/001_AssetStore.sql
new file mode 100644
index 0000000..1dc05d8
--- /dev/null
+++ b/OpenSim/Data/SQLite/Resources/001_AssetStore.sql
@@ -0,0 +1,13 @@
+BEGIN TRANSACTION;
+
+CREATE TABLE assets(
+        UUID varchar(255) primary key,
+        Name varchar(255),
+        Description varchar(255),
+        Type integer,
+        InvType integer,
+        Local integer,
+        Temporary integer,
+        Data blob);
+
+COMMIT;
diff --git a/OpenSim/Data/SQLite/Resources/001_InventoryStore.sql b/OpenSim/Data/SQLite/Resources/001_InventoryStore.sql
new file mode 100644
index 0000000..e4951b0
--- /dev/null
+++ b/OpenSim/Data/SQLite/Resources/001_InventoryStore.sql
@@ -0,0 +1,26 @@
+BEGIN TRANSACTION;
+
+CREATE TABLE inventoryitems(
+        UUID varchar(255) primary key,
+        assetID varchar(255),
+        assetType integer,
+        invType integer,
+        parentFolderID varchar(255),
+        avatarID varchar(255),
+        creatorsID varchar(255),
+        inventoryName varchar(255),
+        inventoryDescription varchar(255),
+        inventoryNextPermissions integer,
+        inventoryCurrentPermissions integer,
+        inventoryBasePermissions integer,
+        inventoryEveryOnePermissions integer);
+
+CREATE TABLE inventoryfolders(
+        UUID varchar(255) primary key,
+        name varchar(255),
+        agentID varchar(255),
+        parentID varchar(255),
+        type integer,
+        version integer);
+
+COMMIT;
diff --git a/OpenSim/Data/SQLite/Resources/001_RegionStore.sql b/OpenSim/Data/SQLite/Resources/001_RegionStore.sql
new file mode 100644
index 0000000..15f3d9f
--- /dev/null
+++ b/OpenSim/Data/SQLite/Resources/001_RegionStore.sql
@@ -0,0 +1,122 @@
+BEGIN TRANSACTION;
+
+CREATE TABLE prims(
+        UUID varchar(255) primary key,
+        RegionUUID varchar(255),
+        ParentID integer,
+        CreationDate integer,
+        Name varchar(255),
+        SceneGroupID varchar(255),
+        Text varchar(255),
+        Description varchar(255),
+        SitName varchar(255),
+        TouchName varchar(255),
+        CreatorID varchar(255),
+        OwnerID varchar(255),
+        GroupID varchar(255),
+        LastOwnerID varchar(255),
+        OwnerMask integer,
+        NextOwnerMask integer,
+        GroupMask integer,
+        EveryoneMask integer,
+        BaseMask integer,
+        PositionX float,
+        PositionY float,
+        PositionZ float,
+        GroupPositionX float,
+        GroupPositionY float,
+        GroupPositionZ float,
+        VelocityX float,
+        VelocityY float,
+        VelocityZ float,
+        AngularVelocityX float,
+        AngularVelocityY float,
+        AngularVelocityZ float,
+        AccelerationX float,
+        AccelerationY float,
+        AccelerationZ float,
+        RotationX float,
+        RotationY float,
+        RotationZ float,
+        RotationW float, 
+        ObjectFlags integer, 
+        SitTargetOffsetX float NOT NULL default 0, 
+        SitTargetOffsetY float NOT NULL default 0, 
+        SitTargetOffsetZ float NOT NULL default 0, 
+        SitTargetOrientW float NOT NULL default 0, 
+        SitTargetOrientX float NOT NULL default 0, 
+        SitTargetOrientY float NOT NULL default 0, 
+        SitTargetOrientZ float NOT NULL default 0);
+
+CREATE TABLE primshapes(UUID varchar(255) primary key,
+        Shape integer,
+        ScaleX float,
+        ScaleY float,
+        ScaleZ float,
+        PCode integer,
+        PathBegin integer,
+        PathEnd integer,
+        PathScaleX integer,
+        PathScaleY integer,
+        PathShearX integer,
+        PathShearY integer,
+        PathSkew integer,
+        PathCurve integer,
+        PathRadiusOffset integer,
+        PathRevolutions integer,
+        PathTaperX integer,
+        PathTaperY integer,
+        PathTwist integer,
+        PathTwistBegin integer,
+        ProfileBegin integer,
+        ProfileEnd integer,
+        ProfileCurve integer,
+        ProfileHollow integer,
+        State integer,
+        Texture blob,
+        ExtraParams blob);
+
+CREATE TABLE terrain(
+        RegionUUID varchar(255),
+        Revision integer,
+        Heightfield blob);
+
+CREATE TABLE land(
+        UUID varchar(255) primary key,
+        RegionUUID varchar(255),
+        LocalLandID string,
+        Bitmap blob,
+        Name varchar(255),
+        Desc varchar(255),
+        OwnerUUID varchar(36),
+        IsGroupOwned string,
+        Area integer,
+        AuctionID integer,
+        Category integer,
+        ClaimDate integer,
+        ClaimPrice integer,
+        GroupUUID varchar(255),
+        SalePrice integer,
+        LandStatus integer,
+        LandFlags string,
+        LandingType string,
+        MediaAutoScale string,
+        MediaTextureUUID varchar(255),
+        MediaURL varchar(255),
+        MusicURL varchar(255),
+        PassHours float,
+        PassPrice string,
+        SnapshotUUID varchar(255),
+        UserLocationX float,
+        UserLocationY float,
+        UserLocationZ float,    
+        UserLookAtX float,
+        UserLookAtY float,
+        UserLookAtZ float);
+
+CREATE TABLE landaccesslist(
+        LandUUID varchar(255),
+        AccessUUID varchar(255),
+        Flags string);
+
+COMMIT;
diff --git a/OpenSim/Data/SQLite/Resources/001_UserStore.sql b/OpenSim/Data/SQLite/Resources/001_UserStore.sql
new file mode 100644
index 0000000..070e340
--- /dev/null
+++ b/OpenSim/Data/SQLite/Resources/001_UserStore.sql
@@ -0,0 +1,37 @@
+BEGIN TRANSACTION;
+
+CREATE TABLE users(
+        UUID varchar(255) primary key,
+        username varchar(255),
+        surname varchar(255),
+        passwordHash varchar(255),
+        passwordSalt varchar(255),
+        homeRegionX integer,
+        homeRegionY integer,
+        homeLocationX float,    
+        homeLocationY float,
+        homeLocationZ float,
+        homeLookAtX float,
+        homeLookAtY float,
+        homeLookAtZ float,
+        created integer,
+        lastLogin integer,
+        rootInventoryFolderID varchar(255),
+        userInventoryURI varchar(255),
+        userAssetURI varchar(255),
+        profileCanDoMask integer,
+        profileWantDoMask integer,
+        profileAboutText varchar(255),
+        profileFirstText varchar(255),
+        profileImage varchar(255),
+        profileFirstImage varchar(255), 
+        webLoginKey text default '00000000-0000-0000-0000-000000000000');
+
+CREATE TABLE userfriends(
+        ownerID varchar(255),
+        friendID varchar(255),
+        friendPerms integer,
+        ownerPerms integer,
+        datetimestamp integer);
+
+COMMIT;
diff --git a/OpenSim/Data/SQLite/SQLiteAssetData.cs b/OpenSim/Data/SQLite/SQLiteAssetData.cs
new file mode 100644
index 0000000..afa73b1
--- /dev/null
+++ b/OpenSim/Data/SQLite/SQLiteAssetData.cs
@@ -0,0 +1,301 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Data;
+using System.Reflection;
+using libsecondlife;
+using Mono.Data.SqliteClient;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.SQLite
+{
+    /// <summary>
+    /// A User storage interface for the DB4o database system
+    /// </summary>
+    public class SQLiteAssetData : AssetDataBase
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// The database manager
+        /// </summary>
+        /// <summary>
+        /// Artificial constructor called upon plugin load
+        /// </summary>
+        private const string SelectAssetSQL = "select * from assets where UUID=:UUID";
+        private const string DeleteAssetSQL = "delete from assets where UUID=:UUID";
+        private const string InsertAssetSQL = "insert into assets(UUID, Name, Description, Type, InvType, Local, Temporary, Data) values(:UUID, :Name, :Description, :Type, :InvType, :Local, :Temporary, :Data)";
+        private const string UpdateAssetSQL = "update assets set Name=:Name, Description=:Description, Type=:Type, InvType=:InvType, Local=:Local, Temporary=:Temporary, Data=:Data where UUID=:UUID"; 
+        private const string assetSelect = "select * from assets";
+
+        private SqliteConnection m_conn;
+
+        public void Initialise(string dbfile, string dbname)
+        {
+            m_conn = new SqliteConnection("URI=file:" + dbfile + ",version=3");
+            m_conn.Open();
+            TestTables(m_conn);
+            return;
+        }
+
+        override public AssetBase FetchAsset(LLUUID uuid)
+        {
+            
+            using (SqliteCommand cmd = new SqliteCommand(SelectAssetSQL, m_conn))
+            {
+                cmd.Parameters.Add(new SqliteParameter(":UUID", Util.ToRawUuidString(uuid)));
+                using (IDataReader reader = cmd.ExecuteReader()) 
+                {
+                    if (reader.Read())
+                    {
+                        AssetBase asset = buildAsset(reader);
+                        reader.Close();
+                        return asset;
+                    }
+                    else
+                    {
+                        reader.Close();
+                        return null;
+                    }
+                }
+            }
+        }
+
+        override public void CreateAsset(AssetBase asset)
+        {
+            m_log.Info("[SQLITE]: Creating Asset " + Util.ToRawUuidString(asset.FullID));
+            if (ExistsAsset(asset.FullID))
+            {
+                m_log.Info("[SQLITE]: Asset exists already, ignoring.");
+            }
+            else 
+            {
+                using (SqliteCommand cmd = new SqliteCommand(InsertAssetSQL, m_conn))
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":UUID", Util.ToRawUuidString(asset.FullID)));
+                    cmd.Parameters.Add(new SqliteParameter(":Name", asset.Name));
+                    cmd.Parameters.Add(new SqliteParameter(":Description", asset.Description));
+                    cmd.Parameters.Add(new SqliteParameter(":Type", asset.Type));
+                    cmd.Parameters.Add(new SqliteParameter(":InvType", asset.InvType));
+                    cmd.Parameters.Add(new SqliteParameter(":Local", asset.Local));
+                    cmd.Parameters.Add(new SqliteParameter(":Temporary", asset.Temporary));
+                    cmd.Parameters.Add(new SqliteParameter(":Data", asset.Data));
+                    
+                    cmd.ExecuteNonQuery();
+                }
+            }
+        }
+
+        override public void UpdateAsset(AssetBase asset)
+        {
+            LogAssetLoad(asset);
+            
+            using (SqliteCommand cmd = new SqliteCommand(UpdateAssetSQL, m_conn))
+            {
+                cmd.Parameters.Add(new SqliteParameter(":UUID", Util.ToRawUuidString(asset.FullID)));
+                cmd.Parameters.Add(new SqliteParameter(":Name", asset.Name));
+                cmd.Parameters.Add(new SqliteParameter(":Description", asset.Description));
+                cmd.Parameters.Add(new SqliteParameter(":Type", asset.Type));
+                cmd.Parameters.Add(new SqliteParameter(":InvType", asset.InvType));
+                cmd.Parameters.Add(new SqliteParameter(":Local", asset.Local));
+                cmd.Parameters.Add(new SqliteParameter(":Temporary", asset.Temporary));
+                cmd.Parameters.Add(new SqliteParameter(":Data", asset.Data));
+                
+                cmd.ExecuteNonQuery();
+            }
+
+        }
+
+        private void LogAssetLoad(AssetBase asset)
+        {
+            string temporary = asset.Temporary ? "Temporary" : "Stored";
+            string local = asset.Local ? "Local" : "Remote";
+
+            int assetLength = (asset.Data != null) ? asset.Data.Length : 0;
+
+            m_log.Info("[SQLITE]: " +
+                                     string.Format("Loaded {6} {5} Asset: [{0}][{3}/{4}] \"{1}\":{2} ({7} bytes)",
+                                                   asset.FullID, asset.Name, asset.Description, asset.Type,
+                                                   asset.InvType, temporary, local, assetLength));
+        }
+
+        override public bool ExistsAsset(LLUUID uuid)
+        {
+            using (SqliteCommand cmd = new SqliteCommand(SelectAssetSQL, m_conn))
+            {
+                cmd.Parameters.Add(new SqliteParameter(":UUID", Util.ToRawUuidString(uuid)));
+                using (IDataReader reader = cmd.ExecuteReader()) 
+                {
+                    if(reader.Read())
+                    {
+                        reader.Close();
+                        return true;
+                    }
+                    else 
+                    {
+                        reader.Close();
+                        return false;
+                    }
+                }
+            }
+        }
+
+        public void DeleteAsset(LLUUID uuid)
+        {
+            using (SqliteCommand cmd = new SqliteCommand(DeleteAssetSQL, m_conn))
+            {
+                cmd.Parameters.Add(new SqliteParameter(":UUID", Util.ToRawUuidString(uuid)));
+                
+                cmd.ExecuteNonQuery();
+            }
+        }
+
+        override public void CommitAssets() // force a sync to the database
+        {
+            m_log.Info("[SQLITE]: Attempting commit");
+            // lock (ds)
+            //             {
+            //                 da.Update(ds, "assets");
+            //                 ds.AcceptChanges();
+            // }
+        }
+
+        /***********************************************************************
+         *
+         *  Database Definition Functions
+         * 
+         *  This should be db agnostic as we define them in ADO.NET terms
+         *
+         **********************************************************************/
+
+        private DataTable createAssetsTable()
+        {
+            DataTable assets = new DataTable("assets");
+
+            SQLiteUtil.createCol(assets, "UUID", typeof (String));
+            SQLiteUtil.createCol(assets, "Name", typeof (String));
+            SQLiteUtil.createCol(assets, "Description", typeof (String));
+            SQLiteUtil.createCol(assets, "Type", typeof (Int32));
+            SQLiteUtil.createCol(assets, "InvType", typeof (Int32));
+            SQLiteUtil.createCol(assets, "Local", typeof (Boolean));
+            SQLiteUtil.createCol(assets, "Temporary", typeof (Boolean));
+            SQLiteUtil.createCol(assets, "Data", typeof (Byte[]));
+            // Add in contraints
+            assets.PrimaryKey = new DataColumn[] {assets.Columns["UUID"]};
+            return assets;
+        }
+
+        /***********************************************************************
+         *  
+         *  Convert between ADO.NET <=> OpenSim Objects
+         *
+         *  These should be database independant
+         *
+         **********************************************************************/
+
+        private AssetBase buildAsset(IDataReader row)
+        {
+            // TODO: this doesn't work yet because something more
+            // interesting has to be done to actually get these values
+            // back out.  Not enough time to figure it out yet.
+            AssetBase asset = new AssetBase();
+
+            asset.FullID = new LLUUID((String) row["UUID"]);
+            asset.Name = (String) row["Name"];
+            asset.Description = (String) row["Description"];
+            asset.Type = Convert.ToSByte(row["Type"]);
+            asset.InvType = Convert.ToSByte(row["InvType"]);
+            asset.Local = Convert.ToBoolean(row["Local"]);
+            asset.Temporary = Convert.ToBoolean(row["Temporary"]);
+            asset.Data = (byte[]) row["Data"];
+            return asset;
+        }
+
+
+        /***********************************************************************
+         *
+         *  Database Binding functions
+         *
+         *  These will be db specific due to typing, and minor differences
+         *  in databases.
+         *
+         **********************************************************************/
+
+        private void InitDB(SqliteConnection conn)
+        {
+            string createAssets = SQLiteUtil.defineTable(createAssetsTable());
+            SqliteCommand pcmd = new SqliteCommand(createAssets, conn);
+            pcmd.ExecuteNonQuery();
+        }
+
+        private bool TestTables(SqliteConnection conn)
+        {
+            SqliteCommand cmd = new SqliteCommand(assetSelect, conn);
+            SqliteDataAdapter pDa = new SqliteDataAdapter(cmd);
+            DataSet tmpDS = new DataSet();
+            try
+            {
+                pDa.Fill(tmpDS, "assets");
+            }
+            catch (SqliteSyntaxException)
+            {
+                m_log.Info("[SQLITE]: SQLite Database doesn't exist... creating");
+                InitDB(conn);
+            }
+            return true;
+        }
+
+        #region IPlugin interface
+
+        override public string Version
+        {
+            get
+            {
+                Module module = GetType().Module;
+                string dllName = module.Assembly.ManifestModule.Name;
+                Version dllVersion = module.Assembly.GetName().Version;
+
+                return
+                    string.Format("{0}.{1}.{2}.{3}", dllVersion.Major, dllVersion.Minor, dllVersion.Build,
+                                  dllVersion.Revision);
+            }
+        }
+
+        override public void Initialise()
+        {
+            Initialise("AssetStorage.db", "");
+        }
+
+        override public string Name
+        {
+            get { return "SQLite Asset storage engine"; }
+        }
+
+        #endregion
+    }
+}
diff --git a/OpenSim/Data/SQLite/SQLiteGridData.cs b/OpenSim/Data/SQLite/SQLiteGridData.cs
new file mode 100644
index 0000000..94e8e50
--- /dev/null
+++ b/OpenSim/Data/SQLite/SQLiteGridData.cs
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Security.Cryptography;
+using System.Text;
+using libsecondlife;
+
+namespace OpenSim.Framework.Data.SQLite
+{
+    /// <summary>
+    /// A Grid Interface to the SQLite database
+    /// </summary>
+    public class SQLiteGridData : GridDataBase
+    {
+        /// <summary>
+        /// A database manager
+        /// </summary>
+        private SQLiteManager database;
+
+        /// <summary>
+        /// Initialises the Grid Interface
+        /// </summary>
+        override public void Initialise()
+        {
+            database = new SQLiteManager("localhost", "db", "user", "password", "false");
+        }
+
+        /// <summary>
+        /// Shuts down the grid interface
+        /// </summary>
+        override public void Close()
+        {
+            database.Close();
+        }
+
+        /// <summary>
+        /// Returns the name of this grid interface
+        /// </summary>
+        /// <returns>A string containing the grid interface</returns>
+        override public string getName()
+        {
+            return "SQLite OpenGridData";
+        }
+
+        /// <summary>
+        /// Returns the version of this grid interface
+        /// </summary>
+        /// <returns>A string containing the version</returns>
+        override public string getVersion()
+        {
+            return "0.1";
+        }
+
+        /// <summary>
+        /// Returns a list of regions within the specified ranges
+        /// </summary>
+        /// <param name="a">minimum X coordinate</param>
+        /// <param name="b">minimum Y coordinate</param>
+        /// <param name="c">maximum X coordinate</param>
+        /// <param name="d">maximum Y coordinate</param>
+        /// <returns>An array of region profiles</returns>
+        override public RegionProfileData[] GetProfilesInRange(uint a, uint b, uint c, uint d)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a sim profile from it's location
+        /// </summary>
+        /// <param name="handle">Region location handle</param>
+        /// <returns>Sim profile</returns>
+        override public RegionProfileData GetProfileByHandle(ulong handle)
+        {
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["handle"] = handle.ToString();
+
+            IDbCommand result = database.Query("SELECT * FROM regions WHERE handle = @handle", param);
+            IDataReader reader = result.ExecuteReader();
+
+            RegionProfileData row = database.getRow(reader);
+            reader.Close();
+            result.Dispose();
+
+            return row;
+        }
+
+        /// <summary>
+        /// Returns a sim profile from it's Region name string
+        /// </summary>
+        /// <param name="regionName">The region name search query</param>
+        /// <returns>The sim profile</returns>
+        override public RegionProfileData GetProfileByString(string regionName)
+        {
+            if (regionName.Length > 2)
+            {
+                Dictionary<string, string> param = new Dictionary<string, string>();
+                // Add % because this is a like query.
+                param["?regionName"] = regionName + "%";
+                // Only returns one record or no record.
+                IDbCommand result = database.Query("SELECT * FROM regions WHERE regionName like ?regionName LIMIT 1", param);
+                IDataReader reader = result.ExecuteReader();
+
+                RegionProfileData row = database.getRow(reader);
+                reader.Close();
+                result.Dispose();
+
+                return row;
+            }
+            else
+            {
+                //m_log.Error("[DATABASE]: Searched for a Region Name shorter then 3 characters");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a sim profile from it's UUID
+        /// </summary>
+        /// <param name="uuid">The region UUID</param>
+        /// <returns>The sim profile</returns>
+        override public RegionProfileData GetProfileByLLUUID(LLUUID uuid)
+        {
+            Dictionary<string, string> param = new Dictionary<string, string>();
+            param["uuid"] = uuid.ToString();
+
+            IDbCommand result = database.Query("SELECT * FROM regions WHERE uuid = @uuid", param);
+            IDataReader reader = result.ExecuteReader();
+
+            RegionProfileData row = database.getRow(reader);
+            reader.Close();
+            result.Dispose();
+
+            return row;
+        }
+
+        /// <summary>
+        /// // Returns a list of avatar and UUIDs that match the query
+        /// </summary>
+        public List<AvatarPickerAvatar> GeneratePickerResults(LLUUID queryID, string query)
+        {
+            //Do nothing yet
+            List<AvatarPickerAvatar> returnlist = new List<AvatarPickerAvatar>();
+            return returnlist;
+        }
+
+        /// <summary>
+        /// Adds a new specified region to the database
+        /// </summary>
+        /// <param name="profile">The profile to add</param>
+        /// <returns>A dataresponse enum indicating success</returns>
+        override public DataResponse AddProfile(RegionProfileData profile)
+        {
+            if (database.insertRow(profile))
+            {
+                return DataResponse.RESPONSE_OK;
+            }
+            else
+            {
+                return DataResponse.RESPONSE_ERROR;
+            }
+        }
+
+        /// <summary>
+        /// DEPRECATED. Attempts to authenticate a region by comparing a shared secret.
+        /// </summary>
+        /// <param name="uuid">The UUID of the challenger</param>
+        /// <param name="handle">The attempted regionHandle of the challenger</param>
+        /// <param name="authkey">The secret</param>
+        /// <returns>Whether the secret and regionhandle match the database entry for UUID</returns>
+        override public bool AuthenticateSim(LLUUID uuid, ulong handle, string authkey)
+        {
+            bool throwHissyFit = false; // Should be true by 1.0
+
+            if (throwHissyFit)
+                throw new Exception("CRYPTOWEAK AUTHENTICATE: Refusing to authenticate due to replay potential.");
+
+            RegionProfileData data = GetProfileByLLUUID(uuid);
+
+            return (handle == data.regionHandle && authkey == data.regionSecret);
+        }
+
+        /// <summary>
+        /// NOT YET FUNCTIONAL. Provides a cryptographic authentication of a region
+        /// </summary>
+        /// <remarks>This requires a security audit.</remarks>
+        /// <param name="uuid"></param>
+        /// <param name="handle"></param>
+        /// <param name="authhash"></param>
+        /// <param name="challenge"></param>
+        /// <returns></returns>
+        public bool AuthenticateSim(LLUUID uuid, ulong handle, string authhash, string challenge)
+        {
+            SHA512Managed HashProvider = new SHA512Managed();
+            ASCIIEncoding TextProvider = new ASCIIEncoding();
+
+            byte[] stream = TextProvider.GetBytes(uuid.ToString() + ":" + handle.ToString() + ":" + challenge);
+            byte[] hash = HashProvider.ComputeHash(stream);
+
+            return false;
+        }
+
+        override public ReservationData GetReservationAtPoint(uint x, uint y)
+        {
+            return null;
+        }
+    }
+}
diff --git a/OpenSim/Data/SQLite/SQLiteInventoryStore.cs b/OpenSim/Data/SQLite/SQLiteInventoryStore.cs
new file mode 100644
index 0000000..d31863f
--- /dev/null
+++ b/OpenSim/Data/SQLite/SQLiteInventoryStore.cs
@@ -0,0 +1,664 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Reflection;
+using libsecondlife;
+using Mono.Data.SqliteClient;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.SQLite
+{
+    public class SQLiteInventoryStore : SQLiteUtil, IInventoryData
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        private const string invItemsSelect = "select * from inventoryitems";
+        private const string invFoldersSelect = "select * from inventoryfolders";
+
+        private DataSet ds;
+        private SqliteDataAdapter invItemsDa;
+        private SqliteDataAdapter invFoldersDa;
+
+        /// <summary>
+        /// Initialises the interface
+        /// </summary>
+        public void Initialise()
+        {
+            Initialise("inventoryStore.db", "inventoryDatabase");
+        }
+
+        public void Initialise(string dbfile, string dbname)
+        {
+            string connectionString = "URI=file:" + dbfile + ",version=3";
+
+            m_log.Info("[Inventory]: Sqlite - connecting: " + dbfile);
+            SqliteConnection conn = new SqliteConnection(connectionString);
+
+            conn.Open();
+
+            TestTables(conn);
+
+            SqliteCommand itemsSelectCmd = new SqliteCommand(invItemsSelect, conn);
+            invItemsDa = new SqliteDataAdapter(itemsSelectCmd);
+            //            SqliteCommandBuilder primCb = new SqliteCommandBuilder(primDa);
+
+            SqliteCommand foldersSelectCmd = new SqliteCommand(invFoldersSelect, conn);
+            invFoldersDa = new SqliteDataAdapter(foldersSelectCmd);
+
+            ds = new DataSet();
+
+            ds.Tables.Add(createInventoryFoldersTable());
+            invFoldersDa.Fill(ds.Tables["inventoryfolders"]);
+            setupFoldersCommands(invFoldersDa, conn);
+            m_log.Info("[DATASTORE]: Populated Intentory Folders Definitions");
+
+            ds.Tables.Add(createInventoryItemsTable());
+            invItemsDa.Fill(ds.Tables["inventoryitems"]);
+            setupItemsCommands(invItemsDa, conn);
+            m_log.Info("[DATASTORE]: Populated Intentory Items Definitions");
+
+            ds.AcceptChanges();
+        }
+
+        public InventoryItemBase buildItem(DataRow row)
+        {
+            InventoryItemBase item = new InventoryItemBase();
+            item.inventoryID = new LLUUID((string) row["UUID"]);
+            item.assetID = new LLUUID((string) row["assetID"]);
+            item.assetType = Convert.ToInt32(row["assetType"]);
+            item.invType = Convert.ToInt32(row["invType"]);
+            item.parentFolderID = new LLUUID((string) row["parentFolderID"]);
+            item.avatarID = new LLUUID((string) row["avatarID"]);
+            item.creatorsID = new LLUUID((string) row["creatorsID"]);
+            item.inventoryName = (string) row["inventoryName"];
+            item.inventoryDescription = (string) row["inventoryDescription"];
+
+            item.inventoryNextPermissions = Convert.ToUInt32(row["inventoryNextPermissions"]);
+            item.inventoryCurrentPermissions = Convert.ToUInt32(row["inventoryCurrentPermissions"]);
+            item.inventoryBasePermissions = Convert.ToUInt32(row["inventoryBasePermissions"]);
+            item.inventoryEveryOnePermissions = Convert.ToUInt32(row["inventoryEveryOnePermissions"]);
+            return item;
+        }
+
+        private void fillItemRow(DataRow row, InventoryItemBase item)
+        {
+            row["UUID"] = Util.ToRawUuidString(item.inventoryID);
+            row["assetID"] = Util.ToRawUuidString(item.assetID);
+            row["assetType"] = item.assetType;
+            row["invType"] = item.invType;
+            row["parentFolderID"] = Util.ToRawUuidString(item.parentFolderID);
+            row["avatarID"] = Util.ToRawUuidString(item.avatarID);
+            row["creatorsID"] = Util.ToRawUuidString(item.creatorsID);
+            row["inventoryName"] = item.inventoryName;
+            row["inventoryDescription"] = item.inventoryDescription;
+
+            row["inventoryNextPermissions"] = item.inventoryNextPermissions;
+            row["inventoryCurrentPermissions"] = item.inventoryCurrentPermissions;
+            row["inventoryBasePermissions"] = item.inventoryBasePermissions;
+            row["inventoryEveryOnePermissions"] = item.inventoryEveryOnePermissions;
+        }
+
+        private void addFolder(InventoryFolderBase folder)
+        {
+            lock (ds)
+            {
+                DataTable inventoryFolderTable = ds.Tables["inventoryfolders"];
+
+                DataRow inventoryRow = inventoryFolderTable.Rows.Find(Util.ToRawUuidString(folder.folderID));
+                if (inventoryRow == null)
+                {
+                    inventoryRow = inventoryFolderTable.NewRow();
+                    fillFolderRow(inventoryRow, folder);
+                    inventoryFolderTable.Rows.Add(inventoryRow);
+                }
+                else
+                {
+                    fillFolderRow(inventoryRow, folder);
+                }
+
+                invFoldersDa.Update(ds, "inventoryfolders");
+            }
+        }
+
+        private void moveFolder(InventoryFolderBase folder)
+        {
+            lock (ds)
+            {
+                DataTable inventoryFolderTable = ds.Tables["inventoryfolders"];
+
+                DataRow inventoryRow = inventoryFolderTable.Rows.Find(Util.ToRawUuidString(folder.folderID));
+                if (inventoryRow == null)
+                {
+                    inventoryRow = inventoryFolderTable.NewRow();
+                    fillFolderRow(inventoryRow, folder);
+                    inventoryFolderTable.Rows.Add(inventoryRow);
+                }
+                else
+                {
+                    moveFolderRow(inventoryRow, folder);
+                }
+
+                invFoldersDa.Update(ds, "inventoryfolders");
+            }
+        }
+
+        private void addItem(InventoryItemBase item)
+        {
+            lock (ds)
+            {
+                DataTable inventoryItemTable = ds.Tables["inventoryitems"];
+
+                DataRow inventoryRow = inventoryItemTable.Rows.Find(Util.ToRawUuidString(item.inventoryID));
+                if (inventoryRow == null)
+                {
+                    inventoryRow = inventoryItemTable.NewRow();
+                    fillItemRow(inventoryRow, item);
+                    inventoryItemTable.Rows.Add(inventoryRow);
+                }
+                else
+                {
+                    fillItemRow(inventoryRow, item);
+                }
+                invItemsDa.Update(ds, "inventoryitems");
+            }
+        }
+
+        public void Shutdown()
+        {
+            // TODO: DataSet commit
+        }
+
+        /// <summary>
+        /// Closes the interface
+        /// </summary>
+        public void Close()
+        {
+        }
+
+        /// <summary>
+        /// The plugin being loaded
+        /// </summary>
+        /// <returns>A string containing the plugin name</returns>
+        public string getName()
+        {
+            return "SQLite Inventory Data Interface";
+        }
+
+        /// <summary>
+        /// The plugins version
+        /// </summary>
+        /// <returns>A string containing the plugin version</returns>
+        public string getVersion()
+        {
+            Module module = GetType().Module;
+            string dllName = module.Assembly.ManifestModule.Name;
+            Version dllVersion = module.Assembly.GetName().Version;
+
+
+            return
+                string.Format("{0}.{1}.{2}.{3}", dllVersion.Major, dllVersion.Minor, dllVersion.Build,
+                              dllVersion.Revision);
+        }
+
+        /// <summary>
+        /// Returns a list of inventory items contained within the specified folder
+        /// </summary>
+        /// <param name="folderID">The UUID of the target folder</param>
+        /// <returns>A List of InventoryItemBase items</returns>
+        public List<InventoryItemBase> getInventoryInFolder(LLUUID folderID)
+        {
+            lock (ds)
+            {
+                List<InventoryItemBase> retval = new List<InventoryItemBase>();
+                DataTable inventoryItemTable = ds.Tables["inventoryitems"];
+                string selectExp = "parentFolderID = '" + Util.ToRawUuidString(folderID) + "'";
+                DataRow[] rows = inventoryItemTable.Select(selectExp);
+                foreach (DataRow row in rows)
+                {
+                    retval.Add(buildItem(row));
+                }
+
+                return retval;
+            }
+        }
+
+        /// <summary>
+        /// Returns a list of the root folders within a users inventory
+        /// </summary>
+        /// <param name="user">The user whos inventory is to be searched</param>
+        /// <returns>A list of folder objects</returns>
+        public List<InventoryFolderBase> getUserRootFolders(LLUUID user)
+        {
+            return new List<InventoryFolderBase>();
+        }
+
+        // see InventoryItemBase.getUserRootFolder
+        public InventoryFolderBase getUserRootFolder(LLUUID user)
+        {
+            lock (ds)
+            {
+                List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
+                DataTable inventoryFolderTable = ds.Tables["inventoryfolders"];
+                string selectExp = "agentID = '" + Util.ToRawUuidString(user) + "' AND parentID = '" +
+                                   Util.ToRawUuidString(LLUUID.Zero) + "'";
+                DataRow[] rows = inventoryFolderTable.Select(selectExp);
+                foreach (DataRow row in rows)
+                {
+                    folders.Add(buildFolder(row));
+                }
+
+                // There should only ever be one root folder for a user.  However, if there's more
+                // than one we'll simply use the first one rather than failing.  It would be even
+                // nicer to print some message to this effect, but this feels like it's too low a 
+                // to put such a message out, and it's too minor right now to spare the time to
+                // suitably refactor.            
+                if (folders.Count > 0)
+                {
+                    return folders[0];
+                }
+
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Append a list of all the child folders of a parent folder 
+        /// </summary>
+        /// <param name="folders">list where folders will be appended</param>
+        /// <param name="parentID">ID of parent</param>
+        protected void getInventoryFolders(ref List<InventoryFolderBase> folders, LLUUID parentID)
+        {
+            lock (ds)
+            {
+                DataTable inventoryFolderTable = ds.Tables["inventoryfolders"];
+                string selectExp = "parentID = '" + Util.ToRawUuidString(parentID) + "'";
+                DataRow[] rows = inventoryFolderTable.Select(selectExp);
+                foreach (DataRow row in rows)
+                {
+                    folders.Add(buildFolder(row));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a list of inventory folders contained in the folder 'parentID'
+        /// </summary>
+        /// <param name="parentID">The folder to get subfolders for</param>
+        /// <returns>A list of inventory folders</returns>
+        public List<InventoryFolderBase> getInventoryFolders(LLUUID parentID)
+        {
+            List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
+            getInventoryFolders(ref folders, Util.ToRawUuidString(parentID));
+            return folders;
+        }
+
+        // See IInventoryData
+        public List<InventoryFolderBase> getFolderHierarchy(LLUUID parentID)
+        {
+            List<InventoryFolderBase> folders = new List<InventoryFolderBase>();
+            getInventoryFolders(ref folders, Util.ToRawUuidString(parentID));
+
+            for (int i = 0; i < folders.Count; i++)
+                getInventoryFolders(ref folders, Util.ToRawUuidString(folders[i].folderID));
+
+            return folders;
+        }
+
+        /// <summary>
+        /// Returns an inventory item by its UUID
+        /// </summary>
+        /// <param name="item">The UUID of the item to be returned</param>
+        /// <returns>A class containing item information</returns>
+        public InventoryItemBase getInventoryItem(LLUUID item)
+        {
+            lock (ds)
+            {
+                DataRow row = ds.Tables["inventoryitems"].Rows.Find(Util.ToRawUuidString(item));
+                if (row != null)
+                {
+                    return buildItem(row);
+                }
+                else
+                {
+                    return null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a specified inventory folder by its UUID
+        /// </summary>
+        /// <param name="folder">The UUID of the folder to be returned</param>
+        /// <returns>A class containing folder information</returns>
+        public InventoryFolderBase getInventoryFolder(LLUUID folder)
+        {
+            // TODO: Deep voodoo here.  If you enable this code then
+            // multi region breaks.  No idea why, but I figured it was
+            // better to leave multi region at this point.  It does mean
+            // that you don't get to see system textures why creating
+            // clothes and the like. :(
+            lock (ds)
+            {
+                DataRow row = ds.Tables["inventoryfolders"].Rows.Find(Util.ToRawUuidString(folder));
+                if (row != null)
+                {
+                    return buildFolder(row);
+                }
+                else
+                {
+                    return null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates a new inventory item based on item
+        /// </summary>
+        /// <param name="item">The item to be created</param>
+        public void addInventoryItem(InventoryItemBase item)
+        {
+            addItem(item);
+        }
+
+        /// <summary>
+        /// Updates an inventory item with item (updates based on ID)
+        /// </summary>
+        /// <param name="item">The updated item</param>
+        public void updateInventoryItem(InventoryItemBase item)
+        {
+            addItem(item);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="item"></param>
+        public void deleteInventoryItem(LLUUID itemID)
+        {
+            lock (ds)
+            {
+                DataTable inventoryItemTable = ds.Tables["inventoryitems"];
+
+                DataRow inventoryRow = inventoryItemTable.Rows.Find(Util.ToRawUuidString(itemID));
+                if (inventoryRow != null)
+                {
+                    inventoryRow.Delete();
+                }
+
+                invItemsDa.Update(ds, "inventoryitems");
+            }
+        }
+
+        /// <summary>
+        /// Delete all items in the specified folder
+        /// </summary>
+        /// <param name="folderId">id of the folder, whose item content should be deleted</param>
+        //!TODO, this is horribly inefficient, but I don't want to ruin the overall structure of this implementation
+        private void deleteItemsInFolder(LLUUID folderId)
+        {
+            List<InventoryItemBase> items = getInventoryInFolder(Util.ToRawUuidString(folderId));
+
+            foreach (InventoryItemBase i in items)
+                deleteInventoryItem(Util.ToRawUuidString(i.inventoryID));
+        }
+
+        /// <summary>
+        /// Adds a new folder specified by folder
+        /// </summary>
+        /// <param name="folder">The inventory folder</param>
+        public void addInventoryFolder(InventoryFolderBase folder)
+        {
+            addFolder(folder);
+        }
+
+        /// <summary>
+        /// Updates a folder based on its ID with folder
+        /// </summary>
+        /// <param name="folder">The inventory folder</param>
+        public void updateInventoryFolder(InventoryFolderBase folder)
+        {
+            addFolder(folder);
+        }
+
+        /// <summary>
+        /// Moves a folder based on its ID with folder
+        /// </summary>
+        /// <param name="folder">The inventory folder</param>
+        public void moveInventoryFolder(InventoryFolderBase folder)
+        {
+            moveFolder(folder);
+        }
+
+        /// <summary>
+        /// Delete a folder
+        /// </summary>
+        /// <remarks>
+        /// This will clean-up any child folders and child items as well
+        /// </remarks>
+        /// <param name="item"></param>
+        public void deleteInventoryFolder(LLUUID folderID)
+        {
+            lock (ds)
+            {
+                List<InventoryFolderBase> subFolders = getFolderHierarchy(Util.ToRawUuidString(folderID));
+
+                DataTable inventoryFolderTable = ds.Tables["inventoryfolders"];
+                DataRow inventoryRow;
+
+                //Delete all sub-folders
+                foreach (InventoryFolderBase f in subFolders)
+                {
+                    inventoryRow = inventoryFolderTable.Rows.Find(Util.ToRawUuidString(f.folderID));
+                    if (inventoryRow != null)
+                    {
+                        deleteItemsInFolder(Util.ToRawUuidString(f.folderID));
+                        inventoryRow.Delete();
+                    }
+                }
+
+                //Delete the actual row
+                inventoryRow = inventoryFolderTable.Rows.Find(Util.ToRawUuidString(folderID));
+                if (inventoryRow != null)
+                {
+                    deleteItemsInFolder(Util.ToRawUuidString(folderID));
+                    inventoryRow.Delete();
+                }
+
+                invFoldersDa.Update(ds, "inventoryfolders");
+            }
+        }
+
+        /***********************************************************************
+         *
+         *  Data Table definitions
+         *
+         **********************************************************************/
+
+        private static DataTable createInventoryItemsTable()
+        {
+            DataTable inv = new DataTable("inventoryitems");
+
+            createCol(inv, "UUID", typeof (String)); //inventoryID
+            createCol(inv, "assetID", typeof (String));
+            createCol(inv, "assetType", typeof (Int32));
+            createCol(inv, "invType", typeof (Int32));
+            createCol(inv, "parentFolderID", typeof (String));
+            createCol(inv, "avatarID", typeof (String));
+            createCol(inv, "creatorsID", typeof (String));
+
+            createCol(inv, "inventoryName", typeof (String));
+            createCol(inv, "inventoryDescription", typeof (String));
+            // permissions
+            createCol(inv, "inventoryNextPermissions", typeof (Int32));
+            createCol(inv, "inventoryCurrentPermissions", typeof (Int32));
+            createCol(inv, "inventoryBasePermissions", typeof (Int32));
+            createCol(inv, "inventoryEveryOnePermissions", typeof (Int32));
+
+            inv.PrimaryKey = new DataColumn[] {inv.Columns["UUID"]};
+            return inv;
+        }
+
+        private DataTable createInventoryFoldersTable()
+        {
+            DataTable fol = new DataTable("inventoryfolders");
+
+            createCol(fol, "UUID", typeof (String)); //folderID
+            createCol(fol, "name", typeof (String));
+            createCol(fol, "agentID", typeof (String));
+            createCol(fol, "parentID", typeof (String));
+            createCol(fol, "type", typeof (Int32));
+            createCol(fol, "version", typeof (Int32));
+
+            fol.PrimaryKey = new DataColumn[] {fol.Columns["UUID"]};
+            return fol;
+        }
+
+        private void setupItemsCommands(SqliteDataAdapter da, SqliteConnection conn)
+        {
+            lock (ds)
+            {
+                da.InsertCommand = createInsertCommand("inventoryitems", ds.Tables["inventoryitems"]);
+                da.InsertCommand.Connection = conn;
+
+                da.UpdateCommand = createUpdateCommand("inventoryitems", "UUID=:UUID", ds.Tables["inventoryitems"]);
+                da.UpdateCommand.Connection = conn;
+
+                SqliteCommand delete = new SqliteCommand("delete from inventoryitems where UUID = :UUID");
+                delete.Parameters.Add(createSqliteParameter("UUID", typeof(String)));
+                delete.Connection = conn;
+                da.DeleteCommand = delete;
+            }
+        }
+
+        private void setupFoldersCommands(SqliteDataAdapter da, SqliteConnection conn)
+        {
+            lock (ds)
+            {
+                da.InsertCommand = createInsertCommand("inventoryfolders", ds.Tables["inventoryfolders"]);
+                da.InsertCommand.Connection = conn;
+
+                da.UpdateCommand = createUpdateCommand("inventoryfolders", "UUID=:UUID", ds.Tables["inventoryfolders"]);
+                da.UpdateCommand.Connection = conn;
+
+                SqliteCommand delete = new SqliteCommand("delete from inventoryfolders where UUID = :UUID");
+                delete.Parameters.Add(createSqliteParameter("UUID", typeof(String)));
+                delete.Connection = conn;
+                da.DeleteCommand = delete;
+            }
+        }
+
+        private InventoryFolderBase buildFolder(DataRow row)
+        {
+            InventoryFolderBase folder = new InventoryFolderBase();
+            folder.folderID = new LLUUID((string) row["UUID"]);
+            folder.name = (string) row["name"];
+            folder.agentID = new LLUUID((string) row["agentID"]);
+            folder.parentID = new LLUUID((string) row["parentID"]);
+            folder.type = Convert.ToInt16(row["type"]);
+            folder.version = Convert.ToUInt16(row["version"]);
+            return folder;
+        }
+
+        private void fillFolderRow(DataRow row, InventoryFolderBase folder)
+        {
+            row["UUID"] = Util.ToRawUuidString(folder.folderID);
+            row["name"] = folder.name;
+            row["agentID"] = Util.ToRawUuidString(folder.agentID);
+            row["parentID"] = Util.ToRawUuidString(folder.parentID);
+            row["type"] = folder.type;
+            row["version"] = folder.version;
+        }
+
+        private void moveFolderRow(DataRow row, InventoryFolderBase folder)
+        {
+            row["UUID"] = Util.ToRawUuidString(folder.folderID);
+            row["parentID"] = Util.ToRawUuidString(folder.parentID);
+        }
+
+        /***********************************************************************
+         *
+         *  Test and Initialization code
+         *
+         **********************************************************************/
+
+        private void InitDB(SqliteConnection conn)
+        {
+            string createInventoryItems = defineTable(createInventoryItemsTable());
+            string createInventoryFolders = defineTable(createInventoryFoldersTable());
+            
+            SqliteCommand pcmd = new SqliteCommand(createInventoryItems, conn);
+            SqliteCommand scmd = new SqliteCommand(createInventoryFolders, conn);
+
+            pcmd.ExecuteNonQuery();
+            scmd.ExecuteNonQuery();
+        }
+
+        private bool TestTables(SqliteConnection conn)
+        {
+            SqliteCommand invItemsSelectCmd = new SqliteCommand(invItemsSelect, conn);
+            SqliteDataAdapter pDa = new SqliteDataAdapter(invItemsSelectCmd);
+            SqliteCommand invFoldersSelectCmd = new SqliteCommand(invFoldersSelect, conn);
+            SqliteDataAdapter sDa = new SqliteDataAdapter(invFoldersSelectCmd);
+
+            DataSet tmpDS = new DataSet();
+            try
+            {
+                pDa.Fill(tmpDS, "inventoryitems");
+                sDa.Fill(tmpDS, "inventoryfolders");
+            }
+            catch (SqliteSyntaxException)
+            {
+                m_log.Info("[DATASTORE]: SQLite Database doesn't exist... creating");
+                InitDB(conn);
+            }
+
+            pDa.Fill(tmpDS, "inventoryitems");
+            sDa.Fill(tmpDS, "inventoryfolders");
+
+            foreach (DataColumn col in createInventoryItemsTable().Columns)
+            {
+                if (! tmpDS.Tables["inventoryitems"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing required column:" + col.ColumnName);
+                    return false;
+                }
+            }
+            foreach (DataColumn col in createInventoryFoldersTable().Columns)
+            {
+                if (! tmpDS.Tables["inventoryfolders"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing required column:" + col.ColumnName);
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}
diff --git a/OpenSim/Data/SQLite/SQLiteManager.cs b/OpenSim/Data/SQLite/SQLiteManager.cs
new file mode 100644
index 0000000..b383b0d
--- /dev/null
+++ b/OpenSim/Data/SQLite/SQLiteManager.cs
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.SQLite;
+using libsecondlife;
+using Mono.Data.SqliteClient;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.SQLite
+{
+    internal class SQLiteManager : SQLiteUtil
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        private IDbConnection dbcon;
+
+        /// <summary>
+        /// Initialises and creates a new SQLite connection and maintains it.
+        /// </summary>
+        /// <param name="hostname">The SQLite server being connected to</param>
+        /// <param name="database">The name of the SQLite database being used</param>
+        /// <param name="username">The username logging into the database</param>
+        /// <param name="password">The password for the user logging in</param>
+        /// <param name="cpooling">Whether to use connection pooling or not, can be one of the following: 'yes', 'true', 'no' or 'false', if unsure use 'false'.</param>
+        public SQLiteManager(string hostname, string database, string username, string password, string cpooling)
+        {
+            try
+            {
+                string connectionString = "URI=file:GridServerSqlite.db;";
+                dbcon = new SQLiteConnection(connectionString);
+
+                dbcon.Open();
+            }
+            catch (Exception e)
+            {
+                throw new Exception("Error initialising SQLite Database: " + e.ToString());
+            }
+        }
+
+        /// <summary>
+        /// Shuts down the database connection
+        /// </summary>
+        public void Close()
+        {
+            dbcon.Close();
+            dbcon = null;
+        }
+
+        /// <summary>
+        /// Runs a query with protection against SQL Injection by using parameterised input.
+        /// </summary>
+        /// <param name="sql">The SQL string - replace any variables such as WHERE x = "y" with WHERE x = @y</param>
+        /// <param name="parameters">The parameters - index so that @y is indexed as 'y'</param>
+        /// <returns>A SQLite DB Command</returns>
+        public IDbCommand Query(string sql, Dictionary<string, string> parameters)
+        {
+            SQLiteCommand dbcommand = (SQLiteCommand) dbcon.CreateCommand();
+            dbcommand.CommandText = sql;
+            foreach (KeyValuePair<string, string> param in parameters)
+            {
+                SQLiteParameter paramx = new SQLiteParameter(param.Key, param.Value);
+                dbcommand.Parameters.Add(paramx);
+            }
+
+            return (IDbCommand) dbcommand;
+        }
+
+// TODO: unused
+//         private bool TestTables(SQLiteConnection conn)
+//         {
+//             SQLiteCommand cmd = new SQLiteCommand("SELECT * FROM regions", conn);
+//             SQLiteDataAdapter pDa = new SQLiteDataAdapter(cmd);
+//             DataSet tmpDS = new DataSet();
+//             try
+//             {
+//                 pDa.Fill(tmpDS, "regions");
+//             }
+//             catch (SqliteSyntaxException)
+//             {
+//                 m_log.Info("[DATASTORE]: SQLite Database doesn't exist... creating");
+//                 InitDB(conn);
+//             }
+//             return true;
+//         }
+
+// TODO: unused
+//         private DataTable createRegionsTable()
+//         {
+//             DataTable regions = new DataTable("regions");
+
+//             createCol(regions, "regionHandle", typeof (ulong));
+//             createCol(regions, "regionName", typeof (String));
+//             createCol(regions, "uuid", typeof (String));
+
+//             createCol(regions, "regionRecvKey", typeof (String));
+//             createCol(regions, "regionSecret", typeof (String));
+//             createCol(regions, "regionSendKey", typeof (String));
+
+//             createCol(regions, "regionDataURI", typeof (String));
+//             createCol(regions, "serverIP", typeof (String));
+//             createCol(regions, "serverPort", typeof (String));
+//             createCol(regions, "serverURI", typeof (String));
+
+
+//             createCol(regions, "locX", typeof (uint));
+//             createCol(regions, "locY", typeof (uint));
+//             createCol(regions, "locZ", typeof (uint));
+
+//             createCol(regions, "eastOverrideHandle", typeof (ulong));
+//             createCol(regions, "westOverrideHandle", typeof (ulong));
+//             createCol(regions, "southOverrideHandle", typeof (ulong));
+//             createCol(regions, "northOverrideHandle", typeof (ulong));
+
+//             createCol(regions, "regionAssetURI", typeof (String));
+//             createCol(regions, "regionAssetRecvKey", typeof (String));
+//             createCol(regions, "regionAssetSendKey", typeof (String));
+
+//             createCol(regions, "regionUserURI", typeof (String));
+//             createCol(regions, "regionUserRecvKey", typeof (String));
+//             createCol(regions, "regionUserSendKey", typeof (String));
+
+//             // Add in contraints
+//             regions.PrimaryKey = new DataColumn[] {regions.Columns["UUID"]};
+//             return regions;
+//         }
+
+// TODO: unused
+//         private void InitDB(SQLiteConnection conn)
+//         {
+//             string createUsers = defineTable(createRegionsTable());
+//             SQLiteCommand pcmd = new SQLiteCommand(createUsers, conn);
+//             conn.Open();
+//             pcmd.ExecuteNonQuery();
+//             conn.Close();
+//         }
+
+        /// <summary>
+        /// Reads a region row from a database reader
+        /// </summary>
+        /// <param name="reader">An active database reader</param>
+        /// <returns>A region profile</returns>
+        public RegionProfileData getRow(IDataReader reader)
+        {
+            RegionProfileData retval = new RegionProfileData();
+
+            if (reader.Read())
+            {
+                // Region Main
+                retval.regionHandle = (ulong) reader["regionHandle"];
+                retval.regionName = (string) reader["regionName"];
+                retval.UUID = new LLUUID((string) reader["uuid"]);
+
+                // Secrets
+                retval.regionRecvKey = (string) reader["regionRecvKey"];
+                retval.regionSecret = (string) reader["regionSecret"];
+                retval.regionSendKey = (string) reader["regionSendKey"];
+
+                // Region Server
+                retval.regionDataURI = (string) reader["regionDataURI"];
+                retval.regionOnline = false; // Needs to be pinged before this can be set.
+                retval.serverIP = (string) reader["serverIP"];
+                retval.serverPort = (uint) reader["serverPort"];
+                retval.serverURI = (string) reader["serverURI"];
+
+                // Location
+                retval.regionLocX = (uint) ((int) reader["locX"]);
+                retval.regionLocY = (uint) ((int) reader["locY"]);
+                retval.regionLocZ = (uint) ((int) reader["locZ"]);
+
+                // Neighbours - 0 = No Override
+                retval.regionEastOverrideHandle = (ulong) reader["eastOverrideHandle"];
+                retval.regionWestOverrideHandle = (ulong) reader["westOverrideHandle"];
+                retval.regionSouthOverrideHandle = (ulong) reader["southOverrideHandle"];
+                retval.regionNorthOverrideHandle = (ulong) reader["northOverrideHandle"];
+
+                // Assets
+                retval.regionAssetURI = (string) reader["regionAssetURI"];
+                retval.regionAssetRecvKey = (string) reader["regionAssetRecvKey"];
+                retval.regionAssetSendKey = (string) reader["regionAssetSendKey"];
+
+                // Userserver
+                retval.regionUserURI = (string) reader["regionUserURI"];
+                retval.regionUserRecvKey = (string) reader["regionUserRecvKey"];
+                retval.regionUserSendKey = (string) reader["regionUserSendKey"];
+            }
+            else
+            {
+                throw new Exception("No rows to return");
+            }
+            return retval;
+        }
+
+        /// <summary>
+        /// Inserts a new region into the database
+        /// </summary>
+        /// <param name="profile">The region to insert</param>
+        /// <returns>Success?</returns>
+        public bool insertRow(RegionProfileData profile)
+        {
+            string sql =
+                "REPLACE INTO regions VALUES (regionHandle, regionName, uuid, regionRecvKey, regionSecret, regionSendKey, regionDataURI, ";
+            sql +=
+                "serverIP, serverPort, serverURI, locX, locY, locZ, eastOverrideHandle, westOverrideHandle, southOverrideHandle, northOverrideHandle, regionAssetURI, regionAssetRecvKey, ";
+            sql += "regionAssetSendKey, regionUserURI, regionUserRecvKey, regionUserSendKey) VALUES ";
+
+            sql += "(@regionHandle, @regionName, @uuid, @regionRecvKey, @regionSecret, @regionSendKey, @regionDataURI, ";
+            sql +=
+                "@serverIP, @serverPort, @serverURI, @locX, @locY, @locZ, @eastOverrideHandle, @westOverrideHandle, @southOverrideHandle, @northOverrideHandle, @regionAssetURI, @regionAssetRecvKey, ";
+            sql += "@regionAssetSendKey, @regionUserURI, @regionUserRecvKey, @regionUserSendKey);";
+
+            Dictionary<string, string> parameters = new Dictionary<string, string>();
+
+            parameters["regionHandle"] = profile.regionHandle.ToString();
+            parameters["regionName"] = profile.regionName;
+            parameters["uuid"] = profile.UUID.ToString();
+            parameters["regionRecvKey"] = profile.regionRecvKey;
+            parameters["regionSendKey"] = profile.regionSendKey;
+            parameters["regionDataURI"] = profile.regionDataURI;
+            parameters["serverIP"] = profile.serverIP;
+            parameters["serverPort"] = profile.serverPort.ToString();
+            parameters["serverURI"] = profile.serverURI;
+            parameters["locX"] = profile.regionLocX.ToString();
+            parameters["locY"] = profile.regionLocY.ToString();
+            parameters["locZ"] = profile.regionLocZ.ToString();
+            parameters["eastOverrideHandle"] = profile.regionEastOverrideHandle.ToString();
+            parameters["westOverrideHandle"] = profile.regionWestOverrideHandle.ToString();
+            parameters["northOverrideHandle"] = profile.regionNorthOverrideHandle.ToString();
+            parameters["southOverrideHandle"] = profile.regionSouthOverrideHandle.ToString();
+            parameters["regionAssetURI"] = profile.regionAssetURI;
+            parameters["regionAssetRecvKey"] = profile.regionAssetRecvKey;
+            parameters["regionAssetSendKey"] = profile.regionAssetSendKey;
+            parameters["regionUserURI"] = profile.regionUserURI;
+            parameters["regionUserRecvKey"] = profile.regionUserRecvKey;
+            parameters["regionUserSendKey"] = profile.regionUserSendKey;
+
+            bool returnval = false;
+
+            try
+            {
+                IDbCommand result = Query(sql, parameters);
+
+                if (result.ExecuteNonQuery() == 1)
+                    returnval = true;
+
+                result.Dispose();
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+
+            return returnval;
+        }
+    }
+}
diff --git a/OpenSim/Data/SQLite/SQLiteRegionData.cs b/OpenSim/Data/SQLite/SQLiteRegionData.cs
new file mode 100644
index 0000000..77161a4
--- /dev/null
+++ b/OpenSim/Data/SQLite/SQLiteRegionData.cs
@@ -0,0 +1,1741 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.IO;
+using libsecondlife;
+using Mono.Data.SqliteClient;
+using OpenSim.Framework;
+using OpenSim.Framework.Console;
+using OpenSim.Region.Environment.Interfaces;
+using OpenSim.Region.Environment.Scenes;
+
+namespace OpenSim.Framework.Data.SQLite
+{
+    public class SQLiteRegionData : IRegionDataStore
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        private const string primSelect = "select * from prims";
+        private const string shapeSelect = "select * from primshapes";
+        private const string itemsSelect = "select * from primitems";
+        private const string terrainSelect = "select * from terrain limit 1";
+        private const string landSelect = "select * from land";
+        private const string landAccessListSelect = "select distinct * from landaccesslist";
+
+        private DataSet ds;
+        private SqliteDataAdapter primDa;
+        private SqliteDataAdapter shapeDa;
+        private SqliteDataAdapter itemsDa;
+        private SqliteDataAdapter terrainDa;
+        private SqliteDataAdapter landDa;
+        private SqliteDataAdapter landAccessListDa;
+
+        private SqliteConnection m_conn;
+
+        private String m_connectionString;
+
+        // Temporary attribute while this is experimental
+        private bool persistPrimInventories;
+
+        /***********************************************************************
+         *
+         *  Public Interface Functions
+         *
+         **********************************************************************/
+
+        // see IRegionDataStore
+        public void Initialise(string connectionString, bool persistPrimInventories)
+        {
+            m_connectionString = connectionString;
+            this.persistPrimInventories = persistPrimInventories;
+
+            ds = new DataSet();
+
+            m_log.Info("[DATASTORE]: Sqlite - connecting: " + connectionString);
+            m_conn = new SqliteConnection(m_connectionString);
+            m_conn.Open();
+
+            SqliteCommand primSelectCmd = new SqliteCommand(primSelect, m_conn);
+            primDa = new SqliteDataAdapter(primSelectCmd);
+            //            SqliteCommandBuilder primCb = new SqliteCommandBuilder(primDa);
+
+            SqliteCommand shapeSelectCmd = new SqliteCommand(shapeSelect, m_conn);
+            shapeDa = new SqliteDataAdapter(shapeSelectCmd);
+            // SqliteCommandBuilder shapeCb = new SqliteCommandBuilder(shapeDa);      
+
+            SqliteCommand itemsSelectCmd = new SqliteCommand(itemsSelect, m_conn);
+            itemsDa = new SqliteDataAdapter(itemsSelectCmd);
+            
+            SqliteCommand terrainSelectCmd = new SqliteCommand(terrainSelect, m_conn);
+            terrainDa = new SqliteDataAdapter(terrainSelectCmd);
+
+            SqliteCommand landSelectCmd = new SqliteCommand(landSelect, m_conn);
+            landDa = new SqliteDataAdapter(landSelectCmd);
+
+            SqliteCommand landAccessListSelectCmd = new SqliteCommand(landAccessListSelect, m_conn);
+            landAccessListDa = new SqliteDataAdapter(landAccessListSelectCmd);
+
+            // We fill the data set, now we've got copies in memory for the information
+            // TODO: see if the linkage actually holds.
+            // primDa.FillSchema(ds, SchemaType.Source, "PrimSchema");
+            TestTables(m_conn);
+
+            lock (ds)
+            {
+                ds.Tables.Add(createPrimTable());
+                setupPrimCommands(primDa, m_conn);
+                primDa.Fill(ds.Tables["prims"]);
+
+                ds.Tables.Add(createShapeTable());
+                setupShapeCommands(shapeDa, m_conn);
+                
+                if (persistPrimInventories)
+                {
+                    ds.Tables.Add(createItemsTable());
+                    setupItemsCommands(itemsDa, m_conn);
+                    itemsDa.Fill(ds.Tables["primitems"]);
+                }
+
+                ds.Tables.Add(createTerrainTable());
+                setupTerrainCommands(terrainDa, m_conn);
+
+                ds.Tables.Add(createLandTable());
+                setupLandCommands(landDa, m_conn);
+
+                ds.Tables.Add(createLandAccessListTable());
+                setupLandAccessCommands(landAccessListDa, m_conn);
+
+                // WORKAROUND: This is a work around for sqlite on
+                // windows, which gets really unhappy with blob columns
+                // that have no sample data in them.  At some point we
+                // need to actually find a proper way to handle this.
+                try
+                {
+                    shapeDa.Fill(ds.Tables["primshapes"]);
+                }
+                catch (Exception)
+                {
+                    m_log.Info("[DATASTORE]: Caught fill error on primshapes table");
+                }
+
+                try
+                {
+                    terrainDa.Fill(ds.Tables["terrain"]);
+                }
+                catch (Exception)
+                {
+                    m_log.Info("[DATASTORE]: Caught fill error on terrain table");
+                }
+
+                try
+                {
+                    landDa.Fill(ds.Tables["land"]);
+                }
+                catch (Exception)
+                {
+                    m_log.Info("[DATASTORE]: Caught fill error on land table");
+                }
+
+                try
+                {
+                    landAccessListDa.Fill(ds.Tables["landaccesslist"]);
+                }
+                catch (Exception)
+                {
+                    m_log.Info("[DATASTORE]: Caught fill error on landaccesslist table");
+                }
+                return;
+            }
+        }
+
+        public void StoreObject(SceneObjectGroup obj, LLUUID regionUUID)
+        {
+            lock (ds)
+            {
+                foreach (SceneObjectPart prim in obj.Children.Values)
+                {
+                    if ((prim.ObjectFlags & (uint) LLObject.ObjectFlags.Physics) == 0)
+                    {
+                        m_log.Info("[DATASTORE]: Adding obj: " + obj.UUID + " to region: " + regionUUID);
+                        addPrim(prim, Util.ToRawUuidString(obj.UUID), Util.ToRawUuidString(regionUUID));
+                    }
+                    else if (prim.Stopped)
+                    {
+                        //m_log.Info("[DATASTORE]: " +
+                                                 //"Adding stopped obj: " + obj.UUID + " to region: " + regionUUID);
+                        //addPrim(prim, Util.ToRawUuidString(obj.UUID), Util.ToRawUuidString(regionUUID));
+                    }
+                    else
+                    {
+                        // m_log.Info("[DATASTORE]: Ignoring Physical obj: " + obj.UUID + " in region: " + regionUUID);
+                    }
+                }
+            }
+
+            Commit();
+            // m_log.Info("[Dump of prims]: " + ds.GetXml());
+        }
+
+        public void RemoveObject(LLUUID obj, LLUUID regionUUID)
+        {
+            m_log.InfoFormat("[DATASTORE]: Removing obj: {0} from region: {1}", obj.UUID, regionUUID);
+            
+            DataTable prims = ds.Tables["prims"];
+            DataTable shapes = ds.Tables["primshapes"];
+
+            string selectExp = "SceneGroupID = '" + Util.ToRawUuidString(obj) + "'";
+            lock (ds)
+            {
+                DataRow[] primRows = prims.Select(selectExp);
+                foreach (DataRow row in primRows)
+                {
+                    // Remove shape rows
+                    LLUUID uuid = new LLUUID((string) row["UUID"]);
+                    DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(uuid));
+                    if (shapeRow != null)
+                    {
+                        shapeRow.Delete();
+                    }
+
+                    if (persistPrimInventories)
+                    {
+                        RemoveItems(uuid);
+                    }
+
+                    // Remove prim row
+                    row.Delete();                    
+                }
+            }
+
+            Commit();
+        }
+
+        /// <summary>
+        /// Remove all persisted items of the given prim.
+        /// The caller must acquire the necessrary synchronization locks and commit or rollback changes.
+        /// </summary>
+        private void RemoveItems(LLUUID uuid)
+        {
+            DataTable items = ds.Tables["primitems"];            
+
+            String sql = String.Format("primID = '{0}'", uuid);            
+            DataRow[] itemRows = items.Select(sql);
+    
+            foreach (DataRow itemRow in itemRows)
+            {
+                itemRow.Delete();
+            }
+        }
+
+        /// <summary>
+        /// Load persisted objects from region storage.
+        /// </summary>
+        /// <param name="regionUUID"></param>
+        /// <returns>List of loaded groups</returns>
+        public List<SceneObjectGroup> LoadObjects(LLUUID regionUUID)
+        {
+            Dictionary<LLUUID, SceneObjectGroup> createdObjects = new Dictionary<LLUUID, SceneObjectGroup>();
+
+            List<SceneObjectGroup> retvals = new List<SceneObjectGroup>();
+
+            DataTable prims = ds.Tables["prims"];
+            DataTable shapes = ds.Tables["primshapes"];
+
+            string byRegion = "RegionUUID = '" + Util.ToRawUuidString(regionUUID) + "'";
+            string orderByParent = "ParentID ASC";
+
+            lock (ds)
+            {
+                DataRow[] primsForRegion = prims.Select(byRegion, orderByParent);
+                m_log.Info("[DATASTORE]: " +
+                                         "Loaded " + primsForRegion.Length + " prims for region: " + regionUUID);
+
+                foreach (DataRow primRow in primsForRegion)
+                {
+                    try
+                    {
+                        SceneObjectPart prim = null;
+                            
+                        string uuid = (string) primRow["UUID"];
+                        string objID = (string) primRow["SceneGroupID"];
+                        if (uuid == objID) //is new SceneObjectGroup ?
+                        {
+                            SceneObjectGroup group = new SceneObjectGroup();
+                            prim = buildPrim(primRow);
+                            DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(prim.UUID));
+                            if (shapeRow != null)
+                            {
+                                prim.Shape = buildShape(shapeRow);
+                            }
+                            else
+                            {
+                                m_log.Info(
+                                    "No shape found for prim in storage, so setting default box shape");
+                                prim.Shape = PrimitiveBaseShape.Default;
+                            }
+                            group.AddPart(prim);
+                            group.RootPart = prim;
+
+                            createdObjects.Add(Util.ToRawUuidString(group.UUID), group);
+                            retvals.Add(group);
+                        }
+                        else
+                        {
+                            prim = buildPrim(primRow);
+                            DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(prim.UUID));
+                            if (shapeRow != null)
+                            {
+                                prim.Shape = buildShape(shapeRow);
+                            }
+                            else
+                            {
+                                m_log.Info(
+                                    "No shape found for prim in storage, so setting default box shape");
+                                prim.Shape = PrimitiveBaseShape.Default;
+                            }
+                            createdObjects[new LLUUID(objID)].AddPart(prim);
+                        }
+
+                        if (persistPrimInventories)
+                        {
+                            LoadItems(prim);
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.Error("[DATASTORE]: Failed create prim object, exception and data follows");
+                        m_log.Info("[DATASTORE]: " + e.ToString());
+                        foreach (DataColumn col in prims.Columns)
+                        {
+                            m_log.Info("[DATASTORE]: Col: " + col.ColumnName + " => " + primRow[col]);
+                        }
+                    }
+                }
+            }
+            return retvals;
+        }
+
+        /// <summary>
+        /// Load in a prim's persisted inventory.
+        /// </summary>
+        /// <param name="prim"></param>
+        private void LoadItems(SceneObjectPart prim)
+        {
+            //m_log.DebugFormat("[DATASTORE]: Loading inventory for {0}, {1}", prim.Name, prim.UUID);
+            
+            DataTable dbItems = ds.Tables["primitems"];
+            
+            String sql = String.Format("primID = '{0}'", prim.UUID.ToString());            
+            DataRow[] dbItemRows = dbItems.Select(sql);
+            
+            IList<TaskInventoryItem> inventory = new List<TaskInventoryItem>();
+            
+            foreach (DataRow row in dbItemRows)
+            {
+                TaskInventoryItem item = buildItem(row);
+                inventory.Add(item);
+                
+                //m_log.DebugFormat("[DATASTORE]: Restored item {0}, {1}", item.Name, item.ItemID); 
+            }
+            
+            prim.RestoreInventoryItems(inventory);
+            
+            // XXX A nasty little hack to recover the folder id for the prim (which is currently stored in 
+            // every item).  This data should really be stored in the prim table itself.
+            if (dbItemRows.Length > 0)
+            {
+                prim.FolderID = inventory[0].ParentID;
+            }
+        }
+
+        public void StoreTerrain(double[,] ter, LLUUID regionID)
+        {
+            lock (ds)
+            {
+                int revision = Util.UnixTimeSinceEpoch();
+
+                // the following is an work around for .NET.  The perf
+                // issues associated with it aren't as bad as you think.
+                m_log.Info("[DATASTORE]: Storing terrain revision r" + revision.ToString());
+                String sql = "insert into terrain(RegionUUID, Revision, Heightfield)" +
+                             " values(:RegionUUID, :Revision, :Heightfield)";
+
+                using (SqliteCommand cmd = new SqliteCommand(sql, m_conn))
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":RegionUUID", Util.ToRawUuidString(regionID)));
+                    cmd.Parameters.Add(new SqliteParameter(":Revision", revision));
+                    cmd.Parameters.Add(new SqliteParameter(":Heightfield", serializeTerrain(ter)));
+                    cmd.ExecuteNonQuery();
+                }
+
+                // This is added to get rid of the infinitely growing
+                // terrain databases which negatively impact on SQLite
+                // over time.  Before reenabling this feature there
+                // needs to be a limitter put on the number of
+                // revisions in the database, as this old
+                // implementation is a DOS attack waiting to happen.
+
+                using (
+                    SqliteCommand cmd =
+                        new SqliteCommand("delete from terrain where RegionUUID=:RegionUUID and Revision < :Revision",
+                                          m_conn))
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":RegionUUID", Util.ToRawUuidString(regionID)));
+                    cmd.Parameters.Add(new SqliteParameter(":Revision", revision));
+                    cmd.ExecuteNonQuery();
+                }
+            }
+        }
+
+        public double[,] LoadTerrain(LLUUID regionID)
+        {
+            lock (ds)
+            {
+                double[,] terret = new double[256,256];
+                terret.Initialize();
+
+                String sql = "select RegionUUID, Revision, Heightfield from terrain" +
+                             " where RegionUUID=:RegionUUID order by Revision desc";
+
+                using (SqliteCommand cmd = new SqliteCommand(sql, m_conn))
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":RegionUUID", Util.ToRawUuidString(regionID)));
+
+                    using (IDataReader row = cmd.ExecuteReader())
+                    {
+                        int rev = 0;
+                        if (row.Read())
+                        {
+                            // TODO: put this into a function
+                            MemoryStream str = new MemoryStream((byte[]) row["Heightfield"]);
+                            BinaryReader br = new BinaryReader(str);
+                            for (int x = 0; x < 256; x++)
+                            {
+                                for (int y = 0; y < 256; y++)
+                                {
+                                    terret[x, y] = br.ReadDouble();
+                                }
+                            }
+                            rev = (int) row["Revision"];
+                        }
+                        else
+                        {
+                            m_log.Info("[DATASTORE]: No terrain found for region");
+                            return null;
+                        }
+
+                        m_log.Info("[DATASTORE]: Loaded terrain revision r" + rev.ToString());
+                    }
+                }
+                return terret;
+            }
+        }
+
+        public void RemoveLandObject(LLUUID globalID)
+        {
+            lock (ds)
+            {
+                using (SqliteCommand cmd = new SqliteCommand("delete from land where UUID=:UUID", m_conn))
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":UUID", Util.ToRawUuidString(globalID)));
+                    cmd.ExecuteNonQuery();
+                }
+
+                using (SqliteCommand cmd = new SqliteCommand("delete from landaccesslist where LandUUID=:UUID", m_conn))
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":UUID", Util.ToRawUuidString(globalID)));
+                    cmd.ExecuteNonQuery();
+                }
+            }
+        }
+
+        public void StoreLandObject(ILandObject parcel)
+        {
+            lock (ds)
+            {
+                DataTable land = ds.Tables["land"];
+                DataTable landaccesslist = ds.Tables["landaccesslist"];
+
+                DataRow landRow = land.Rows.Find(Util.ToRawUuidString(parcel.landData.globalID));
+                if (landRow == null)
+                {
+                    landRow = land.NewRow();
+                    fillLandRow(landRow, parcel.landData, parcel.regionUUID);
+                    land.Rows.Add(landRow);
+                }
+                else
+                {
+                    fillLandRow(landRow, parcel.landData, parcel.regionUUID);
+                }
+
+                // I know this caused someone issues before, but OpenSim is unusable if we leave this stuff around
+                using (SqliteCommand cmd = new SqliteCommand("delete from landaccesslist where LandUUID=:LandUUID", m_conn))
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":LandUUID", Util.ToRawUuidString(parcel.landData.globalID)));
+                    cmd.ExecuteNonQuery();
+                }
+
+                foreach (ParcelManager.ParcelAccessEntry entry in parcel.landData.parcelAccessList)
+                {
+                    DataRow newAccessRow = landaccesslist.NewRow();
+                    fillLandAccessRow(newAccessRow, entry, parcel.landData.globalID);
+                    landaccesslist.Rows.Add(newAccessRow);
+                }
+            }
+
+            Commit();
+        }
+
+        public List<LandData> LoadLandObjects(LLUUID regionUUID)
+        {
+            List<LandData> landDataForRegion = new List<LandData>();
+            lock (ds)
+            {
+                DataTable land = ds.Tables["land"];
+                DataTable landaccesslist = ds.Tables["landaccesslist"];
+                string searchExp = "RegionUUID = '" + Util.ToRawUuidString(regionUUID) + "'";
+                DataRow[] rawDataForRegion = land.Select(searchExp);
+                foreach (DataRow rawDataLand in rawDataForRegion)
+                {
+                    LandData newLand = buildLandData(rawDataLand);
+                    string accessListSearchExp = "LandUUID = '" + Util.ToRawUuidString(newLand.globalID) + "'";
+                    DataRow[] rawDataForLandAccessList = landaccesslist.Select(accessListSearchExp);
+                    foreach (DataRow rawDataLandAccess in rawDataForLandAccessList)
+                    {
+                        newLand.parcelAccessList.Add(buildLandAccessData(rawDataLandAccess));
+                    }
+
+                    landDataForRegion.Add(newLand);
+                }
+            }
+            return landDataForRegion;
+        }
+
+        public void Commit()
+        {
+            lock (ds)
+            {
+                primDa.Update(ds, "prims");
+                shapeDa.Update(ds, "primshapes");
+                
+                if (persistPrimInventories)
+                {
+                    itemsDa.Update(ds, "primitems");
+                }
+                
+                terrainDa.Update(ds, "terrain");
+                landDa.Update(ds, "land");
+                landAccessListDa.Update(ds, "landaccesslist");
+                ds.AcceptChanges();
+            }
+        }
+
+        public void Shutdown()
+        {
+            Commit();
+        }
+
+        /***********************************************************************
+         *
+         *  Database Definition Functions
+         * 
+         *  This should be db agnostic as we define them in ADO.NET terms
+         *
+         **********************************************************************/
+
+        private void createCol(DataTable dt, string name, Type type)
+        {
+            DataColumn col = new DataColumn(name, type);
+            dt.Columns.Add(col);
+        }
+
+        private DataTable createTerrainTable()
+        {
+            DataTable terrain = new DataTable("terrain");
+
+            createCol(terrain, "RegionUUID", typeof (String));
+            createCol(terrain, "Revision", typeof (Int32));
+            createCol(terrain, "Heightfield", typeof (Byte[]));
+
+            return terrain;
+        }
+
+        private DataTable createPrimTable()
+        {
+            DataTable prims = new DataTable("prims");
+
+            createCol(prims, "UUID", typeof (String));
+            createCol(prims, "RegionUUID", typeof (String));
+            createCol(prims, "ParentID", typeof (Int32));
+            createCol(prims, "CreationDate", typeof (Int32));
+            createCol(prims, "Name", typeof (String));
+            createCol(prims, "SceneGroupID", typeof (String));
+            // various text fields
+            createCol(prims, "Text", typeof (String));
+            createCol(prims, "Description", typeof (String));
+            createCol(prims, "SitName", typeof (String));
+            createCol(prims, "TouchName", typeof (String));
+            // permissions
+            createCol(prims, "ObjectFlags", typeof (Int32));
+            createCol(prims, "CreatorID", typeof (String));
+            createCol(prims, "OwnerID", typeof (String));
+            createCol(prims, "GroupID", typeof (String));
+            createCol(prims, "LastOwnerID", typeof (String));
+            createCol(prims, "OwnerMask", typeof (Int32));
+            createCol(prims, "NextOwnerMask", typeof (Int32));
+            createCol(prims, "GroupMask", typeof (Int32));
+            createCol(prims, "EveryoneMask", typeof (Int32));
+            createCol(prims, "BaseMask", typeof (Int32));
+            // vectors
+            createCol(prims, "PositionX", typeof (Double));
+            createCol(prims, "PositionY", typeof (Double));
+            createCol(prims, "PositionZ", typeof (Double));
+            createCol(prims, "GroupPositionX", typeof (Double));
+            createCol(prims, "GroupPositionY", typeof (Double));
+            createCol(prims, "GroupPositionZ", typeof (Double));
+            createCol(prims, "VelocityX", typeof (Double));
+            createCol(prims, "VelocityY", typeof (Double));
+            createCol(prims, "VelocityZ", typeof (Double));
+            createCol(prims, "AngularVelocityX", typeof (Double));
+            createCol(prims, "AngularVelocityY", typeof (Double));
+            createCol(prims, "AngularVelocityZ", typeof (Double));
+            createCol(prims, "AccelerationX", typeof (Double));
+            createCol(prims, "AccelerationY", typeof (Double));
+            createCol(prims, "AccelerationZ", typeof (Double));
+            // quaternions
+            createCol(prims, "RotationX", typeof (Double));
+            createCol(prims, "RotationY", typeof (Double));
+            createCol(prims, "RotationZ", typeof (Double));
+            createCol(prims, "RotationW", typeof (Double));
+
+            // sit target
+            createCol(prims, "SitTargetOffsetX", typeof (Double));
+            createCol(prims, "SitTargetOffsetY", typeof (Double));
+            createCol(prims, "SitTargetOffsetZ", typeof (Double));
+
+            createCol(prims, "SitTargetOrientW", typeof (Double));
+            createCol(prims, "SitTargetOrientX", typeof (Double));
+            createCol(prims, "SitTargetOrientY", typeof (Double));
+            createCol(prims, "SitTargetOrientZ", typeof (Double));
+
+            // Add in contraints
+            prims.PrimaryKey = new DataColumn[] {prims.Columns["UUID"]};
+
+            return prims;
+        }
+
+        private DataTable createShapeTable()
+        {
+            DataTable shapes = new DataTable("primshapes");
+            createCol(shapes, "UUID", typeof (String));
+            // shape is an enum
+            createCol(shapes, "Shape", typeof (Int32));
+            // vectors
+            createCol(shapes, "ScaleX", typeof (Double));
+            createCol(shapes, "ScaleY", typeof (Double));
+            createCol(shapes, "ScaleZ", typeof (Double));
+            // paths
+            createCol(shapes, "PCode", typeof (Int32));
+            createCol(shapes, "PathBegin", typeof (Int32));
+            createCol(shapes, "PathEnd", typeof (Int32));
+            createCol(shapes, "PathScaleX", typeof (Int32));
+            createCol(shapes, "PathScaleY", typeof (Int32));
+            createCol(shapes, "PathShearX", typeof (Int32));
+            createCol(shapes, "PathShearY", typeof (Int32));
+            createCol(shapes, "PathSkew", typeof (Int32));
+            createCol(shapes, "PathCurve", typeof (Int32));
+            createCol(shapes, "PathRadiusOffset", typeof (Int32));
+            createCol(shapes, "PathRevolutions", typeof (Int32));
+            createCol(shapes, "PathTaperX", typeof (Int32));
+            createCol(shapes, "PathTaperY", typeof (Int32));
+            createCol(shapes, "PathTwist", typeof (Int32));
+            createCol(shapes, "PathTwistBegin", typeof (Int32));
+            // profile
+            createCol(shapes, "ProfileBegin", typeof (Int32));
+            createCol(shapes, "ProfileEnd", typeof (Int32));
+            createCol(shapes, "ProfileCurve", typeof (Int32));
+            createCol(shapes, "ProfileHollow", typeof (Int32));
+            createCol(shapes, "State", typeof(Int32));
+            // text TODO: this isn't right, but I'm not sure the right
+            // way to specify this as a blob atm
+            createCol(shapes, "Texture", typeof (Byte[]));
+            createCol(shapes, "ExtraParams", typeof (Byte[]));
+
+            shapes.PrimaryKey = new DataColumn[] {shapes.Columns["UUID"]};
+
+            return shapes;
+        }
+
+        private DataTable createItemsTable()
+        {
+            DataTable items = new DataTable("primitems");
+
+            createCol(items, "itemID", typeof (String));
+            createCol(items, "primID", typeof (String));
+            createCol(items, "assetID", typeof (String));
+            createCol(items, "parentFolderID", typeof (String));
+            
+            createCol(items, "invType", typeof (Int32));            
+            createCol(items, "assetType", typeof (Int32));
+
+            createCol(items, "name", typeof (String));
+            createCol(items, "description", typeof (String));
+
+            createCol(items, "creationDate", typeof (Int64));
+            createCol(items, "creatorID", typeof (String));
+            createCol(items, "ownerID", typeof (String));
+            createCol(items, "lastOwnerID", typeof (String));
+            createCol(items, "groupID", typeof (String));
+
+            createCol(items, "nextPermissions", typeof (UInt32));
+            createCol(items, "currentPermissions", typeof (UInt32));
+            createCol(items, "basePermissions", typeof (UInt32));
+            createCol(items, "everyonePermissions", typeof (UInt32));
+            createCol(items, "groupPermissions", typeof (UInt32));
+
+            items.PrimaryKey = new DataColumn[] {items.Columns["itemID"]};
+
+            return items;
+        }
+
+        private DataTable createLandTable()
+        {
+            DataTable land = new DataTable("land");
+            createCol(land, "UUID", typeof (String));
+            createCol(land, "RegionUUID", typeof (String));
+            createCol(land, "LocalLandID", typeof (UInt32));
+
+            // Bitmap is a byte[512]
+            createCol(land, "Bitmap", typeof (Byte[]));
+
+            createCol(land, "Name", typeof (String));
+            createCol(land, "Desc", typeof (String));
+            createCol(land, "OwnerUUID", typeof (String));
+            createCol(land, "IsGroupOwned", typeof (Boolean));
+            createCol(land, "Area", typeof (Int32));
+            createCol(land, "AuctionID", typeof (Int32)); //Unemplemented
+            createCol(land, "Category", typeof (Int32)); //Enum libsecondlife.Parcel.ParcelCategory
+            createCol(land, "ClaimDate", typeof (Int32));
+            createCol(land, "ClaimPrice", typeof (Int32));
+            createCol(land, "GroupUUID", typeof (string));
+            createCol(land, "SalePrice", typeof (Int32));
+            createCol(land, "LandStatus", typeof (Int32)); //Enum. libsecondlife.Parcel.ParcelStatus
+            createCol(land, "LandFlags", typeof (UInt32));
+            createCol(land, "LandingType", typeof (Byte));
+            createCol(land, "MediaAutoScale", typeof (Byte));
+            createCol(land, "MediaTextureUUID", typeof (String));
+            createCol(land, "MediaURL", typeof (String));
+            createCol(land, "MusicURL", typeof (String));
+            createCol(land, "PassHours", typeof (Double));
+            createCol(land, "PassPrice", typeof (UInt32));
+            createCol(land, "SnapshotUUID", typeof (String));
+            createCol(land, "UserLocationX", typeof (Double));
+            createCol(land, "UserLocationY", typeof (Double));
+            createCol(land, "UserLocationZ", typeof (Double));
+            createCol(land, "UserLookAtX", typeof (Double));
+            createCol(land, "UserLookAtY", typeof (Double));
+            createCol(land, "UserLookAtZ", typeof (Double));
+
+            land.PrimaryKey = new DataColumn[] {land.Columns["UUID"]};
+
+            return land;
+        }
+
+        private DataTable createLandAccessListTable()
+        {
+            DataTable landaccess = new DataTable("landaccesslist");
+            createCol(landaccess, "LandUUID", typeof (String));
+            createCol(landaccess, "AccessUUID", typeof (String));
+            createCol(landaccess, "Flags", typeof (UInt32));
+
+            return landaccess;
+        }
+
+        /***********************************************************************
+         *  
+         *  Convert between ADO.NET <=> OpenSim Objects
+         *
+         *  These should be database independant
+         *
+         **********************************************************************/
+
+        private SceneObjectPart buildPrim(DataRow row)
+        {
+            // TODO: this doesn't work yet because something more
+            // interesting has to be done to actually get these values
+            // back out.  Not enough time to figure it out yet.
+            SceneObjectPart prim = new SceneObjectPart();
+            prim.UUID = new LLUUID((String) row["UUID"]);
+            // explicit conversion of integers is required, which sort
+            // of sucks.  No idea if there is a shortcut here or not.
+            prim.ParentID = Convert.ToUInt32(row["ParentID"]);
+            prim.CreationDate = Convert.ToInt32(row["CreationDate"]);
+            prim.Name = (String) row["Name"];
+            // various text fields
+            prim.Text = (String) row["Text"];
+            prim.Description = (String) row["Description"];
+            prim.SitName = (String) row["SitName"];
+            prim.TouchName = (String) row["TouchName"];
+            // permissions
+            prim.ObjectFlags = Convert.ToUInt32(row["ObjectFlags"]);
+            prim.CreatorID = new LLUUID((String) row["CreatorID"]);
+            prim.OwnerID = new LLUUID((String) row["OwnerID"]);
+            prim.GroupID = new LLUUID((String) row["GroupID"]);
+            prim.LastOwnerID = new LLUUID((String) row["LastOwnerID"]);
+            prim.OwnerMask = Convert.ToUInt32(row["OwnerMask"]);
+            prim.NextOwnerMask = Convert.ToUInt32(row["NextOwnerMask"]);
+            prim.GroupMask = Convert.ToUInt32(row["GroupMask"]);
+            prim.EveryoneMask = Convert.ToUInt32(row["EveryoneMask"]);
+            prim.BaseMask = Convert.ToUInt32(row["BaseMask"]);
+            // vectors
+            prim.OffsetPosition = new LLVector3(
+                Convert.ToSingle(row["PositionX"]),
+                Convert.ToSingle(row["PositionY"]),
+                Convert.ToSingle(row["PositionZ"])
+                );
+            prim.GroupPosition = new LLVector3(
+                Convert.ToSingle(row["GroupPositionX"]),
+                Convert.ToSingle(row["GroupPositionY"]),
+                Convert.ToSingle(row["GroupPositionZ"])
+                );
+            prim.Velocity = new LLVector3(
+                Convert.ToSingle(row["VelocityX"]),
+                Convert.ToSingle(row["VelocityY"]),
+                Convert.ToSingle(row["VelocityZ"])
+                );
+            prim.AngularVelocity = new LLVector3(
+                Convert.ToSingle(row["AngularVelocityX"]),
+                Convert.ToSingle(row["AngularVelocityY"]),
+                Convert.ToSingle(row["AngularVelocityZ"])
+                );
+            prim.Acceleration = new LLVector3(
+                Convert.ToSingle(row["AccelerationX"]),
+                Convert.ToSingle(row["AccelerationY"]),
+                Convert.ToSingle(row["AccelerationZ"])
+                );
+            // quaternions
+            prim.RotationOffset = new LLQuaternion(
+                Convert.ToSingle(row["RotationX"]),
+                Convert.ToSingle(row["RotationY"]),
+                Convert.ToSingle(row["RotationZ"]),
+                Convert.ToSingle(row["RotationW"])
+                );
+
+            try
+            {
+                prim.SetSitTargetLL(new LLVector3(
+                                        Convert.ToSingle(row["SitTargetOffsetX"]),
+                                        Convert.ToSingle(row["SitTargetOffsetY"]),
+                                        Convert.ToSingle(row["SitTargetOffsetZ"])), new LLQuaternion(
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientX"]),
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientY"]),
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientZ"]),
+                                                                                        Convert.ToSingle(
+                                                                                            row["SitTargetOrientW"])));
+            }
+            catch (InvalidCastException)
+            {
+                // Database table was created before we got here and now has null values :P
+                m_conn.Open();
+                SqliteCommand cmd =
+                    new SqliteCommand("ALTER TABLE prims ADD COLUMN SitTargetOffsetX float NOT NULL default 0;", m_conn);
+                cmd.ExecuteNonQuery();
+                cmd =
+                    new SqliteCommand("ALTER TABLE prims ADD COLUMN SitTargetOffsetY float NOT NULL default 0;", m_conn);
+                cmd.ExecuteNonQuery();
+                cmd =
+                    new SqliteCommand("ALTER TABLE prims ADD COLUMN SitTargetOffsetZ float NOT NULL default 0;", m_conn);
+                cmd.ExecuteNonQuery();
+                cmd =
+                    new SqliteCommand("ALTER TABLE prims ADD COLUMN SitTargetOrientW float NOT NULL default 0;", m_conn);
+                cmd.ExecuteNonQuery();
+                cmd =
+                    new SqliteCommand("ALTER TABLE prims ADD COLUMN SitTargetOrientX float NOT NULL default 0;", m_conn);
+                cmd.ExecuteNonQuery();
+                cmd =
+                    new SqliteCommand("ALTER TABLE prims ADD COLUMN SitTargetOrientY float NOT NULL default 0;", m_conn);
+                cmd.ExecuteNonQuery();
+                cmd =
+                    new SqliteCommand("ALTER TABLE prims ADD COLUMN SitTargetOrientZ float NOT NULL default 0;", m_conn);
+                cmd.ExecuteNonQuery();
+            }
+
+            return prim;
+        }
+        
+        /// <summary>
+        /// Build a prim inventory item from the persisted data.
+        /// </summary>
+        /// <param name="row"></param>
+        /// <returns></returns>
+        private TaskInventoryItem buildItem(DataRow row)
+        {
+            TaskInventoryItem taskItem = new TaskInventoryItem();
+            
+            taskItem.ItemID        = new LLUUID((String)row["itemID"]); 
+            taskItem.ParentPartID  = new LLUUID((String)row["primID"]);
+            taskItem.AssetID       = new LLUUID((String)row["assetID"]);
+            taskItem.ParentID      = new LLUUID((String)row["parentFolderID"]);
+            
+            taskItem.InvType       = Convert.ToInt32(row["invType"]);
+            taskItem.Type          = Convert.ToInt32(row["assetType"]);
+            
+            taskItem.Name          = (String)row["name"];
+            taskItem.Description   = (String)row["description"];
+            taskItem.CreationDate  = Convert.ToUInt32(row["creationDate"]);
+            taskItem.CreatorID     = new LLUUID((String)row["creatorID"]);
+            taskItem.OwnerID       = new LLUUID((String)row["ownerID"]);
+            taskItem.LastOwnerID   = new LLUUID((String)row["lastOwnerID"]);
+            taskItem.GroupID       = new LLUUID((String)row["groupID"]);
+            
+            taskItem.NextOwnerMask = Convert.ToUInt32(row["nextPermissions"]);
+            taskItem.OwnerMask     = Convert.ToUInt32(row["currentPermissions"]);
+            taskItem.BaseMask      = Convert.ToUInt32(row["basePermissions"]);
+            taskItem.EveryoneMask  = Convert.ToUInt32(row["everyonePermissions"]);
+            taskItem.GroupMask     = Convert.ToUInt32(row["groupPermissions"]);
+            
+            return taskItem;
+        }
+
+        private LandData buildLandData(DataRow row)
+        {
+            LandData newData = new LandData();
+
+            newData.globalID = new LLUUID((String) row["UUID"]);
+            newData.localID = Convert.ToInt32(row["LocalLandID"]);
+
+            // Bitmap is a byte[512]
+            newData.landBitmapByteArray = (Byte[]) row["Bitmap"];
+
+            newData.landName = (String) row["Name"];
+            newData.landDesc = (String) row["Desc"];
+            newData.ownerID = (String) row["OwnerUUID"];
+            newData.isGroupOwned = (Boolean) row["IsGroupOwned"];
+            newData.area = Convert.ToInt32(row["Area"]);
+            newData.auctionID = Convert.ToUInt32(row["AuctionID"]); //Unemplemented
+            newData.category = (Parcel.ParcelCategory) Convert.ToInt32(row["Category"]);
+                //Enum libsecondlife.Parcel.ParcelCategory
+            newData.claimDate = Convert.ToInt32(row["ClaimDate"]);
+            newData.claimPrice = Convert.ToInt32(row["ClaimPrice"]);
+            newData.groupID = new LLUUID((String) row["GroupUUID"]);
+            newData.salePrice = Convert.ToInt32(row["SalePrice"]);
+            newData.landStatus = (Parcel.ParcelStatus) Convert.ToInt32(row["LandStatus"]);
+                //Enum. libsecondlife.Parcel.ParcelStatus
+            newData.landFlags = Convert.ToUInt32(row["LandFlags"]);
+            newData.landingType = (Byte) row["LandingType"];
+            newData.mediaAutoScale = (Byte) row["MediaAutoScale"];
+            newData.mediaID = new LLUUID((String) row["MediaTextureUUID"]);
+            newData.mediaURL = (String) row["MediaURL"];
+            newData.musicURL = (String) row["MusicURL"];
+            newData.passHours = Convert.ToSingle(row["PassHours"]);
+            newData.passPrice = Convert.ToInt32(row["PassPrice"]);
+            newData.snapshotID = (String) row["SnapshotUUID"];
+
+            newData.userLocation =
+                new LLVector3(Convert.ToSingle(row["UserLocationX"]), Convert.ToSingle(row["UserLocationY"]),
+                              Convert.ToSingle(row["UserLocationZ"]));
+            newData.userLookAt =
+                new LLVector3(Convert.ToSingle(row["UserLookAtX"]), Convert.ToSingle(row["UserLookAtY"]),
+                              Convert.ToSingle(row["UserLookAtZ"]));
+            newData.parcelAccessList = new List<ParcelManager.ParcelAccessEntry>();
+
+            return newData;
+        }
+
+        private ParcelManager.ParcelAccessEntry buildLandAccessData(DataRow row)
+        {
+            ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry();
+            entry.AgentID = new LLUUID((string) row["AccessUUID"]);
+            entry.Flags = (ParcelManager.AccessList) row["Flags"];
+            entry.Time = new DateTime();
+            return entry;
+        }
+
+        private Array serializeTerrain(double[,] val)
+        {
+            MemoryStream str = new MemoryStream(65536*sizeof (double));
+            BinaryWriter bw = new BinaryWriter(str);
+
+            // TODO: COMPATIBILITY - Add byte-order conversions
+            for (int x = 0; x < 256; x++)
+                for (int y = 0; y < 256; y++)
+                    bw.Write(val[x, y]);
+
+            return str.ToArray();
+        }
+
+//         private void fillTerrainRow(DataRow row, LLUUID regionUUID, int rev, double[,] val)
+//         {
+//             row["RegionUUID"] = regionUUID;
+//             row["Revision"] = rev;
+
+//             MemoryStream str = new MemoryStream(65536*sizeof (double));
+//             BinaryWriter bw = new BinaryWriter(str);
+
+//             // TODO: COMPATIBILITY - Add byte-order conversions
+//             for (int x = 0; x < 256; x++)
+//                 for (int y = 0; y < 256; y++)
+//                     bw.Write(val[x, y]);
+
+//             row["Heightfield"] = str.ToArray();
+//         }
+
+        private void fillPrimRow(DataRow row, SceneObjectPart prim, LLUUID sceneGroupID, LLUUID regionUUID)
+        {
+            row["UUID"] = Util.ToRawUuidString(prim.UUID);
+            row["RegionUUID"] = Util.ToRawUuidString(regionUUID);
+            row["ParentID"] = prim.ParentID;
+            row["CreationDate"] = prim.CreationDate;
+            row["Name"] = prim.Name;
+            row["SceneGroupID"] = Util.ToRawUuidString(sceneGroupID);
+                // the UUID of the root part for this SceneObjectGroup
+            // various text fields
+            row["Text"] = prim.Text;
+            row["Description"] = prim.Description;
+            row["SitName"] = prim.SitName;
+            row["TouchName"] = prim.TouchName;
+            // permissions
+            row["ObjectFlags"] = prim.ObjectFlags;
+            row["CreatorID"] = Util.ToRawUuidString(prim.CreatorID);
+            row["OwnerID"] = Util.ToRawUuidString(prim.OwnerID);
+            row["GroupID"] = Util.ToRawUuidString(prim.GroupID);
+            row["LastOwnerID"] = Util.ToRawUuidString(prim.LastOwnerID);
+            row["OwnerMask"] = prim.OwnerMask;
+            row["NextOwnerMask"] = prim.NextOwnerMask;
+            row["GroupMask"] = prim.GroupMask;
+            row["EveryoneMask"] = prim.EveryoneMask;
+            row["BaseMask"] = prim.BaseMask;
+            // vectors
+            row["PositionX"] = prim.OffsetPosition.X;
+            row["PositionY"] = prim.OffsetPosition.Y;
+            row["PositionZ"] = prim.OffsetPosition.Z;
+            row["GroupPositionX"] = prim.GroupPosition.X;
+            row["GroupPositionY"] = prim.GroupPosition.Y;
+            row["GroupPositionZ"] = prim.GroupPosition.Z;
+            row["VelocityX"] = prim.Velocity.X;
+            row["VelocityY"] = prim.Velocity.Y;
+            row["VelocityZ"] = prim.Velocity.Z;
+            row["AngularVelocityX"] = prim.AngularVelocity.X;
+            row["AngularVelocityY"] = prim.AngularVelocity.Y;
+            row["AngularVelocityZ"] = prim.AngularVelocity.Z;
+            row["AccelerationX"] = prim.Acceleration.X;
+            row["AccelerationY"] = prim.Acceleration.Y;
+            row["AccelerationZ"] = prim.Acceleration.Z;
+            // quaternions
+            row["RotationX"] = prim.RotationOffset.X;
+            row["RotationY"] = prim.RotationOffset.Y;
+            row["RotationZ"] = prim.RotationOffset.Z;
+            row["RotationW"] = prim.RotationOffset.W;
+
+            // Sit target
+            LLVector3 sitTargetPos = prim.GetSitTargetPositionLL();
+            row["SitTargetOffsetX"] = sitTargetPos.X;
+            row["SitTargetOffsetY"] = sitTargetPos.Y;
+            row["SitTargetOffsetZ"] = sitTargetPos.Z;
+
+            LLQuaternion sitTargetOrient = prim.GetSitTargetOrientationLL();
+            row["SitTargetOrientW"] = sitTargetOrient.W;
+            row["SitTargetOrientX"] = sitTargetOrient.X;
+            row["SitTargetOrientY"] = sitTargetOrient.Y;
+            row["SitTargetOrientZ"] = sitTargetOrient.Z;
+        }
+        
+        private void fillItemRow(DataRow row, TaskInventoryItem taskItem)
+        {
+            row["itemID"] = taskItem.ItemID;
+            row["primID"] = taskItem.ParentPartID;
+            row["assetID"] = taskItem.AssetID;
+            row["parentFolderID"] = taskItem.ParentID;
+            
+            row["invType"] = taskItem.InvType;
+            row["assetType"] = taskItem.Type;
+            
+            row["name"] = taskItem.Name;
+            row["description"] = taskItem.Description;
+            row["creationDate"] = taskItem.CreationDate;
+            row["creatorID"] = taskItem.CreatorID;
+            row["ownerID"] = taskItem.OwnerID;
+            row["lastOwnerID"] = taskItem.LastOwnerID;
+            row["groupID"] = taskItem.GroupID;
+            row["nextPermissions"] = taskItem.NextOwnerMask;
+            row["currentPermissions"] = taskItem.OwnerMask;
+            row["basePermissions"] = taskItem.BaseMask;
+            row["everyonePermissions"] = taskItem.EveryoneMask;
+            row["groupPermissions"] = taskItem.GroupMask;
+        }
+
+        private void fillLandRow(DataRow row, LandData land, LLUUID regionUUID)
+        {
+            row["UUID"] = Util.ToRawUuidString(land.globalID);
+            row["RegionUUID"] = Util.ToRawUuidString(regionUUID);
+            row["LocalLandID"] = land.localID;
+
+            // Bitmap is a byte[512]
+            row["Bitmap"] = land.landBitmapByteArray;
+
+            row["Name"] = land.landName;
+            row["Desc"] = land.landDesc;
+            row["OwnerUUID"] = Util.ToRawUuidString(land.ownerID);
+            row["IsGroupOwned"] = land.isGroupOwned;
+            row["Area"] = land.area;
+            row["AuctionID"] = land.auctionID; //Unemplemented
+            row["Category"] = land.category; //Enum libsecondlife.Parcel.ParcelCategory
+            row["ClaimDate"] = land.claimDate;
+            row["ClaimPrice"] = land.claimPrice;
+            row["GroupUUID"] = Util.ToRawUuidString(land.groupID);
+            row["SalePrice"] = land.salePrice;
+            row["LandStatus"] = land.landStatus; //Enum. libsecondlife.Parcel.ParcelStatus
+            row["LandFlags"] = land.landFlags;
+            row["LandingType"] = land.landingType;
+            row["MediaAutoScale"] = land.mediaAutoScale;
+            row["MediaTextureUUID"] = Util.ToRawUuidString(land.mediaID);
+            row["MediaURL"] = land.mediaURL;
+            row["MusicURL"] = land.musicURL;
+            row["PassHours"] = land.passHours;
+            row["PassPrice"] = land.passPrice;
+            row["SnapshotUUID"] = Util.ToRawUuidString(land.snapshotID);
+            row["UserLocationX"] = land.userLocation.X;
+            row["UserLocationY"] = land.userLocation.Y;
+            row["UserLocationZ"] = land.userLocation.Z;
+            row["UserLookAtX"] = land.userLookAt.X;
+            row["UserLookAtY"] = land.userLookAt.Y;
+            row["UserLookAtZ"] = land.userLookAt.Z;
+        }
+
+        private void fillLandAccessRow(DataRow row, ParcelManager.ParcelAccessEntry entry, LLUUID parcelID)
+        {
+            row["LandUUID"] = Util.ToRawUuidString(parcelID);
+            row["AccessUUID"] = Util.ToRawUuidString(entry.AgentID);
+            row["Flags"] = entry.Flags;
+        }
+
+        private PrimitiveBaseShape buildShape(DataRow row)
+        {
+            PrimitiveBaseShape s = new PrimitiveBaseShape();
+            s.Scale = new LLVector3(
+                Convert.ToSingle(row["ScaleX"]),
+                Convert.ToSingle(row["ScaleY"]),
+                Convert.ToSingle(row["ScaleZ"])
+                );
+            // paths
+            s.PCode = Convert.ToByte(row["PCode"]);
+            s.PathBegin = Convert.ToUInt16(row["PathBegin"]);
+            s.PathEnd = Convert.ToUInt16(row["PathEnd"]);
+            s.PathScaleX = Convert.ToByte(row["PathScaleX"]);
+            s.PathScaleY = Convert.ToByte(row["PathScaleY"]);
+            s.PathShearX = Convert.ToByte(row["PathShearX"]);
+            s.PathShearY = Convert.ToByte(row["PathShearY"]);
+            s.PathSkew = Convert.ToSByte(row["PathSkew"]);
+            s.PathCurve = Convert.ToByte(row["PathCurve"]);
+            s.PathRadiusOffset = Convert.ToSByte(row["PathRadiusOffset"]);
+            s.PathRevolutions = Convert.ToByte(row["PathRevolutions"]);
+            s.PathTaperX = Convert.ToSByte(row["PathTaperX"]);
+            s.PathTaperY = Convert.ToSByte(row["PathTaperY"]);
+            s.PathTwist = Convert.ToSByte(row["PathTwist"]);
+            s.PathTwistBegin = Convert.ToSByte(row["PathTwistBegin"]);
+            // profile
+            s.ProfileBegin = Convert.ToUInt16(row["ProfileBegin"]);
+            s.ProfileEnd = Convert.ToUInt16(row["ProfileEnd"]);
+            s.ProfileCurve = Convert.ToByte(row["ProfileCurve"]);
+            s.ProfileHollow = Convert.ToUInt16(row["ProfileHollow"]);
+            try
+            {
+                s.State = Convert.ToByte(row["State"]);
+            }
+            catch (InvalidCastException)
+            {
+                m_conn.Open();
+                SqliteCommand cmd =
+                    new SqliteCommand("ALTER TABLE primshapes ADD COLUMN State Integer NOT NULL default 0;", m_conn);
+                cmd.ExecuteNonQuery();
+            }
+            // text TODO: this isn't right] = but I'm not sure the right
+            // way to specify this as a blob atm
+
+            byte[] textureEntry = (byte[]) row["Texture"];
+            s.TextureEntry = textureEntry;
+
+            s.ExtraParams = (byte[]) row["ExtraParams"];
+            // System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
+            //             string texture = encoding.GetString((Byte[])row["Texture"]);
+            //             if (!texture.StartsWith("<"))
+            //             {
+            //                 //here so that we can still work with old format database files (ie from before I added xml serialization)
+            //                  LLObject.TextureEntry textureEntry = null;
+            //                 textureEntry = new LLObject.TextureEntry(new LLUUID(texture));
+            //                 s.TextureEntry = textureEntry.ToBytes();
+            //             }
+            //             else
+            //             {
+            //                 TextureBlock textureEntry = TextureBlock.FromXmlString(texture);
+            //                 s.TextureEntry = textureEntry.TextureData;
+            //                 s.ExtraParams = textureEntry.ExtraParams;
+            // }
+
+            return s;
+        }
+
+        private void fillShapeRow(DataRow row, SceneObjectPart prim)
+        {
+            PrimitiveBaseShape s = prim.Shape;
+            row["UUID"] = Util.ToRawUuidString(prim.UUID);
+            // shape is an enum
+            row["Shape"] = 0;
+            // vectors
+            row["ScaleX"] = s.Scale.X;
+            row["ScaleY"] = s.Scale.Y;
+            row["ScaleZ"] = s.Scale.Z;
+            // paths
+            row["PCode"] = s.PCode;
+            row["PathBegin"] = s.PathBegin;
+            row["PathEnd"] = s.PathEnd;
+            row["PathScaleX"] = s.PathScaleX;
+            row["PathScaleY"] = s.PathScaleY;
+            row["PathShearX"] = s.PathShearX;
+            row["PathShearY"] = s.PathShearY;
+            row["PathSkew"] = s.PathSkew;
+            row["PathCurve"] = s.PathCurve;
+            row["PathRadiusOffset"] = s.PathRadiusOffset;
+            row["PathRevolutions"] = s.PathRevolutions;
+            row["PathTaperX"] = s.PathTaperX;
+            row["PathTaperY"] = s.PathTaperY;
+            row["PathTwist"] = s.PathTwist;
+            row["PathTwistBegin"] = s.PathTwistBegin;
+            // profile
+            row["ProfileBegin"] = s.ProfileBegin;
+            row["ProfileEnd"] = s.ProfileEnd;
+            row["ProfileCurve"] = s.ProfileCurve;
+            row["ProfileHollow"] = s.ProfileHollow;
+            row["State"] = s.State;
+
+            row["Texture"] = s.TextureEntry;
+            row["ExtraParams"] = s.ExtraParams;
+        }
+
+        private void addPrim(SceneObjectPart prim, LLUUID sceneGroupID, LLUUID regionUUID)
+        {
+            DataTable prims = ds.Tables["prims"];
+            DataTable shapes = ds.Tables["primshapes"];
+
+            DataRow primRow = prims.Rows.Find(Util.ToRawUuidString(prim.UUID));
+            if (primRow == null)
+            {
+                primRow = prims.NewRow();
+                fillPrimRow(primRow, prim, sceneGroupID, regionUUID);
+                prims.Rows.Add(primRow);
+            }
+            else
+            {
+                fillPrimRow(primRow, prim, sceneGroupID, regionUUID);
+            }
+
+            DataRow shapeRow = shapes.Rows.Find(Util.ToRawUuidString(prim.UUID));
+            if (shapeRow == null)
+            {
+                shapeRow = shapes.NewRow();
+                fillShapeRow(shapeRow, prim);
+                shapes.Rows.Add(shapeRow);
+            }
+            else
+            {
+                fillShapeRow(shapeRow, prim);
+            }
+        }
+        
+        // see IRegionDatastore
+        public void StorePrimInventory(LLUUID primID, ICollection<TaskInventoryItem> items)
+        {
+            if (!persistPrimInventories)
+                return;
+            
+            m_log.InfoFormat("[DATASTORE]: Entered StorePrimInventory with prim ID {0}", primID);
+            
+            DataTable dbItems = ds.Tables["primitems"]; 
+            
+            // For now, we're just going to crudely remove all the previous inventory items 
+            // no matter whether they have changed or not, and replace them with the current set.            
+            lock (ds)
+            {
+                RemoveItems(primID);
+                
+                // repalce with current inventory details
+                foreach (TaskInventoryItem newItem in items)
+                {
+//                    m_log.InfoFormat(
+//                        "[DATASTORE]: ", 
+//                        "Adding item {0}, {1} to prim ID {2}", 
+//                        newItem.Name, newItem.ItemID, newItem.ParentPartID);
+                    
+                    DataRow newItemRow = dbItems.NewRow();
+                    fillItemRow(newItemRow, newItem);
+                    dbItems.Rows.Add(newItemRow);                
+                }
+            }
+            
+            Commit();
+        }
+
+        /***********************************************************************
+         *
+         *  SQL Statement Creation Functions
+         *
+         *  These functions create SQL statements for update, insert, and create.
+         *  They can probably be factored later to have a db independant
+         *  portion and a db specific portion
+         *
+         **********************************************************************/
+
+        private SqliteCommand createInsertCommand(string table, DataTable dt)
+        {
+            /**
+             *  This is subtle enough to deserve some commentary.
+             *  Instead of doing *lots* and *lots of hardcoded strings
+             *  for database definitions we'll use the fact that
+             *  realistically all insert statements look like "insert
+             *  into A(b, c) values(:b, :c) on the parameterized query
+             *  front.  If we just have a list of b, c, etc... we can
+             *  generate these strings instead of typing them out.
+             */
+            string[] cols = new string[dt.Columns.Count];
+            for (int i = 0; i < dt.Columns.Count; i++)
+            {
+                DataColumn col = dt.Columns[i];
+                cols[i] = col.ColumnName;
+            }
+
+            string sql = "insert into " + table + "(";
+            sql += String.Join(", ", cols);
+            // important, the first ':' needs to be here, the rest get added in the join
+            sql += ") values (:";
+            sql += String.Join(", :", cols);
+            sql += ")";
+            SqliteCommand cmd = new SqliteCommand(sql);
+
+            // this provides the binding for all our parameters, so
+            // much less code than it used to be
+            foreach (DataColumn col in dt.Columns)
+            {
+                cmd.Parameters.Add(createSqliteParameter(col.ColumnName, col.DataType));
+            }
+            return cmd;
+        }
+
+        private SqliteCommand createUpdateCommand(string table, string pk, DataTable dt)
+        {
+            string sql = "update " + table + " set ";
+            string subsql = String.Empty;
+            foreach (DataColumn col in dt.Columns)
+            {
+                if (subsql.Length > 0)
+                {
+                    // a map function would rock so much here
+                    subsql += ", ";
+                }
+                subsql += col.ColumnName + "= :" + col.ColumnName;
+            }
+            sql += subsql;
+            sql += " where " + pk;
+            SqliteCommand cmd = new SqliteCommand(sql);
+
+            // this provides the binding for all our parameters, so
+            // much less code than it used to be
+
+            foreach (DataColumn col in dt.Columns)
+            {
+                cmd.Parameters.Add(createSqliteParameter(col.ColumnName, col.DataType));
+            }
+            return cmd;
+        }
+
+
+        private string defineTable(DataTable dt)
+        {
+            string sql = "create table " + dt.TableName + "(";
+            string subsql = String.Empty;
+            foreach (DataColumn col in dt.Columns)
+            {
+                if (subsql.Length > 0)
+                {
+                    // a map function would rock so much here
+                    subsql += ",\n";
+                }
+                subsql += col.ColumnName + " " + sqliteType(col.DataType);
+                if (dt.PrimaryKey.Length > 0 && col == dt.PrimaryKey[0])
+                {
+                    subsql += " primary key";
+                }
+            }
+            sql += subsql;
+            sql += ")";
+            return sql;
+        }
+
+        /***********************************************************************
+         *
+         *  Database Binding functions
+         *
+         *  These will be db specific due to typing, and minor differences
+         *  in databases.
+         *
+         **********************************************************************/
+
+        ///<summary>
+        /// This is a convenience function that collapses 5 repetitive
+        /// lines for defining SqliteParameters to 2 parameters:
+        /// column name and database type.
+        ///        
+        /// It assumes certain conventions like :param as the param
+        /// name to replace in parametrized queries, and that source
+        /// version is always current version, both of which are fine
+        /// for us.
+        ///</summary>
+        ///<returns>a built sqlite parameter</returns>
+        private SqliteParameter createSqliteParameter(string name, Type type)
+        {
+            SqliteParameter param = new SqliteParameter();
+            param.ParameterName = ":" + name;
+            param.DbType = dbtypeFromType(type);
+            param.SourceColumn = name;
+            param.SourceVersion = DataRowVersion.Current;
+            return param;
+        }                
+
+        private void setupPrimCommands(SqliteDataAdapter da, SqliteConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("prims", ds.Tables["prims"]);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("prims", "UUID=:UUID", ds.Tables["prims"]);
+            da.UpdateCommand.Connection = conn;
+
+            SqliteCommand delete = new SqliteCommand("delete from prims where UUID = :UUID");
+            delete.Parameters.Add(createSqliteParameter("UUID", typeof (String)));
+            delete.Connection = conn;
+            da.DeleteCommand = delete;
+        }
+        
+        private void setupItemsCommands(SqliteDataAdapter da, SqliteConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("primitems", ds.Tables["primitems"]);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("primitems", "itemID = :itemID", ds.Tables["primitems"]);
+            da.UpdateCommand.Connection = conn;
+
+            SqliteCommand delete = new SqliteCommand("delete from primitems where itemID = :itemID");
+            delete.Parameters.Add(createSqliteParameter("itemID", typeof (String)));
+            delete.Connection = conn;
+            da.DeleteCommand = delete;
+        }        
+
+        private void setupTerrainCommands(SqliteDataAdapter da, SqliteConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("terrain", ds.Tables["terrain"]);
+            da.InsertCommand.Connection = conn;
+        }
+
+        private void setupLandCommands(SqliteDataAdapter da, SqliteConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("land", ds.Tables["land"]);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("land", "UUID=:UUID", ds.Tables["land"]);
+            da.UpdateCommand.Connection = conn;
+        }
+
+        private void setupLandAccessCommands(SqliteDataAdapter da, SqliteConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("landaccesslist", ds.Tables["landaccesslist"]);
+            da.InsertCommand.Connection = conn;
+        }
+
+        private void setupShapeCommands(SqliteDataAdapter da, SqliteConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("primshapes", ds.Tables["primshapes"]);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = createUpdateCommand("primshapes", "UUID=:UUID", ds.Tables["primshapes"]);
+            da.UpdateCommand.Connection = conn;
+
+            SqliteCommand delete = new SqliteCommand("delete from primshapes where UUID = :UUID");
+            delete.Parameters.Add(createSqliteParameter("UUID", typeof (String)));
+            delete.Connection = conn;
+            da.DeleteCommand = delete;
+        }
+
+        /// <summary>
+        /// Create the necessary database tables.
+        /// </summary>
+        /// <param name="conn"></param>
+        private void InitDB(SqliteConnection conn)
+        {
+            string createPrims = defineTable(createPrimTable());
+            string createShapes = defineTable(createShapeTable());
+            string createItems = defineTable(createItemsTable());
+            string createTerrain = defineTable(createTerrainTable());
+            string createLand = defineTable(createLandTable());
+            string createLandAccessList = defineTable(createLandAccessListTable());
+
+            SqliteCommand pcmd = new SqliteCommand(createPrims, conn);
+            SqliteCommand scmd = new SqliteCommand(createShapes, conn);
+            SqliteCommand icmd = new SqliteCommand(createItems, conn);
+            SqliteCommand tcmd = new SqliteCommand(createTerrain, conn);
+            SqliteCommand lcmd = new SqliteCommand(createLand, conn);
+            SqliteCommand lalcmd = new SqliteCommand(createLandAccessList, conn);
+
+            try
+            {
+                pcmd.ExecuteNonQuery();
+            }
+            catch (SqliteSyntaxException)
+            {
+                m_log.Warn("[SQLITE]: Primitives Table Already Exists");
+            }
+
+            try
+            {
+                scmd.ExecuteNonQuery();
+            }
+            catch (SqliteSyntaxException)
+            {
+                m_log.Warn("[SQLITE]: Shapes Table Already Exists");
+            }
+
+            if (persistPrimInventories)
+            {
+                try
+                {
+                    icmd.ExecuteNonQuery();
+                }
+                catch (SqliteSyntaxException)
+                {
+                    m_log.Warn("[SQLITE]: Primitives Inventory Table Already Exists");
+                }
+            }
+
+            try
+            {
+                tcmd.ExecuteNonQuery();
+            }
+            catch (SqliteSyntaxException)
+            {
+                m_log.Warn("[SQLITE]: Terrain Table Already Exists");
+            }
+
+            try
+            {
+                lcmd.ExecuteNonQuery();
+            }
+            catch (SqliteSyntaxException)
+            {
+                m_log.Warn("[SQLITE]: Land Table Already Exists");
+            }
+
+            try
+            {
+                lalcmd.ExecuteNonQuery();
+            }
+            catch (SqliteSyntaxException)
+            {
+                m_log.Warn("[SQLITE]: LandAccessList Table Already Exists");
+            }
+        }
+
+        private bool TestTables(SqliteConnection conn)
+        {
+            SqliteCommand primSelectCmd = new SqliteCommand(primSelect, conn);
+            SqliteDataAdapter pDa = new SqliteDataAdapter(primSelectCmd);
+
+            SqliteCommand shapeSelectCmd = new SqliteCommand(shapeSelect, conn);
+            SqliteDataAdapter sDa = new SqliteDataAdapter(shapeSelectCmd);
+
+            SqliteCommand itemsSelectCmd = new SqliteCommand(itemsSelect, conn);
+            SqliteDataAdapter iDa = new SqliteDataAdapter(itemsSelectCmd);
+
+            SqliteCommand terrainSelectCmd = new SqliteCommand(terrainSelect, conn);
+            SqliteDataAdapter tDa = new SqliteDataAdapter(terrainSelectCmd);
+
+            SqliteCommand landSelectCmd = new SqliteCommand(landSelect, conn);
+            SqliteDataAdapter lDa = new SqliteDataAdapter(landSelectCmd);
+
+            SqliteCommand landAccessListSelectCmd = new SqliteCommand(landAccessListSelect, conn);
+            SqliteDataAdapter lalDa = new SqliteDataAdapter(landAccessListSelectCmd);
+
+            DataSet tmpDS = new DataSet();
+            try
+            {
+                pDa.Fill(tmpDS, "prims");
+                sDa.Fill(tmpDS, "primshapes");
+
+                if (persistPrimInventories)
+                    iDa.Fill(tmpDS, "primitems");
+
+                tDa.Fill(tmpDS, "terrain");
+                lDa.Fill(tmpDS, "land");
+                lalDa.Fill(tmpDS, "landaccesslist");
+            }
+            catch (SqliteSyntaxException)
+            {
+                m_log.Info("[DATASTORE]: SQLite Database doesn't exist... creating");
+                InitDB(conn);
+            }
+
+            pDa.Fill(tmpDS, "prims");
+            sDa.Fill(tmpDS, "primshapes");
+
+            if (persistPrimInventories)
+                iDa.Fill(tmpDS, "primitems");
+
+            tDa.Fill(tmpDS, "terrain");
+            lDa.Fill(tmpDS, "land");
+            lalDa.Fill(tmpDS, "landaccesslist");
+
+            foreach (DataColumn col in createPrimTable().Columns)
+            {
+                if (!tmpDS.Tables["prims"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing required column:" + col.ColumnName);
+                    return false;
+                }
+            }
+
+            foreach (DataColumn col in createShapeTable().Columns)
+            {
+                if (!tmpDS.Tables["primshapes"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing required column:" + col.ColumnName);
+                    return false;
+                }
+            }
+            
+            // XXX primitems should probably go here eventually
+
+            foreach (DataColumn col in createTerrainTable().Columns)
+            {
+                if (!tmpDS.Tables["terrain"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing require column:" + col.ColumnName);
+                    return false;
+                }
+            }
+
+            foreach (DataColumn col in createLandTable().Columns)
+            {
+                if (!tmpDS.Tables["land"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing require column:" + col.ColumnName);
+                    return false;
+                }
+            }
+
+            foreach (DataColumn col in createLandAccessListTable().Columns)
+            {
+                if (!tmpDS.Tables["landaccesslist"].Columns.Contains(col.ColumnName))
+                {
+                    m_log.Info("[DATASTORE]: Missing require column:" + col.ColumnName);
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /***********************************************************************
+         *
+         *  Type conversion functions
+         *
+         **********************************************************************/
+
+        private DbType dbtypeFromType(Type type)
+        {
+            if (type == typeof (String))
+            {
+                return DbType.String;
+            }
+            else if (type == typeof (Int32))
+            {
+                return DbType.Int32;
+            }
+            else if (type == typeof (Double))
+            {
+                return DbType.Double;
+            }
+            else if (type == typeof (Byte))
+            {
+                return DbType.Byte;
+            }
+            else if (type == typeof (Double))
+            {
+                return DbType.Double;
+            }
+            else if (type == typeof (Byte[]))
+            {
+                return DbType.Binary;
+            }
+            else
+            {
+                return DbType.String;
+            }
+        }
+
+        // this is something we'll need to implement for each db
+        // slightly differently.
+        private string sqliteType(Type type)
+        {
+            if (type == typeof (String))
+            {
+                return "varchar(255)";
+            }
+            else if (type == typeof (Int32))
+            {
+                return "integer";
+            }
+            else if (type == typeof (Int64))
+            {
+                return "integer";
+            }
+            else if (type == typeof (Double))
+            {
+                return "float";
+            }
+            else if (type == typeof (Byte[]))
+            {
+                return "blob";
+            }
+            else
+            {
+                return "string";
+            }
+        }
+    }
+}
diff --git a/OpenSim/Data/SQLite/SQLiteUserData.cs b/OpenSim/Data/SQLite/SQLiteUserData.cs
new file mode 100644
index 0000000..2efd4aa
--- /dev/null
+++ b/OpenSim/Data/SQLite/SQLiteUserData.cs
@@ -0,0 +1,821 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using libsecondlife;
+using Mono.Data.SqliteClient;
+using OpenSim.Framework.Console;
+
+namespace OpenSim.Framework.Data.SQLite
+{
+    /// <summary>
+    /// A User storage interface for the SQLite database system
+    /// </summary>
+    public class SQLiteUserData : UserDataBase
+    {
+        private static readonly log4net.ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+
+        /// <summary>
+        /// The database manager
+        /// </summary>
+        /// <summary>
+        /// Artificial constructor called upon plugin load
+        /// </summary>
+        private const string SelectUserByUUID = "select * from users where UUID=:UUID";
+        private const string SelectUserByName = "select * from users where username=:username and surname=:surname";
+        private const string SelectFriendsByUUID = "select a.friendID, a.friendPerms, b.friendPerms from userfriends as a, userfriends as b where a.ownerID=:ownerID and b.ownerID=a.friendID and b.friendID=a.ownerID";
+
+        private const string userSelect = "select * from users";
+        private const string userFriendsSelect = "select a.ownerID as ownerID,a.friendID as friendID,a.friendPerms as friendPerms,b.friendPerms as ownerperms, b.ownerID as fownerID, b.friendID as ffriendID from userfriends as a, userfriends as b";
+
+        private const string AvatarPickerAndSQL = "select * from users where username like :username and surname like :surname";
+        private const string AvatarPickerOrSQL = "select * from users where username like :username or surname like :surname";
+        
+        private DataSet ds;
+        private SqliteDataAdapter da;
+        private SqliteDataAdapter daf;
+        SqliteConnection g_conn;
+
+        override public void Initialise()
+        {
+            SqliteConnection conn = new SqliteConnection("URI=file:userprofiles.db,version=3");
+            TestTables(conn);
+
+            // This sucks, but It doesn't seem to work with the dataset Syncing :P
+            g_conn = conn;
+            g_conn.Open();
+            
+            ds = new DataSet();
+            da = new SqliteDataAdapter(new SqliteCommand(userSelect, conn));
+            daf = new SqliteDataAdapter(new SqliteCommand(userFriendsSelect, conn));
+
+            lock (ds)
+            {
+                ds.Tables.Add(createUsersTable());
+                ds.Tables.Add(createUserAgentsTable());
+                ds.Tables.Add(createUserFriendsTable());
+
+                setupUserCommands(da, conn);
+                da.Fill(ds.Tables["users"]);
+
+                setupUserFriendsCommands(daf, conn);
+                try
+                {
+                    daf.Fill(ds.Tables["userfriends"]);
+                }
+                catch (SqliteSyntaxException)
+                {
+                    m_log.Info("[SQLITE]: userfriends table not found, creating.... ");
+                    InitDB(conn);
+                    daf.Fill(ds.Tables["userfriends"]);
+                }
+
+            }
+
+            return;
+        }
+
+        // see IUserData
+        override public UserProfileData GetUserByUUID(LLUUID uuid)
+        {
+            lock (ds)
+            {
+                DataRow row = ds.Tables["users"].Rows.Find(Util.ToRawUuidString(uuid));
+                if (row != null)
+                {
+                    UserProfileData user = buildUserProfile(row);
+                    row = ds.Tables["useragents"].Rows.Find(Util.ToRawUuidString(uuid));
+                    if (row != null)
+                    {
+                        user.currentAgent = buildUserAgent(row);
+                    }
+                    return user;
+                }
+                else
+                {
+                    return null;
+                }
+            }
+        }
+
+        // see IUserData
+        override public UserProfileData GetUserByName(string fname, string lname)
+        {
+            string select = "surname = '" + lname + "' and username = '" + fname + "'";
+            lock (ds)
+            {
+                DataRow[] rows = ds.Tables["users"].Select(select);
+                if (rows.Length > 0)
+                {
+                    UserProfileData user = buildUserProfile(rows[0]);
+                    DataRow row = ds.Tables["useragents"].Rows.Find(Util.ToRawUuidString(user.UUID));
+                    if (row != null)
+                    {
+                        user.currentAgent = buildUserAgent(row);
+                    }
+                    return user;
+                }
+                else
+                {
+                    return null;
+                }
+            }
+        }
+
+        #region User Friends List Data
+
+        override public void AddNewUserFriend(LLUUID friendlistowner, LLUUID friend, uint perms)
+        {
+            string InsertFriends = "insert into userfriends(ownerID, friendID, friendPerms) values(:ownerID, :friendID, :perms)";
+            
+            using (SqliteCommand cmd = new SqliteCommand(InsertFriends, g_conn))
+            {
+                cmd.Parameters.Add(new SqliteParameter(":ownerID", friendlistowner.UUID.ToString()));
+                cmd.Parameters.Add(new SqliteParameter(":friendID", friend.UUID.ToString()));
+                cmd.Parameters.Add(new SqliteParameter(":perms", perms));
+                cmd.ExecuteNonQuery();
+            }
+            using (SqliteCommand cmd = new SqliteCommand(InsertFriends, g_conn))
+            {
+                cmd.Parameters.Add(new SqliteParameter(":ownerID", friend.UUID.ToString()));
+                cmd.Parameters.Add(new SqliteParameter(":friendID", friendlistowner.UUID.ToString()));
+                cmd.Parameters.Add(new SqliteParameter(":perms", perms));
+                cmd.ExecuteNonQuery();
+            }
+        }
+
+        override public void RemoveUserFriend(LLUUID friendlistowner, LLUUID friend)
+        {
+            string DeletePerms = "delete from friendlist where (ownerID=:ownerID and friendID=:friendID) or (ownerID=:friendID and friendID=:ownerID)";
+            using (SqliteCommand cmd = new SqliteCommand(DeletePerms, g_conn))
+            {
+                cmd.Parameters.Add(new SqliteParameter(":ownerID", friendlistowner.UUID.ToString()));
+                cmd.Parameters.Add(new SqliteParameter(":friendID", friend.UUID.ToString()));
+                cmd.ExecuteNonQuery();
+            }
+        }
+
+        override public void UpdateUserFriendPerms(LLUUID friendlistowner, LLUUID friend, uint perms)
+        {
+            string UpdatePerms = "update friendlist set perms=:perms where ownerID=:ownerID and friendID=:friendID";
+            using (SqliteCommand cmd = new SqliteCommand(UpdatePerms, g_conn))
+            {
+                cmd.Parameters.Add(new SqliteParameter(":perms", perms));
+                cmd.Parameters.Add(new SqliteParameter(":ownerID", friendlistowner.UUID.ToString()));
+                cmd.Parameters.Add(new SqliteParameter(":friendID", friend.UUID.ToString()));
+                cmd.ExecuteNonQuery();
+            }
+        }
+
+        override public List<FriendListItem> GetUserFriendList(LLUUID friendlistowner)
+        {
+            List<FriendListItem> returnlist = new List<FriendListItem>();
+
+            using (SqliteCommand cmd = new SqliteCommand(SelectFriendsByUUID, g_conn))
+            {
+                cmd.Parameters.Add(new SqliteParameter(":ownerID", friendlistowner.UUID.ToString()));
+
+                try
+                {
+                    using (IDataReader reader = cmd.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            FriendListItem user = new FriendListItem();
+                            user.FriendListOwner = friendlistowner;
+                            user.Friend = new LLUUID((string)reader[0]);
+                            user.FriendPerms = Convert.ToUInt32(reader[1]);
+                            user.FriendListOwnerPerms = Convert.ToUInt32(reader[2]);
+                            returnlist.Add(user);
+                        }
+                        reader.Close();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    m_log.Error("[USER]: Exception getting friends list for user: " + ex.ToString());
+                }
+            }
+             
+            return returnlist;
+        }
+       
+        
+
+
+        #endregion
+
+        override public void UpdateUserCurrentRegion(LLUUID avatarid, LLUUID regionuuid)
+        {
+            m_log.Info("[USER]: Stub UpdateUserCUrrentRegion called");
+        }
+
+
+        override public List<Framework.AvatarPickerAvatar> GeneratePickerResults(LLUUID queryID, string query)
+        {
+            List<Framework.AvatarPickerAvatar> returnlist = new List<Framework.AvatarPickerAvatar>();
+            string[] querysplit;
+            querysplit = query.Split(' ');
+            if (querysplit.Length == 2)
+            {
+                using (SqliteCommand cmd = new SqliteCommand(AvatarPickerAndSQL, g_conn))
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":username", querysplit[0] + "%"));
+                    cmd.Parameters.Add(new SqliteParameter(":surname", querysplit[1] + "%"));
+
+                    using (IDataReader reader = cmd.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            Framework.AvatarPickerAvatar user = new Framework.AvatarPickerAvatar();
+                            user.AvatarID = new LLUUID((string) reader["UUID"]);
+                            user.firstName = (string) reader["username"];
+                            user.lastName = (string) reader["surname"];
+                            returnlist.Add(user);
+                        }
+                        reader.Close();
+                    }
+                }
+            }
+            else if (querysplit.Length == 1)
+            {
+                using (SqliteCommand cmd = new SqliteCommand(AvatarPickerOrSQL, g_conn))
+                {
+                    cmd.Parameters.Add(new SqliteParameter(":username", querysplit[0] + "%"));
+                    cmd.Parameters.Add(new SqliteParameter(":surname", querysplit[0] + "%"));
+
+                    using (IDataReader reader = cmd.ExecuteReader())
+                    {
+                        while (reader.Read())
+                        {
+                            Framework.AvatarPickerAvatar user = new Framework.AvatarPickerAvatar();
+                            user.AvatarID = new LLUUID((string) reader["UUID"]);
+                            user.firstName = (string) reader["username"];
+                            user.lastName = (string) reader["surname"];
+                            returnlist.Add(user);
+                        }
+                        reader.Close();
+                    }
+                }
+            }
+            return returnlist;
+        }
+
+        /// <summary>
+        /// Returns a user by UUID direct
+        /// </summary>
+        /// <param name="uuid">The user's account ID</param>
+        /// <returns>A matching user profile</returns>
+        override public UserAgentData GetAgentByUUID(LLUUID uuid)
+        {
+            try
+            {
+                return GetUserByUUID(uuid).currentAgent;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Returns a session by account name
+        /// </summary>
+        /// <param name="name">The account name</param>
+        /// <returns>The user's session agent</returns>
+        override public UserAgentData GetAgentByName(string name)
+        {
+            return GetAgentByName(name.Split(' ')[0], name.Split(' ')[1]);
+        }
+
+        /// <summary>
+        /// Returns a session by account name
+        /// </summary>
+        /// <param name="fname">The first part of the user's account name</param>
+        /// <param name="lname">The second part of the user's account name</param>
+        /// <returns>A user agent</returns>
+        override public UserAgentData GetAgentByName(string fname, string lname)
+        {
+            try
+            {
+                return GetUserByName(fname, lname).currentAgent;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+
+
+        override public void StoreWebLoginKey(LLUUID AgentID, LLUUID WebLoginKey)
+        {
+            DataTable users = ds.Tables["users"];
+            lock (ds)
+            {
+                DataRow row = users.Rows.Find(Util.ToRawUuidString(AgentID));
+                if (row == null)
+                {
+                    m_log.Warn("[WEBLOGIN]: Unable to store new web login key for non-existant user");
+                }
+                else
+                {
+                    UserProfileData user = GetUserByUUID(AgentID);
+                    user.webLoginKey = WebLoginKey;
+                    fillUserRow(row, user);
+                    da.Update(ds, "users");
+
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// Creates a new user profile
+        /// </summary>
+        /// <param name="user">The profile to add to the database</param>
+        override public void AddNewUserProfile(UserProfileData user)
+        {
+            DataTable users = ds.Tables["users"];
+            lock (ds)
+            {
+                DataRow row = users.Rows.Find(Util.ToRawUuidString(user.UUID));
+                if (row == null)
+                {
+                    row = users.NewRow();
+                    fillUserRow(row, user);
+                    users.Rows.Add(row);
+                }
+                else
+                {
+                    fillUserRow(row, user);
+                    
+                }
+                // This is why we're getting the 'logins never log-off'..    because It isn't clearing the 
+                // useragents table once the useragent is null
+                //
+                // A database guy should look at this and figure out the best way to clear the useragents table.
+                if (user.currentAgent != null)
+                {
+                    DataTable ua = ds.Tables["useragents"];
+                    row = ua.Rows.Find(Util.ToRawUuidString(user.UUID));
+                    if (row == null)
+                    {
+                        row = ua.NewRow();
+                        fillUserAgentRow(row, user.currentAgent);
+                        ua.Rows.Add(row);
+                    }
+                    else
+                    {
+                        fillUserAgentRow(row, user.currentAgent);
+                    }
+                }
+                else
+                {
+                    // I just added this to help the standalone login situation.  
+                    //It still needs to be looked at by a Database guy
+                    DataTable ua = ds.Tables["useragents"];
+                    row = ua.Rows.Find(Util.ToRawUuidString(user.UUID));
+
+                    if (row == null)
+                    {
+                        // do nothing
+                    }
+                    else
+                    {
+                        row.Delete();
+                        ua.AcceptChanges();
+                    }
+                }
+
+                m_log.Info("[SQLITE]: " +
+                                         "Syncing user database: " + ds.Tables["users"].Rows.Count + " users stored");
+                // save changes off to disk
+                da.Update(ds, "users");
+            }
+        }
+
+        /// <summary>
+        /// Creates a new user profile
+        /// </summary>
+        /// <param name="user">The profile to add to the database</param>
+        /// <returns>True on success, false on error</returns>
+        override public bool UpdateUserProfile(UserProfileData user)
+        {
+            try
+            {
+                AddNewUserProfile(user);
+                return true;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new user agent
+        /// </summary>
+        /// <param name="agent">The agent to add to the database</param>
+        override public void AddNewUserAgent(UserAgentData agent)
+        {
+            // Do nothing. yet.
+        }
+
+        /// <summary>
+        /// Transfers money between two user accounts
+        /// </summary>
+        /// <param name="from">Starting account</param>
+        /// <param name="to">End account</param>
+        /// <param name="amount">The amount to move</param>
+        /// <returns>Success?</returns>
+        override public bool MoneyTransferRequest(LLUUID from, LLUUID to, uint amount)
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Transfers inventory between two accounts
+        /// </summary>
+        /// <remarks>Move to inventory server</remarks>
+        /// <param name="from">Senders account</param>
+        /// <param name="to">Receivers account</param>
+        /// <param name="item">Inventory item</param>
+        /// <returns>Success?</returns>
+        override public bool InventoryTransferRequest(LLUUID from, LLUUID to, LLUUID item)
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Returns the name of the storage provider
+        /// </summary>
+        /// <returns>Storage provider name</returns>
+        override public string getName()
+        {
+            return "Sqlite Userdata";
+        }
+
+        /// <summary>
+        /// Returns the version of the storage provider
+        /// </summary>
+        /// <returns>Storage provider version</returns>
+        override public string GetVersion()
+        {
+            return "0.1";
+        }
+
+        /***********************************************************************
+         *
+         *  DataTable creation 
+         *
+         **********************************************************************/
+        /***********************************************************************
+         *
+         *  Database Definition Functions
+         * 
+         *  This should be db agnostic as we define them in ADO.NET terms
+         *
+         **********************************************************************/
+
+        private static DataTable createUsersTable()
+        {
+            DataTable users = new DataTable("users");
+
+            SQLiteUtil.createCol(users, "UUID", typeof (String));
+            SQLiteUtil.createCol(users, "username", typeof (String));
+            SQLiteUtil.createCol(users, "surname", typeof (String));
+            SQLiteUtil.createCol(users, "passwordHash", typeof (String));
+            SQLiteUtil.createCol(users, "passwordSalt", typeof (String));
+
+            SQLiteUtil.createCol(users, "homeRegionX", typeof (Int32));
+            SQLiteUtil.createCol(users, "homeRegionY", typeof (Int32));
+            SQLiteUtil.createCol(users, "homeLocationX", typeof (Double));
+            SQLiteUtil.createCol(users, "homeLocationY", typeof (Double));
+            SQLiteUtil.createCol(users, "homeLocationZ", typeof (Double));
+            SQLiteUtil.createCol(users, "homeLookAtX", typeof (Double));
+            SQLiteUtil.createCol(users, "homeLookAtY", typeof (Double));
+            SQLiteUtil.createCol(users, "homeLookAtZ", typeof (Double));
+            SQLiteUtil.createCol(users, "created", typeof (Int32));
+            SQLiteUtil.createCol(users, "lastLogin", typeof (Int32));
+            SQLiteUtil.createCol(users, "rootInventoryFolderID", typeof (String));
+            SQLiteUtil.createCol(users, "userInventoryURI", typeof (String));
+            SQLiteUtil.createCol(users, "userAssetURI", typeof (String));
+            SQLiteUtil.createCol(users, "profileCanDoMask", typeof (Int32));
+            SQLiteUtil.createCol(users, "profileWantDoMask", typeof (Int32));
+            SQLiteUtil.createCol(users, "profileAboutText", typeof (String));
+            SQLiteUtil.createCol(users, "profileFirstText", typeof (String));
+            SQLiteUtil.createCol(users, "profileImage", typeof (String));
+            SQLiteUtil.createCol(users, "profileFirstImage", typeof (String));
+            SQLiteUtil.createCol(users, "webLoginKey", typeof(String));
+            // Add in contraints
+            users.PrimaryKey = new DataColumn[] {users.Columns["UUID"]};
+            return users;
+        }
+
+        private static DataTable createUserAgentsTable()
+        {
+            DataTable ua = new DataTable("useragents");
+            // this is the UUID of the user
+            SQLiteUtil.createCol(ua, "UUID", typeof (String));
+            SQLiteUtil.createCol(ua, "agentIP", typeof (String));
+            SQLiteUtil.createCol(ua, "agentPort", typeof (Int32));
+            SQLiteUtil.createCol(ua, "agentOnline", typeof (Boolean));
+            SQLiteUtil.createCol(ua, "sessionID", typeof (String));
+            SQLiteUtil.createCol(ua, "secureSessionID", typeof (String));
+            SQLiteUtil.createCol(ua, "regionID", typeof (String));
+            SQLiteUtil.createCol(ua, "loginTime", typeof (Int32));
+            SQLiteUtil.createCol(ua, "logoutTime", typeof (Int32));
+            SQLiteUtil.createCol(ua, "currentRegion", typeof (String));
+            SQLiteUtil.createCol(ua, "currentHandle", typeof (String));
+            // vectors
+            SQLiteUtil.createCol(ua, "currentPosX", typeof (Double));
+            SQLiteUtil.createCol(ua, "currentPosY", typeof (Double));
+            SQLiteUtil.createCol(ua, "currentPosZ", typeof (Double));
+            // constraints
+            ua.PrimaryKey = new DataColumn[] {ua.Columns["UUID"]};
+
+            return ua;
+        }
+
+        private static DataTable createUserFriendsTable()
+        {
+            DataTable ua = new DataTable("userfriends");
+            // table contains user <----> user relationship with perms
+            SQLiteUtil.createCol(ua, "ownerID", typeof(String));
+            SQLiteUtil.createCol(ua, "friendID", typeof(String));
+            SQLiteUtil.createCol(ua, "friendPerms", typeof(Int32));
+            SQLiteUtil.createCol(ua, "ownerPerms", typeof(Int32));
+            SQLiteUtil.createCol(ua, "datetimestamp", typeof(Int32));
+
+            return ua;
+        }
+
+        /***********************************************************************
+         *  
+         *  Convert between ADO.NET <=> OpenSim Objects
+         *
+         *  These should be database independant
+         *
+         **********************************************************************/
+
+        private static UserProfileData buildUserProfile(DataRow row)
+        {
+            // TODO: this doesn't work yet because something more
+            // interesting has to be done to actually get these values
+            // back out.  Not enough time to figure it out yet.
+            UserProfileData user = new UserProfileData();
+            LLUUID.TryParse((String)row["UUID"], out user.UUID);
+            user.username = (String) row["username"];
+            user.surname = (String) row["surname"];
+            user.passwordHash = (String) row["passwordHash"];
+            user.passwordSalt = (String) row["passwordSalt"];
+
+            user.homeRegionX = Convert.ToUInt32(row["homeRegionX"]);
+            user.homeRegionY = Convert.ToUInt32(row["homeRegionY"]);
+            user.homeLocation = new LLVector3(
+                Convert.ToSingle(row["homeLocationX"]),
+                Convert.ToSingle(row["homeLocationY"]),
+                Convert.ToSingle(row["homeLocationZ"])
+                );
+            user.homeLookAt = new LLVector3(
+                Convert.ToSingle(row["homeLookAtX"]),
+                Convert.ToSingle(row["homeLookAtY"]),
+                Convert.ToSingle(row["homeLookAtZ"])
+                );
+            user.created = Convert.ToInt32(row["created"]);
+            user.lastLogin = Convert.ToInt32(row["lastLogin"]);
+            user.rootInventoryFolderID = new LLUUID((String) row["rootInventoryFolderID"]);
+            user.userInventoryURI = (String) row["userInventoryURI"];
+            user.userAssetURI = (String) row["userAssetURI"];
+            user.profileCanDoMask = Convert.ToUInt32(row["profileCanDoMask"]);
+            user.profileWantDoMask = Convert.ToUInt32(row["profileWantDoMask"]);
+            user.profileAboutText = (String) row["profileAboutText"];
+            user.profileFirstText = (String) row["profileFirstText"];
+            LLUUID.TryParse((String)row["profileImage"], out user.profileImage);
+            LLUUID.TryParse((String)row["profileFirstImage"], out user.profileFirstImage);
+            user.webLoginKey = new LLUUID((String) row["webLoginKey"]);
+
+            return user;
+        }
+
+        private void fillUserRow(DataRow row, UserProfileData user)
+        {
+            row["UUID"] = Util.ToRawUuidString(user.UUID);
+            row["username"] = user.username;
+            row["surname"] = user.surname;
+            row["passwordHash"] = user.passwordHash;
+            row["passwordSalt"] = user.passwordSalt;
+
+
+            row["homeRegionX"] = user.homeRegionX;
+            row["homeRegionY"] = user.homeRegionY;
+            row["homeLocationX"] = user.homeLocation.X;
+            row["homeLocationY"] = user.homeLocation.Y;
+            row["homeLocationZ"] = user.homeLocation.Z;
+            row["homeLookAtX"] = user.homeLookAt.X;
+            row["homeLookAtY"] = user.homeLookAt.Y;
+            row["homeLookAtZ"] = user.homeLookAt.Z;
+
+            row["created"] = user.created;
+            row["lastLogin"] = user.lastLogin;
+            row["rootInventoryFolderID"] = user.rootInventoryFolderID;
+            row["userInventoryURI"] = user.userInventoryURI;
+            row["userAssetURI"] = user.userAssetURI;
+            row["profileCanDoMask"] = user.profileCanDoMask;
+            row["profileWantDoMask"] = user.profileWantDoMask;
+            row["profileAboutText"] = user.profileAboutText;
+            row["profileFirstText"] = user.profileFirstText;
+            row["profileImage"] = user.profileImage;
+            row["profileFirstImage"] = user.profileFirstImage;
+            row["webLoginKey"] = user.webLoginKey;
+
+            // ADO.NET doesn't handle NULL very well
+            foreach (DataColumn col in ds.Tables["users"].Columns)
+            {
+                if (row[col] == null)
+                {
+                    row[col] = String.Empty;
+                }
+            }
+        }
+
+        private static UserAgentData buildUserAgent(DataRow row)
+        {
+            UserAgentData ua = new UserAgentData();
+
+            ua.UUID = new LLUUID((String) row["UUID"]);
+            ua.agentIP = (String) row["agentIP"];
+            ua.agentPort = Convert.ToUInt32(row["agentPort"]);
+            ua.agentOnline = Convert.ToBoolean(row["agentOnline"]);
+            ua.sessionID = new LLUUID((String) row["sessionID"]);
+            ua.secureSessionID = new LLUUID((String) row["secureSessionID"]);
+            ua.regionID = new LLUUID((String) row["regionID"]);
+            ua.loginTime = Convert.ToInt32(row["loginTime"]);
+            ua.logoutTime = Convert.ToInt32(row["logoutTime"]);
+            ua.currentRegion = new LLUUID((String) row["currentRegion"]);
+            ua.currentHandle = Convert.ToUInt64(row["currentHandle"]);
+            ua.currentPos = new LLVector3(
+                Convert.ToSingle(row["currentPosX"]),
+                Convert.ToSingle(row["currentPosY"]),
+                Convert.ToSingle(row["currentPosZ"])
+                );
+            return ua;
+        }
+
+        private static void fillUserAgentRow(DataRow row, UserAgentData ua)
+        {
+            row["UUID"] = ua.UUID;
+            row["agentIP"] = ua.agentIP;
+            row["agentPort"] = ua.agentPort;
+            row["agentOnline"] = ua.agentOnline;
+            row["sessionID"] = ua.sessionID;
+            row["secureSessionID"] = ua.secureSessionID;
+            row["regionID"] = ua.regionID;
+            row["loginTime"] = ua.loginTime;
+            row["logoutTime"] = ua.logoutTime;
+            row["currentRegion"] = ua.currentRegion;
+            row["currentHandle"] = ua.currentHandle.ToString();
+            // vectors
+            row["currentPosX"] = ua.currentPos.X;
+            row["currentPosY"] = ua.currentPos.Y;
+            row["currentPosZ"] = ua.currentPos.Z;
+        }
+
+        /***********************************************************************
+         *
+         *  Database Binding functions
+         *
+         *  These will be db specific due to typing, and minor differences
+         *  in databases.
+         *
+         **********************************************************************/
+
+        private void setupUserCommands(SqliteDataAdapter da, SqliteConnection conn)
+        {
+            da.InsertCommand = SQLiteUtil.createInsertCommand("users", ds.Tables["users"]);
+            da.InsertCommand.Connection = conn;
+
+            da.UpdateCommand = SQLiteUtil.createUpdateCommand("users", "UUID=:UUID", ds.Tables["users"]);
+            da.UpdateCommand.Connection = conn;
+
+            SqliteCommand delete = new SqliteCommand("delete from users where UUID = :UUID");
+            delete.Parameters.Add(SQLiteUtil.createSqliteParameter("UUID", typeof(String)));
+            delete.Connection = conn;
+            da.DeleteCommand = delete;
+        }
+
+        private void setupUserFriendsCommands(SqliteDataAdapter daf, SqliteConnection conn)
+        {
+            daf.InsertCommand = SQLiteUtil.createInsertCommand("userfriends", ds.Tables["userfriends"]);
+            daf.InsertCommand.Connection = conn;
+
+            daf.UpdateCommand = SQLiteUtil.createUpdateCommand("userfriends", "ownerID=:ownerID and friendID=:friendID", ds.Tables["userfriends"]);
+            daf.UpdateCommand.Connection = conn;
+
+            SqliteCommand delete = new SqliteCommand("delete from userfriends where ownerID=:ownerID and friendID=:friendID");
+            delete.Parameters.Add(SQLiteUtil.createSqliteParameter("ownerID", typeof(String)));
+            delete.Parameters.Add(SQLiteUtil.createSqliteParameter("friendID", typeof(String)));
+            delete.Connection = conn;
+            daf.DeleteCommand = delete;
+
+        }
+
+        private void InitDB(SqliteConnection conn)
+        {
+            string createUsers = SQLiteUtil.defineTable(createUsersTable());
+            string createFriends = SQLiteUtil.defineTable(createUserFriendsTable());
+
+            SqliteCommand pcmd = new SqliteCommand(createUsers, conn);
+            SqliteCommand fcmd = new SqliteCommand(createFriends, conn);
+
+            conn.Open();
+
+            try
+            {
+
+                pcmd.ExecuteNonQuery();
+            }
+            catch (System.Exception)
+            {
+                m_log.Info("[USERS]: users table already exists");
+            }
+
+            try
+            {
+                fcmd.ExecuteNonQuery();
+            }
+            catch (System.Exception)
+            {
+                m_log.Info("[USERS]: userfriends table already exists");
+            }
+
+            conn.Close();
+        }
+
+        private bool TestTables(SqliteConnection conn)
+        {
+            SqliteCommand cmd = new SqliteCommand(userSelect, conn);
+            SqliteCommand fcmd = new SqliteCommand(userFriendsSelect, conn);
+            SqliteDataAdapter pDa = new SqliteDataAdapter(cmd);
+            SqliteDataAdapter fDa = new SqliteDataAdapter(cmd);
+
+            DataSet tmpDS = new DataSet();
+            DataSet tmpDS2 = new DataSet();
+
+            try
+            {
+                pDa.Fill(tmpDS, "users");
+                fDa.Fill(tmpDS2, "userfriends");
+            }
+            catch (SqliteSyntaxException)
+            {
+                m_log.Info("[DATASTORE]: SQLite Database doesn't exist... creating");
+                InitDB(conn);
+            }
+            conn.Open();
+            try
+            {
+                cmd = new SqliteCommand("select webLoginKey from users limit 1;", conn);
+                cmd.ExecuteNonQuery();
+            }
+            catch (SqliteSyntaxException)
+            {
+                cmd = new SqliteCommand("alter table users add column webLoginKey text default '00000000-0000-0000-0000-000000000000';", conn);
+                cmd.ExecuteNonQuery();
+                pDa.Fill(tmpDS, "users");
+            }
+            finally
+            {
+                conn.Close();
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/OpenSim/Data/SQLite/SQLiteUtils.cs b/OpenSim/Data/SQLite/SQLiteUtils.cs
new file mode 100644
index 0000000..1334e53
--- /dev/null
+++ b/OpenSim/Data/SQLite/SQLiteUtils.cs
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSim Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Data;
+using Mono.Data.SqliteClient;
+
+namespace OpenSim.Framework.Data.SQLite
+{
+    /// <summary>
+    /// A base class for methods needed by all SQLite database classes
+    /// </summary>
+    public class SQLiteUtil
+    {
+        /***********************************************************************
+         *
+         *  Database Definition Helper Functions
+         * 
+         *  This should be db agnostic as we define them in ADO.NET terms
+         *
+         **********************************************************************/
+
+        public static void createCol(DataTable dt, string name, Type type)
+        {
+            DataColumn col = new DataColumn(name, type);
+            dt.Columns.Add(col);
+        }
+
+        /***********************************************************************
+         *
+         *  SQL Statement Creation Functions
+         *
+         *  These functions create SQL statements for update, insert, and create.
+         *  They can probably be factored later to have a db independant
+         *  portion and a db specific portion
+         *
+         **********************************************************************/
+
+        public static SqliteCommand createInsertCommand(string table, DataTable dt)
+        {
+            /**
+             *  This is subtle enough to deserve some commentary.
+             *  Instead of doing *lots* and *lots of hardcoded strings
+             *  for database definitions we'll use the fact that
+             *  realistically all insert statements look like "insert
+             *  into A(b, c) values(:b, :c) on the parameterized query
+             *  front.  If we just have a list of b, c, etc... we can
+             *  generate these strings instead of typing them out.
+             */
+            string[] cols = new string[dt.Columns.Count];
+            for (int i = 0; i < dt.Columns.Count; i++)
+            {
+                DataColumn col = dt.Columns[i];
+                cols[i] = col.ColumnName;
+            }
+
+            string sql = "insert into " + table + "(";
+            sql += String.Join(", ", cols);
+            // important, the first ':' needs to be here, the rest get added in the join
+            sql += ") values (:";
+            sql += String.Join(", :", cols);
+            sql += ")";
+            SqliteCommand cmd = new SqliteCommand(sql);
+
+            // this provides the binding for all our parameters, so
+            // much less code than it used to be
+            foreach (DataColumn col in dt.Columns)
+            {
+                cmd.Parameters.Add(createSqliteParameter(col.ColumnName, col.DataType));
+            }
+            return cmd;
+        }
+
+        public static SqliteCommand createUpdateCommand(string table, string pk, DataTable dt)
+        {
+            string sql = "update " + table + " set ";
+            string subsql = String.Empty;
+            foreach (DataColumn col in dt.Columns)
+            {
+                if (subsql.Length > 0)
+                {
+                    // a map function would rock so much here
+                    subsql += ", ";
+                }
+                subsql += col.ColumnName + "= :" + col.ColumnName;
+            }
+            sql += subsql;
+            sql += " where " + pk;
+            SqliteCommand cmd = new SqliteCommand(sql);
+
+            // this provides the binding for all our parameters, so
+            // much less code than it used to be
+
+            foreach (DataColumn col in dt.Columns)
+            {
+                cmd.Parameters.Add(createSqliteParameter(col.ColumnName, col.DataType));
+            }
+            return cmd;
+        }
+
+
+        public static string defineTable(DataTable dt)
+        {
+            string sql = "create table " + dt.TableName + "(";
+            string subsql = String.Empty;
+            foreach (DataColumn col in dt.Columns)
+            {
+                if (subsql.Length > 0)
+                {
+                    // a map function would rock so much here
+                    subsql += ",\n";
+                }
+                subsql += col.ColumnName + " " + sqliteType(col.DataType);
+                if (dt.PrimaryKey.Length > 0)
+                {
+                    if (col == dt.PrimaryKey[0])
+                    {
+                        subsql += " primary key";
+                    }
+                }
+            }
+            sql += subsql;
+            sql += ")";
+            return sql;
+        }
+
+        /***********************************************************************
+         *
+         *  Database Binding functions
+         *
+         *  These will be db specific due to typing, and minor differences
+         *  in databases.
+         *
+         **********************************************************************/
+
+        ///<summary>
+        /// This is a convenience function that collapses 5 repetitive
+        /// lines for defining SqliteParameters to 2 parameters:
+        /// column name and database type.
+        ///        
+        /// It assumes certain conventions like :param as the param
+        /// name to replace in parametrized queries, and that source
+        /// version is always current version, both of which are fine
+        /// for us.
+        ///</summary>
+        ///<returns>a built sqlite parameter</returns>
+        public static SqliteParameter createSqliteParameter(string name, Type type)
+        {
+            SqliteParameter param = new SqliteParameter();
+            param.ParameterName = ":" + name;
+            param.DbType = dbtypeFromType(type);
+            param.SourceColumn = name;
+            param.SourceVersion = DataRowVersion.Current;
+            return param;
+        }
+
+        /***********************************************************************
+         *
+         *  Type conversion functions
+         *
+         **********************************************************************/
+
+        public static DbType dbtypeFromType(Type type)
+        {
+            if (type == typeof (String))
+            {
+                return DbType.String;
+            }
+            else if (type == typeof (Int32))
+            {
+                return DbType.Int32;
+            }
+            else if (type == typeof (UInt32))
+            {
+                return DbType.UInt32;
+            }
+            else if (type == typeof (Int64))
+            {
+                return DbType.Int64;
+            }
+            else if (type == typeof (UInt64))
+            {
+                return DbType.UInt64;
+            }
+            else if (type == typeof (Double))
+            {
+                return DbType.Double;
+            }
+            else if (type == typeof (Boolean))
+            {
+                return DbType.Boolean;
+            }
+            else if (type == typeof (Byte[]))
+            {
+                return DbType.Binary;
+            }
+            else
+            {
+                return DbType.String;
+            }
+        }
+
+        // this is something we'll need to implement for each db
+        // slightly differently.
+        public static string sqliteType(Type type)
+        {
+            if (type == typeof (String))
+            {
+                return "varchar(255)";
+            }
+            else if (type == typeof (Int32))
+            {
+                return "integer";
+            }
+            else if (type == typeof (UInt32))
+            {
+                return "integer";
+            }
+            else if (type == typeof (Int64))
+            {
+                return "varchar(255)";
+            }
+            else if (type == typeof (UInt64))
+            {
+                return "varchar(255)";
+            }
+            else if (type == typeof (Double))
+            {
+                return "float";
+            }
+            else if (type == typeof (Boolean))
+            {
+                return "integer";
+            }
+            else if (type == typeof (Byte[]))
+            {
+                return "blob";
+            }
+            else
+            {
+                return "string";
+            }
+        }
+    }
+}