OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* 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
ThreadPoolClientBranch
lbsa71 2008-01-14 22:34:19 +00:00
parent b49ae37e89
commit 6d751411b7
11 changed files with 322 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
OpenSim/Framework/Data.MySQL/MySQLDatabaseMapper.cs Normal file
View File

@ -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;
}
}
}

39
OpenSim/Framework/Data/OpenSimDataReader.cs Normal file
View File

@ -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;
}
}
}

23
OpenSim/Framework/Data/OpenSimDatabaseMapper.cs Normal file
View File

@ -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);
}
}
}

73
OpenSim/Framework/Data/OpenSimObjectFieldMapper.cs Normal file
View File

@ -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;
}
}
}

143
OpenSim/Framework/Data/PrimitiveBaseShapeTableMapper.cs Normal file
View File

@ -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;
}
}
}

25
ThirdParty/TribalMedia/TribalMedia.Framework.Data/DataReader.cs vendored
View File

@ -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))

8
ThirdParty/TribalMedia/TribalMedia.Framework.Data/DatabaseMapper.cs vendored
View File

@ -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;
}
}
}

52
ThirdParty/TribalMedia/TribalMedia.Framework.Data/FieldMapper.cs vendored
View File

@ -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))
//{
// 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));
//}
RawAddParam(command, fieldNames, fieldName, m_tableMapper.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

2
ThirdParty/TribalMedia/TribalMedia.Framework.Data/ObjectTableMapper.cs vendored
View File

@ -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
{

9
ThirdParty/TribalMedia/TribalMedia.Framework.Data/TableMapper.cs vendored
View File

@ -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);
}
}
}

2
prebuild.xml
View File

@ -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"/>