Initial update to OpenSim 0.8.2.1 source code.

1 files changed, 160 insertions, 25 deletions

diff --git a/OpenSim/Data/MSSQL/MSSQLManager.cs b/OpenSim/Data/PGSQL/PGSQLManager.cs
index 9a0015c..46f835a 100644
--- a/OpenSim/Data/MSSQL/MSSQLManager.cs
+++ b/OpenSim/Data/PGSQL/PGSQLManager.cs
@@ -28,18 +28,20 @@
 using System;
 using System.Collections.Generic;
 using System.Data;
-using System.Data.SqlClient;
 using System.IO;
 using System.Reflection;
+using OpenSim.Framework;
 using log4net;
 using OpenMetaverse;
+using Npgsql;
+using NpgsqlTypes;
 
-namespace OpenSim.Data.MSSQL
+namespace OpenSim.Data.PGSQL
 {
     /// <summary>
     /// A management class for the MS SQL Storage Engine
     /// </summary>
-    public class MSSQLManager
+    public class PGSQLManager
     {
 //        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
@@ -52,9 +54,37 @@ namespace OpenSim.Data.MSSQL
         /// Initialize the manager and set the connectionstring
         /// </summary>
         /// <param name="connection"></param>
-        public MSSQLManager(string connection)
+        public PGSQLManager(string connection)
         {
             connectionString = connection;
+            InitializeMonoSecurity();
+        }
+
+        public void InitializeMonoSecurity()
+        {
+            if (!Util.IsPlatformMono)
+            {
+                if (AppDomain.CurrentDomain.GetData("MonoSecurityPostgresAdded") == null)
+                {
+                    AppDomain.CurrentDomain.SetData("MonoSecurityPostgresAdded", "true");
+
+                    AppDomain currentDomain = AppDomain.CurrentDomain;
+                    currentDomain.AssemblyResolve += new ResolveEventHandler(ResolveEventHandlerMonoSec);
+                }
+            }
+        }
+
+        private System.Reflection.Assembly ResolveEventHandlerMonoSec(object sender, ResolveEventArgs args)
+        {
+            Assembly MyAssembly = null;
+
+            if (args.Name.Substring(0, args.Name.IndexOf(",")) == "Mono.Security")
+            {
+                MyAssembly = Assembly.LoadFrom("lib/NET/Mono.Security.dll");
+            }
+
+            //Return the loaded assembly.
+            return MyAssembly;
         }
 
         /// <summary>
@@ -62,54 +92,97 @@ namespace OpenSim.Data.MSSQL
         /// </summary>
         /// <param name="type"></param>
         /// <returns></returns>
-        internal SqlDbType DbtypeFromType(Type type)
+        internal NpgsqlDbType DbtypeFromType(Type type)
         {
             if (type == typeof(string))
             {
-                return SqlDbType.VarChar;
+                return NpgsqlDbType.Varchar;
             }
             if (type == typeof(double))
             {
-                return SqlDbType.Float;
+                return NpgsqlDbType.Double;
             }
             if (type == typeof(Single))
             {
-                return SqlDbType.Float;
+                return NpgsqlDbType.Double;
             }
             if (type == typeof(int))
             {
-                return SqlDbType.Int;
+                return NpgsqlDbType.Integer;
             }
             if (type == typeof(bool))
             {
-                return SqlDbType.Bit;
+                return NpgsqlDbType.Boolean;
             }
             if (type == typeof(UUID))
             {
-                return SqlDbType.UniqueIdentifier;
+                return NpgsqlDbType.Uuid;
+            }
+            if (type == typeof(byte))
+            {
+                return NpgsqlDbType.Smallint;
             }
             if (type == typeof(sbyte))
             {
-                return SqlDbType.Int;
+                return NpgsqlDbType.Integer;
             }
             if (type == typeof(Byte[]))
             {
-                return SqlDbType.Image;
+                return NpgsqlDbType.Bytea;
             }
             if (type == typeof(uint) || type == typeof(ushort))
             {
-                return SqlDbType.Int;
+                return NpgsqlDbType.Integer;
             }
             if (type == typeof(ulong))
             {
-                return SqlDbType.BigInt;
+                return NpgsqlDbType.Bigint;
             }
             if (type == typeof(DateTime))
             {
-                return SqlDbType.DateTime;
+                return NpgsqlDbType.Timestamp;
             }
 
-            return SqlDbType.VarChar;
+            return NpgsqlDbType.Varchar;
+        }
+
+        internal NpgsqlDbType DbtypeFromString(Type type, string PGFieldType)
+        {
+            if (PGFieldType == "")
+            {
+                return DbtypeFromType(type);
+            }
+
+            if (PGFieldType == "character varying")
+            {
+                return NpgsqlDbType.Varchar;
+            }
+            if (PGFieldType == "double precision")
+            {
+                return NpgsqlDbType.Double;
+            }
+            if (PGFieldType == "integer")
+            {
+                return NpgsqlDbType.Integer;
+            }
+            if (PGFieldType == "smallint")
+            {
+                return NpgsqlDbType.Smallint;
+            }
+            if (PGFieldType == "boolean")
+            {
+                return NpgsqlDbType.Boolean;
+            }
+            if (PGFieldType == "uuid")
+            {
+                return NpgsqlDbType.Uuid;
+            }
+            if (PGFieldType == "bytea")
+            {
+                return NpgsqlDbType.Bytea;
+            }
+
+            return DbtypeFromType(type);
         }
 
         /// <summary>
@@ -131,7 +204,7 @@ namespace OpenSim.Data.MSSQL
             }
             if (valueType == typeof(bool))
             {
-                return (bool)value ? 1 : 0;
+                return (bool)value;
             }
             if (valueType == typeof(Byte[]))
             {
@@ -145,12 +218,51 @@ namespace OpenSim.Data.MSSQL
         }
 
         /// <summary>
+        ///  Create value for parameter based on PGSQL Schema
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="PGFieldType"></param>
+        /// <returns></returns>
+        internal static object CreateParameterValue(object value, string PGFieldType)
+        {
+            if (PGFieldType == "uuid")
+            {
+                UUID uidout;
+                UUID.TryParse(value.ToString(), out uidout);
+                return uidout;
+            }
+            if (PGFieldType == "integer")
+            {
+                int intout;
+                int.TryParse(value.ToString(), out intout);
+                return intout;
+            }
+            if (PGFieldType == "boolean")
+            {
+                return (value.ToString() == "true");
+            }
+            if (PGFieldType == "timestamp with time zone")
+            {
+                return (DateTime)value;
+            }
+            if (PGFieldType == "timestamp without time zone")
+            {
+                return (DateTime)value;
+            }
+            if (PGFieldType == "double precision")
+            {
+                return (Double)value;
+            }
+            return CreateParameterValue(value);
+        }
+
+        /// <summary>
         /// Create a parameter for a command
         /// </summary>
         /// <param name="parameterName">Name of the parameter.</param>
         /// <param name="parameterObject">parameter object.</param>
         /// <returns></returns>
-        internal SqlParameter CreateParameter(string parameterName, object parameterObject)
+        internal NpgsqlParameter CreateParameter(string parameterName, object parameterObject)
         {
             return CreateParameter(parameterName, parameterObject, false);
         }
@@ -162,15 +274,15 @@ namespace OpenSim.Data.MSSQL
         /// <param name="parameterObject">parameter object.</param>
         /// <param name="parameterOut">if set to <c>true</c> parameter is a output parameter</param>
         /// <returns></returns>
-        internal SqlParameter CreateParameter(string parameterName, object parameterObject, bool parameterOut)
+        internal NpgsqlParameter CreateParameter(string parameterName, object parameterObject, bool parameterOut)
         {
-            //Tweak so we dont always have to add @ sign
-            if (!parameterName.StartsWith("@")) parameterName = "@" + parameterName;
+            //Tweak so we dont always have to add : sign
+            if (parameterName.StartsWith(":")) parameterName = parameterName.Replace(":","");
 
             //HACK if object is null, it is turned into a string, there are no nullable type till now
             if (parameterObject == null) parameterObject = "";
 
-            SqlParameter parameter = new SqlParameter(parameterName, DbtypeFromType(parameterObject.GetType()));
+            NpgsqlParameter parameter = new NpgsqlParameter(parameterName, DbtypeFromType(parameterObject.GetType()));
 
             if (parameterOut)
             {
@@ -186,16 +298,39 @@ namespace OpenSim.Data.MSSQL
         }
 
         /// <summary>
+        /// Create a parameter with PGSQL schema type
+        /// </summary>
+        /// <param name="parameterName"></param>
+        /// <param name="parameterObject"></param>
+        /// <param name="PGFieldType"></param>
+        /// <returns></returns>
+        internal NpgsqlParameter CreateParameter(string parameterName, object parameterObject, string PGFieldType)
+        {
+            //Tweak so we dont always have to add : sign
+            if (parameterName.StartsWith(":")) parameterName = parameterName.Replace(":", "");
+
+            //HACK if object is null, it is turned into a string, there are no nullable type till now
+            if (parameterObject == null) parameterObject = "";
+
+            NpgsqlParameter parameter = new NpgsqlParameter(parameterName, DbtypeFromString(parameterObject.GetType(), PGFieldType));
+
+            parameter.Direction = ParameterDirection.Input;
+            parameter.Value = CreateParameterValue(parameterObject, PGFieldType);
+
+            return parameter;
+        }
+
+        /// <summary>
         /// Checks if we need to do some migrations to the database
         /// </summary>
         /// <param name="migrationStore">migrationStore.</param>
         public void CheckMigration(string migrationStore)
         {
-            using (SqlConnection connection = new SqlConnection(connectionString)) 
+            using (NpgsqlConnection connection = new NpgsqlConnection(connectionString)) 
             {
                 connection.Open();
                 Assembly assem = GetType().Assembly;
-                MSSQLMigration migration = new MSSQLMigration(connection, assem, migrationStore);
+                PGSQLMigration migration = new PGSQLMigration(connection, assem, migrationStore);
 
                 migration.Update();
             }