* Added specialization of DatabaseMapper, DataReader and ObjectFieldMapper to support LLVector3, LLQuaternion and LLUUID

* Added PrimitiveBaseShapeTableMapper to show how it's done

NOTE: Nothing actually works yet - this code should be considered more of educational value until it's all wired together

OpenSim/Framework/Data.MySQL/MySQLDatabaseMapper.cs

@@ -0,0 +1,24 @@
+using System.Data.Common;
+using MySql.Data.MySqlClient;
+
+namespace OpenSim.Framework.Data.MySQL
+{
+    public class MySQLDatabaseMapper : OpenSimDatabaseMapper
+    {
+        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;
+        }
+    }
+}

OpenSim/Framework/Data/OpenSimDataReader.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Text;
+using libsecondlife;
+using TribalMedia.Framework.Data;
+
+namespace OpenSim.Framework.Data
+{
+    public class OpenSimDataReader : DataReader
+    {
+        public OpenSimDataReader(IDataReader source) : base(source)
+        {
+        }
+
+        public LLVector3 GetVector(string s)
+        {
+            float x = GetFloat(s + "X");
+            float y = GetFloat(s + "Y");
+            float z = GetFloat(s + "Z");
+
+            LLVector3 vector = new LLVector3(x, y, z);
+
+            return vector;
+        }
+
+        public LLQuaternion GetQuaternion(string s)
+        {
+            float x = GetFloat(s + "X");
+            float y = GetFloat(s + "Y");
+            float z = GetFloat(s + "Z");
+            float w = GetFloat(s + "W");
+
+            LLQuaternion quaternion = new LLQuaternion(x, y, z, w);
+
+            return quaternion;
+        }
+    }
+}

OpenSim/Framework/Data/OpenSimDatabaseMapper.cs

@@ -0,0 +1,23 @@
+using System.Data.Common;
+using libsecondlife;
+using TribalMedia.Framework.Data;
+
+namespace OpenSim.Framework.Data
+{
+    public abstract class OpenSimDatabaseMapper : DatabaseMapper
+    {
+        public OpenSimDatabaseMapper(string connectionString) : base(connectionString)
+        {
+        }
+
+        public override object ConvertToDbType(object value)
+        {
+            if (value is LLUUID)
+            {
+                return ((LLUUID) value).UUID.ToString();
+            }
+
+            return base.ConvertToDbType(value);
+        }
+    }
+}

OpenSim/Framework/Data/OpenSimObjectFieldMapper.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using libsecondlife;
+using TribalMedia.Framework.Data;
+
+namespace OpenSim.Framework.Data
+{
+    public class OpenSimObjectFieldMapper<TObject, TField> : ObjectField<TObject, TField>
+    {
+        public OpenSimObjectFieldMapper(TableMapper tableMapper, string fieldName,
+                                        ObjectGetAccessor<TObject, TField> rowMapperGetAccessor,
+                                        ObjectSetAccessor<TObject, TField> rowMapperSetAccessor)
+            : base(tableMapper, fieldName, rowMapperGetAccessor, rowMapperSetAccessor)
+        {
+        }
+
+        public override void ExpandField<TObj>(TObj obj, System.Data.Common.DbCommand command, List<string> fieldNames)
+        {
+            string fieldName = FieldName;
+            object value = GetParamValue(obj);
+
+            if (ValueType == typeof(LLVector3))
+            {
+                LLVector3 vector = (LLVector3)value;
+
+                RawAddParam(command, fieldNames, fieldName + "X", vector.X);
+                RawAddParam(command, fieldNames, fieldName + "Y", vector.Y);
+                RawAddParam(command, fieldNames, fieldName + "Z", vector.Z);
+            }
+            else if (ValueType == typeof(LLQuaternion))
+            {
+                LLQuaternion quaternion = (LLQuaternion)value;
+
+                RawAddParam(command, fieldNames, fieldName + "X", quaternion.X);
+                RawAddParam(command, fieldNames, fieldName + "Y", quaternion.Y);
+                RawAddParam(command, fieldNames, fieldName + "Z", quaternion.Z);
+                RawAddParam(command, fieldNames, fieldName + "W", quaternion.W);
+            }
+            else
+            {
+                base.ExpandField<TObj>(obj, command, fieldNames);
+            }
+        }
+
+        protected override object GetValue(DataReader reader)
+        {
+            object value;
+
+            OpenSimDataReader osreader = (OpenSimDataReader) reader;
+
+            if (ValueType == typeof(LLVector3))
+            {
+                value = osreader.GetVector(FieldName);
+            }
+            else if (ValueType == typeof(LLQuaternion))
+            {
+                value = osreader.GetQuaternion(FieldName);
+            }
+            else if (ValueType == typeof(LLUUID))
+            {
+                Guid guid = reader.GetGuid(FieldName);
+                value = new LLUUID(guid);
+            }
+            else
+            {
+                value = base.GetValue(reader);
+            }
+
+            return value;
+        }      
+    }
+}

OpenSim/Framework/Data/PrimitiveBaseShapeTableMapper.cs

@@ -0,0 +1,143 @@
+using System;
+using OpenSim.Framework;
+using TribalMedia.Framework.Data;
+using libsecondlife;
+
+namespace OpenSim.Framework.Data
+{
+    public class PrimitiveBaseShapeRowMapper : RowMapper<PrimitiveBaseShape>
+    {
+        public Guid SceneObjectPartId;
+
+        public PrimitiveBaseShapeRowMapper(Schema schema, PrimitiveBaseShape obj) : base(schema, obj)
+        {
+        }
+    }
+
+    public class PrimitiveBaseShapeTableMapper : ObjectTableMapper<PrimitiveBaseShapeRowMapper, Guid>
+    {
+        public PrimitiveBaseShapeTableMapper(DatabaseMapper connection, string tableName)
+            : base(connection, tableName)
+        {
+            RowMapperSchema<PrimitiveBaseShapeRowMapper> rowMapperSchema = new RowMapperSchema<PrimitiveBaseShapeRowMapper>(this);
+            m_schema = rowMapperSchema;
+
+            m_keyFieldMapper = rowMapperSchema.AddMapping<Guid>("SceneObjectPartId",
+                                                                delegate(PrimitiveBaseShapeRowMapper shape) { return shape.SceneObjectPartId; },
+                                                                delegate(PrimitiveBaseShapeRowMapper shape, Guid value) { shape.SceneObjectPartId = value; });
+
+            rowMapperSchema.AddMapping<byte>("PCode",
+                                             delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PCode; },
+                                             delegate(PrimitiveBaseShapeRowMapper shape, byte value) { shape.Object.PCode = value; });
+
+            rowMapperSchema.AddMapping<ushort>("PathBegin",
+                                               delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathBegin; },
+                                               delegate(PrimitiveBaseShapeRowMapper shape, ushort value) { shape.Object.PathBegin = value; });
+
+            rowMapperSchema.AddMapping<ushort>("PathEnd",
+                                               delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathEnd; },
+                                               delegate(PrimitiveBaseShapeRowMapper shape, ushort value) { shape.Object.PathEnd = value; });
+
+            rowMapperSchema.AddMapping<byte>("PathScaleX",
+                                             delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathScaleX; },
+                                             delegate(PrimitiveBaseShapeRowMapper shape, byte value) { shape.Object.PathScaleX = value; });
+
+            rowMapperSchema.AddMapping<byte>("PathScaleY",
+                                             delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathScaleY; },
+                                             delegate(PrimitiveBaseShapeRowMapper shape, byte value) { shape.Object.PathScaleY = value; });
+
+            rowMapperSchema.AddMapping<byte>("PathShearX",
+                                             delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathShearX; },
+                                             delegate(PrimitiveBaseShapeRowMapper shape, byte value) { shape.Object.PathShearX = value; });
+
+            rowMapperSchema.AddMapping<byte>("PathShearY",
+                                             delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathShearY; },
+                                             delegate(PrimitiveBaseShapeRowMapper shape, byte value) { shape.Object.PathShearY = value; });
+
+            rowMapperSchema.AddMapping<ushort>("ProfileBegin",
+                                               delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.ProfileBegin; },
+                                               delegate(PrimitiveBaseShapeRowMapper shape, ushort value) { shape.Object.ProfileBegin = value; });
+
+            rowMapperSchema.AddMapping<ushort>("ProfileEnd",
+                                               delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.ProfileEnd; },
+                                               delegate(PrimitiveBaseShapeRowMapper shape, ushort value) { shape.Object.ProfileEnd = value; });
+
+            rowMapperSchema.AddMapping<LLVector3>("Scale",
+                                                       delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.Scale; },
+                                                       delegate(PrimitiveBaseShapeRowMapper shape, LLVector3 value) { shape.Object.Scale = value; });
+
+            rowMapperSchema.AddMapping<sbyte>("PathTaperX",
+                                              delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathTaperX; },
+                                              delegate(PrimitiveBaseShapeRowMapper shape, sbyte value) { shape.Object.PathTaperX = value; });
+
+            rowMapperSchema.AddMapping<sbyte>("PathTaperY",
+                                              delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathTaperY; },
+                                              delegate(PrimitiveBaseShapeRowMapper shape, sbyte value) { shape.Object.PathTaperY = value; });
+
+            rowMapperSchema.AddMapping<sbyte>("PathTwist",
+                                              delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathTwist; },
+                                              delegate(PrimitiveBaseShapeRowMapper shape, sbyte value) { shape.Object.PathTwist = value; });
+
+            rowMapperSchema.AddMapping<sbyte>("PathRadiusOffset",
+                                              delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathRadiusOffset; },
+                                              delegate(PrimitiveBaseShapeRowMapper shape, sbyte value) { shape.Object.PathRadiusOffset = value; });
+
+            rowMapperSchema.AddMapping<byte>("PathRevolutions",
+                                             delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathRevolutions; },
+                                             delegate(PrimitiveBaseShapeRowMapper shape, byte value) { shape.Object.PathRevolutions = value; });
+
+            rowMapperSchema.AddMapping<sbyte>("PathTwistBegin",
+                                              delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathTwistBegin; },
+                                              delegate(PrimitiveBaseShapeRowMapper shape, sbyte value) { shape.Object.PathTwistBegin = value; });
+
+            rowMapperSchema.AddMapping<byte>("PathCurve",
+                                             delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.PathCurve; },
+                                             delegate(PrimitiveBaseShapeRowMapper shape, byte value) { shape.Object.PathCurve = value; });
+
+            rowMapperSchema.AddMapping<byte>("ProfileCurve",
+                                             delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.ProfileCurve; },
+                                             delegate(PrimitiveBaseShapeRowMapper shape, byte value) { shape.Object.ProfileCurve = value; });
+
+            rowMapperSchema.AddMapping<ushort>("ProfileHollow",
+                                               delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.ProfileHollow; },
+                                               delegate(PrimitiveBaseShapeRowMapper shape, ushort value) { shape.Object.ProfileHollow = value; });
+
+            rowMapperSchema.AddMapping<byte[]>("TextureEntry",
+                                               delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.TextureEntry; },
+                                               delegate(PrimitiveBaseShapeRowMapper shape, byte[] value) { shape.Object.TextureEntry = value; });
+
+            rowMapperSchema.AddMapping<byte[]>("ExtraParams",
+                                               delegate(PrimitiveBaseShapeRowMapper shape) { return shape.Object.ExtraParams; },
+                                               delegate(PrimitiveBaseShapeRowMapper shape, byte[] value) { shape.Object.ExtraParams = value; });            
+        }
+
+        public override PrimitiveBaseShapeRowMapper FromReader(DataReader reader)
+        {
+            PrimitiveBaseShape shape = new PrimitiveBaseShape();
+
+            PrimitiveBaseShapeRowMapper mapper = new PrimitiveBaseShapeRowMapper(m_schema, shape);
+            mapper.FillObject( reader );
+
+            return mapper;
+        }
+
+        public bool Update(Guid sceneObjectPartId, PrimitiveBaseShape primitiveBaseShape)
+        {
+            PrimitiveBaseShapeRowMapper mapper = CreateRowMapper(sceneObjectPartId, primitiveBaseShape);
+            return Update(sceneObjectPartId, mapper);
+        }
+
+        public bool Add(Guid sceneObjectPartId, PrimitiveBaseShape primitiveBaseShape)
+        {
+            PrimitiveBaseShapeRowMapper mapper = CreateRowMapper(sceneObjectPartId, primitiveBaseShape);
+            return Add(mapper);
+        }
+
+        private PrimitiveBaseShapeRowMapper CreateRowMapper(Guid sceneObjectPartId, PrimitiveBaseShape primitiveBaseShape)
+        {
+            PrimitiveBaseShapeRowMapper mapper = new PrimitiveBaseShapeRowMapper( m_schema, primitiveBaseShape );
+            mapper.SceneObjectPartId = sceneObjectPartId;
+            return mapper;
+        }
+    }
+}

ThirdParty/TribalMedia/TribalMedia.Framework.Data/DataReader.cs

@@ -61,29 +61,6 @@ namespace TribalMedia.Framework.Data
             return (sbyte) m_source.GetInt16(m_source.GetOrdinal(name));
         }
 
-        //public Vector3 GetVector(string s)
-        //{
-        //    float x = GetFloat(s + "X");
-        //    float y = GetFloat(s + "Y");
-        //    float z = GetFloat(s + "Z");
-
-        //    Vector3 vector = new Vector3(x, y, z);
-
-        //    return vector;
-        //}
-
-        //public Quaternion GetQuaternion(string s)
-        //{
-        //    float x = GetFloat(s + "X");
-        //    float y = GetFloat(s + "Y");
-        //    float z = GetFloat(s + "Z");
-        //    float w = GetFloat(s + "W");
-
-        //    Quaternion quaternion = new Quaternion(x, y, z, w);
-
-        //    return quaternion;
-        //}
-
         public float GetFloat(string name)
         {
             return m_source.GetFloat(m_source.GetOrdinal(name));
@@ -134,7 +111,7 @@ namespace TribalMedia.Framework.Data
             return m_source.Read();
         }
 
-        internal Guid GetGuid(string name)
+        public Guid GetGuid(string name)
         {
             string guidString = GetString(name);
             if (String.IsNullOrEmpty(guidString))

ThirdParty/TribalMedia/TribalMedia.Framework.Data/DatabaseMapper.cs

@@ -41,7 +41,6 @@ namespace TribalMedia.Framework.Data
         }
 
         public abstract DbConnection GetNewConnection();
-
         public abstract string CreateParamName(string fieldName);
 
         public DbCommand CreateSelectCommand(TableMapper mapper, DbConnection connection, string fieldName, object key)
@@ -67,7 +66,7 @@ namespace TribalMedia.Framework.Data
 
             DbParameter param = command.CreateParameter();
             param.ParameterName = keyFieldParamName;
-            param.Value = FieldMapper.ConvertToDbType(key);
+            param.Value = ConvertToDbType(key);
             command.Parameters.Add(param);
 
             return String.Format("{0}={1}", fieldName, keyFieldParamName);
@@ -131,5 +130,10 @@ namespace TribalMedia.Framework.Data
 
             return command;
         }
+
+        public virtual object ConvertToDbType(object value)
+        {
+            return value;
+        }
     }
 }

ThirdParty/TribalMedia/TribalMedia.Framework.Data/FieldMapper.cs

@@ -78,52 +78,18 @@ namespace TribalMedia.Framework.Data
             command.Parameters.Add(param);
         }
 
-        public void ExpandField<TObj>(TObj obj, DbCommand command, List<string> fieldNames)
+        public virtual void ExpandField<TObj>(TObj obj, DbCommand command, List<string> fieldNames)
         {
             string fieldName = FieldName;
             object value = GetParamValue(obj);
 
-            //if (ValueType == typeof (Vector3))
+            RawAddParam(command, fieldNames, fieldName, m_tableMapper.ConvertToDbType(value));
-            //{
-            //    Vector3 vector = (Vector3) value;
-
-            //    RawAddParam(command, fieldNames, fieldName + "X", vector.X);
-            //    RawAddParam(command, fieldNames, fieldName + "Y", vector.Y);
-            //    RawAddParam(command, fieldNames, fieldName + "Z", vector.Z);
-            //}
-            //else if (ValueType == typeof (Quaternion))
-            //{
-            //    Quaternion quaternion = (Quaternion) value;
-
-            //    RawAddParam(command, fieldNames, fieldName + "X", quaternion.X);
-            //    RawAddParam(command, fieldNames, fieldName + "Y", quaternion.Y);
-            //    RawAddParam(command, fieldNames, fieldName + "Z", quaternion.Z);
-            //    RawAddParam(command, fieldNames, fieldName + "W", quaternion.W);
-            //}
-            //else
-            //{
-                RawAddParam(command, fieldNames, fieldName, ConvertToDbType(value));
-            //}
         }
 
-        protected object GetValue(DataReader reader)
+        protected virtual object GetValue(DataReader reader)
         {
             object value;
-            //if (ValueType == typeof (Vector3))
+
-            //{
-            //    value = reader.GetVector(m_fieldName);
-            //}
-            //else if (ValueType == typeof (Quaternion))
-            //{
-            //    value = reader.GetQuaternion(m_fieldName);
-            //}
-            //else 
-            //if (ValueType == typeof(UID))
-            //{
-            //    Guid guid = reader.GetGuid(m_fieldName);
-            //    value = new UID(guid);
-            //}
-            //else 
             if (ValueType == typeof(Guid))
             {
                 value = reader.GetGuid(m_fieldName);
@@ -162,16 +128,6 @@ namespace TribalMedia.Framework.Data
 
             return value;
         }
-
-        public static object ConvertToDbType(object value)
-        {
-            //if (value is UID)
-            //{
-            //    return (value as UID).UUID.ToString();
-            //}
-
-            return value;
-        }
     }
 
     public class RowMapperField<TRowMapper, TField> : FieldMapper

ThirdParty/TribalMedia/TribalMedia.Framework.Data/ObjectTableMapper.cs

@@ -25,10 +25,8 @@
 */
 
 using System;
-using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
-using TribalMedia.Framework.Data;
 
 namespace TribalMedia.Framework.Data
 {

ThirdParty/TribalMedia/TribalMedia.Framework.Data/TableMapper.cs

@@ -62,13 +62,13 @@ namespace TribalMedia.Framework.Data
             get { return m_tableName; }
         }
 
-        private Schema m_schema;
+        protected Schema m_schema;
         public Schema Schema
         {
             get { return m_schema; }
         }
 
-        private FieldMapper m_keyFieldMapper;
+        protected FieldMapper m_keyFieldMapper;
         public FieldMapper KeyFieldMapper
         {
             get { return m_keyFieldMapper; }
@@ -104,5 +104,10 @@ namespace TribalMedia.Framework.Data
         {
             return m_connectionPool.CreateUpdateCommand(this, connection, rowMapper, primaryKey);
         }
+
+        public object ConvertToDbType(object value)
+        {
+            return m_connectionPool.ConvertToDbType(value);
+        }
     }
 }

prebuild.xml

@@ -118,6 +118,7 @@
       <Reference name="XMLRPC.dll"/>
       <Reference name="libsecondlife.dll"/>
       <Reference name="OpenSim.Framework"/>
+      <Reference name="TribalMedia.Framework.Data"/>
       <Files>
         <Match pattern="*.cs" recurse="true"/>
       </Files>
@@ -903,6 +904,7 @@
       <Reference name="System.Data"/>
       <Reference name="OpenSim.Framework"/>
       <Reference name="OpenSim.Framework.Data"/>
+      <Reference name="TribalMedia.Framework.Data"/>
       <Reference name="libsecondlife.dll"/>
       <Reference name="MySql.Data.dll"/>
       <Reference name="OpenSim.Framework.Console"/>