2002-11-26 Tim Coleman <tim@timcoleman.com>

        * Mono.Data.SybaseClient.build:
                Copy dll into Test directory.
        * Mono.Data.SybaseClient/SybaseCommand.cs:
        * Mono.Data.SybaseClient/SybaseConnection.cs:
        * Mono.Data.SybaseClient/SybaseParameter.cs:
        * Mono.Data.SybaseClient/SybaseParameterCollection.cs:
        * Mono.Data.SybaseClient/SybaseTransaction.cs:
                Many changes around making PREPAREs work in
                Sybase as well as SQL Server.

svn path=/trunk/mcs/; revision=9195

7 files changed, 203 insertions, 339 deletions

diff --git a/mcs/class/Mono.Data.SybaseClient/ChangeLog b/mcs/class/Mono.Data.SybaseClient/ChangeLog
index fb2cc33b8b2..69130fe756b 100644
--- a/mcs/class/Mono.Data.SybaseClient/ChangeLog
+++ b/mcs/class/Mono.Data.SybaseClient/ChangeLog
@@ -1,3 +1,14 @@
+2002-11-26  Tim Coleman <tim@timcoleman.com>
+	* Mono.Data.SybaseClient.build:
+		Copy dll into Test directory.
+	* Mono.Data.SybaseClient/SybaseCommand.cs:
+	* Mono.Data.SybaseClient/SybaseConnection.cs:
+	* Mono.Data.SybaseClient/SybaseParameter.cs:
+	* Mono.Data.SybaseClient/SybaseParameterCollection.cs:
+	* Mono.Data.SybaseClient/SybaseTransaction.cs:
+		Many changes around making PREPAREs work in
+		Sybase as well as SQL Server.
+
 2002-11-21  Tim Coleman <tim@timcoleman.com>
 	* Mono.Data.SybaseClient.build:
 	* Mono.Data.SybaseClient/SybaseCommand.cs:
diff --git a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient.build b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient.build
index b5435f230d6..56b8311df16 100644
--- a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient.build
+++ b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient.build
@@ -33,6 +33,7 @@
 				<includes name="../lib/Mono.Data.Tds.dll"/>
 			</references>
 		</csc>
+		<copy file="../lib/Mono.Data.SybaseClient.dll" tofile="Test/Mono.Data.SybaseClient.dll"/>
 	</target>
 	<target name="test" depends="build">
 		<nant basedir="Test" target="test"/>
diff --git a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseCommand.cs b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseCommand.cs
index eb4098673c7..66cc5c14f17 100644
--- a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseCommand.cs
+++ b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseCommand.cs
@@ -11,6 +11,7 @@
 // Copyright (C) Tim Coleman, 2002
 //
 
+using Mono.Data.Tds;
 using Mono.Data.Tds.Protocol;
 using System;
 using System.Collections;
@@ -20,7 +21,6 @@ using System.Data;
 using System.Data.Common;
 using System.Runtime.InteropServices;
 using System.Text;
-using System.Xml;
 
 namespace Mono.Data.SybaseClient {
 	public sealed class SybaseCommand : Component, IDbCommand, ICloneable
@@ -28,19 +28,16 @@ namespace Mono.Data.SybaseClient {
 		#region Fields
 
 		bool disposed = false;
-
 		int commandTimeout;
 		bool designTimeVisible;
 		string commandText;
-
 		CommandType commandType;
 		SybaseConnection connection;
 		SybaseTransaction transaction;
 		UpdateRowSource updatedRowSource;
-
 		CommandBehavior behavior = CommandBehavior.Default;
-		NameValueCollection preparedStatements = new NameValueCollection ();
 		SybaseParameterCollection parameters;
+		string preparedStatement = null;
 
 		#endregion // Fields
 
@@ -86,7 +83,11 @@ namespace Mono.Data.SybaseClient {
 
 		public string CommandText {
 			get { return commandText; }
-			set { commandText = value; }
+			set { 
+				if (value != commandText && preparedStatement != null)
+					Unprepare ();
+				commandText = value; 
+			}
 		}
 
 		public int CommandTimeout {
@@ -166,132 +167,6 @@ namespace Mono.Data.SybaseClient {
 
 		#region Methods
 
-		private string BuildCommand ()
-		{
-			string statementHandle = preparedStatements [commandText];
-			if (statementHandle != null) {
-				string proc = String.Format ("sp_execute {0}", statementHandle);	
-				if (parameters.Count > 0)
-					proc += ",";
-				return BuildProcedureCall (proc, parameters);
-			}
-
-			if (commandType == CommandType.StoredProcedure)
-				return BuildProcedureCall (commandText, parameters);
-
-			string sql = String.Empty;
-			if ((behavior & CommandBehavior.KeyInfo) > 0)
-				sql += "SET FMTONLY OFF; SET NO_BROWSETABLE ON;";
-			if ((behavior & CommandBehavior.SchemaOnly) > 0)
-				sql += "SET FMTONLY ON;";
-	
-			switch (commandType) {
-			case CommandType.Text :
-				sql += commandText;
-				break;
-			default:
-				throw new InvalidOperationException ("The CommandType was invalid.");
-			}
-			return BuildExec (sql);
-		}
-
-		[MonoTODO ("This throws a SybaseException.")]
-		private string BuildExec (string sql)
-		{
-			StringBuilder declare = new StringBuilder ();
-			StringBuilder assign = new StringBuilder ();
-
-			sql = sql.Replace ("'", "''");
-			foreach (SybaseParameter parameter in parameters) {
-				declare.Append ("declare ");
-				declare.Append (parameter.Prepare (parameter.ParameterName));
-				if (parameter.Direction == ParameterDirection.Output)
-					declare.Append (" output");
-				declare.Append ('\n');
-				assign.Append (String.Format ("select {0}={1}\n", parameter.ParameterName, FormatParameter (parameter)));
-			}
-
-			return String.Format ("{0}{1}{2}", declare.ToString (), assign.ToString (), sql);
-		}
-
-		private string BuildPrepare ()
-		{
-			StringBuilder parms = new StringBuilder ();
-			foreach (SybaseParameter parameter in parameters) {
-				if (parms.Length > 0)
-					parms.Append (", ");
-				parms.Append (parameter.Prepare (parameter.ParameterName));
-				if (parameter.Direction == ParameterDirection.Output)
-					parms.Append (" output");
-			}
-
-			SybaseParameterCollection localParameters = new SybaseParameterCollection (this);
-			SybaseParameter parm;
-		
-			parm = new SybaseParameter ("@P1", SybaseType.Int);
-			parm.Direction = ParameterDirection.Output;
-			localParameters.Add (parm);
-
-			parm = new SybaseParameter ("@P2", SybaseType.NVarChar);
-			parm.Value = parms.ToString ();
-			parm.Size = ((string) parm.Value).Length;
-			localParameters.Add (parm);
-
-			parm = new SybaseParameter ("@P3", SybaseType.NVarChar);
-			parm.Value = commandText;
-			parm.Size = ((string) parm.Value).Length;
-			localParameters.Add (parm);
-
-			return BuildProcedureCall ("sp_prepare", localParameters);
-		}
-
-		private static string BuildProcedureCall (string procedure, SybaseParameterCollection parameters)
-		{
-			StringBuilder parms = new StringBuilder ();
-			StringBuilder declarations = new StringBuilder ();
-			StringBuilder outParms = new StringBuilder ();
-			StringBuilder set = new StringBuilder ();
-
-			int index = 1;
-			foreach (SybaseParameter parameter in parameters) {
-				string parmName = String.Format ("@P{0}", index);
-
-				switch (parameter.Direction) {
-				case ParameterDirection.Input :
-					if (parms.Length > 0)
-						parms.Append (", ");
-					parms.Append (FormatParameter (parameter));
-					break;
-				case ParameterDirection.Output :
-					if (parms.Length > 0)
-						parms.Append (", ");
-					parms.Append (parmName);
-					parms.Append (" output");
-
-					if (outParms.Length > 0) {
-						outParms.Append (", ");
-						declarations.Append (", ");
-					}
-					else {
-						outParms.Append ("select ");
-						declarations.Append ("declare ");
-					}
-
-					declarations.Append (parameter.Prepare (parmName));
-					set.Append (String.Format ("set {0}=NULL\n", parmName));
-					outParms.Append (parmName);
-					break;
-				default :
-					throw new NotImplementedException ("Only support input and output parameters.");
-				}
-				index += 1;
-			}
-			if (declarations.Length > 0)
-				declarations.Append ('\n');
-
-			return String.Format ("{0}{1}{2} {3}\n{4}", declarations.ToString (), set.ToString (), procedure, parms.ToString (), outParms.ToString ());
-		}
-
 		public void Cancel () 
 		{
 			if (Connection == null || Connection.Tds == null)
@@ -322,7 +197,10 @@ namespace Mono.Data.SybaseClient {
 			SybaseParameterCollection localParameters = new SybaseParameterCollection (this);
 			localParameters.Add ("@P1", SybaseType.NVarChar, commandText.Length).Value = commandText;
 
-			Connection.Tds.ExecuteQuery (BuildProcedureCall ("sp_procedure_params_rowset", localParameters));
+			string sql = "sp_procedure_params_rowset";
+
+			Connection.Tds.ExecProc (sql, localParameters.MetaParameters, 0, true);
+
 			SybaseDataReader reader = new SybaseDataReader (this);
 			parameters.Clear ();
 			object[] dbValues = new object[reader.FieldCount];
@@ -334,19 +212,52 @@ namespace Mono.Data.SybaseClient {
 			reader.Close ();	
 		}
 
+		private void Execute (CommandBehavior behavior, bool wantResults)
+		{
+			TdsMetaParameterCollection parms = Parameters.MetaParameters;
+			if (preparedStatement == null) {
+				bool schemaOnly = ((CommandBehavior & CommandBehavior.SchemaOnly) > 0);
+				bool keyInfo = ((CommandBehavior & CommandBehavior.SchemaOnly) > 0);
+
+				StringBuilder sql1 = new StringBuilder ();
+				StringBuilder sql2 = new StringBuilder ();
+
+				if (schemaOnly || keyInfo)
+					sql1.Append ("SET FMTONLY OFF;");
+				if (keyInfo) {
+					sql1.Append ("SET NO_BROWSETABLE ON;");
+					sql2.Append ("SET NO_BROWSETABLE OFF;");
+				}
+				if (schemaOnly) {
+					sql1.Append ("SET FMTONLY ON;");
+					sql2.Append ("SET FMTONLY OFF;");
+				}
+
+				switch (CommandType) {
+				case CommandType.StoredProcedure:
+					if (keyInfo || schemaOnly)
+						Connection.Tds.Execute (sql1.ToString ());
+					Connection.Tds.ExecProc (CommandText, parms, CommandTimeout, wantResults);
+					if (keyInfo || schemaOnly)
+						Connection.Tds.Execute (sql2.ToString ());
+					break;
+				case CommandType.Text:
+					string sql = String.Format ("{0}{1}{2}", sql1.ToString (), CommandText, sql2.ToString ());
+					Connection.Tds.Execute (sql, parms, CommandTimeout, wantResults);
+					break;
+				}
+			}
+			else 
+				Connection.Tds.ExecPrepared (preparedStatement, parms, CommandTimeout, wantResults);
+		}
+
 		public int ExecuteNonQuery ()
 		{
 			ValidateCommand ("ExecuteNonQuery");
-			string sql = String.Empty;
 			int result = 0;
 
-			if (Parameters.Count > 0)
-				sql = BuildCommand ();
-			else
-				sql = CommandText;
-
 			try {
-				result = Connection.Tds.ExecuteNonQuery (sql, CommandTimeout);
+				Execute (CommandBehavior.Default, false);
 			}
 			catch (TdsTimeoutException e) {
 				throw SybaseException.FromTdsInternalException ((TdsInternalException) e);
@@ -364,15 +275,12 @@ namespace Mono.Data.SybaseClient {
 		public SybaseDataReader ExecuteReader (CommandBehavior behavior)
 		{
 			ValidateCommand ("ExecuteReader");
-			this.behavior = behavior;
-
 			try {
-				Connection.Tds.ExecuteQuery (BuildCommand (), CommandTimeout);
+				Execute (behavior, true);
 			}
 			catch (TdsTimeoutException e) {
 				throw SybaseException.FromTdsInternalException ((TdsInternalException) e);
 			}
-		
 			Connection.DataReader = new SybaseDataReader (this);
 			return Connection.DataReader;
 		}
@@ -381,7 +289,7 @@ namespace Mono.Data.SybaseClient {
 		{
 			ValidateCommand ("ExecuteScalar");
 			try {
-				Connection.Tds.ExecuteQuery (BuildCommand (), CommandTimeout);
+				Execute (CommandBehavior.Default, true);
 			}
 			catch (TdsTimeoutException e) {
 				throw SybaseException.FromTdsInternalException ((TdsInternalException) e);
@@ -395,41 +303,6 @@ namespace Mono.Data.SybaseClient {
 			return result;
 		}
 
-		[MonoTODO ("Include offset from SybaseParameter for binary/string types.")]
-		static string FormatParameter (SybaseParameter parameter)
-		{
-			if (parameter.Value == null)
-				return "NULL";
-
-			switch (parameter.SybaseType) {
-				case SybaseType.BigInt :
-				case SybaseType.Decimal :
-				case SybaseType.Float :
-				case SybaseType.Int :
-				case SybaseType.Money :
-				case SybaseType.Real :
-				case SybaseType.SmallInt :
-				case SybaseType.SmallMoney :
-				case SybaseType.TinyInt :
-					return parameter.Value.ToString ();
-				case SybaseType.NVarChar :
-				case SybaseType.NChar :
-					return String.Format ("N'{0}'", parameter.Value.ToString ().Replace ("'", "''"));
-				case SybaseType.UniqueIdentifier :
-					return String.Format ("0x{0}", ((Guid) parameter.Value).ToString ("N"));
-				case SybaseType.Bit:
-					if (parameter.Value.GetType () == typeof (bool))
-						return (((bool) parameter.Value) ? "0x1" : "0x0");
-					return parameter.Value.ToString ();
-				case SybaseType.Image:
-				case SybaseType.Binary:
-				case SybaseType.VarBinary:
-					return String.Format ("0x{0}", BitConverter.ToString ((byte[]) parameter.Value).Replace ("-", "").ToLower ());
-				default:
-					return String.Format ("'{0}'", parameter.Value.ToString ().Replace ("'", "''"));
-			}
-		}
-
 		private void GetOutputParameters ()
 		{
 			Connection.Tds.SkipToEnd ();
@@ -472,12 +345,8 @@ namespace Mono.Data.SybaseClient {
 		public void Prepare ()
 		{
 			ValidateCommand ("Prepare");
-			Connection.Tds.ExecuteNonQuery (BuildPrepare ());
-
-			if (Connection.Tds.OutputParameters.Count == 0 || Connection.Tds.OutputParameters[0] == null)
-				throw new Exception ("Could not prepare the statement.");
-
-			preparedStatements [commandText] = ((int) Connection.Tds.OutputParameters [0]).ToString ();
+			if (CommandType == CommandType.Text) 
+				preparedStatement = Connection.Tds.Prepare (CommandText, Parameters.MetaParameters);
 		}
 
 		public void ResetCommandTimeout ()
@@ -485,6 +354,12 @@ namespace Mono.Data.SybaseClient {
 			commandTimeout = 30;
 		}
 
+		private void Unprepare ()
+		{
+			Connection.Tds.Unprepare (preparedStatement); 
+			preparedStatement = null;
+		}
+
 		private void ValidateCommand (string method)
 		{
 			if (Connection == null)
diff --git a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseConnection.cs b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseConnection.cs
index 20bba7c25c4..08a88e73666 100644
--- a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseConnection.cs
+++ b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseConnection.cs
@@ -182,7 +182,7 @@ namespace Mono.Data.SybaseClient {
 				break;
 			}
 
-			tds.ExecuteNonQuery (String.Format ("SET TRANSACTION ISOLATION LEVEL {0};BEGIN TRANSACTION {1}", isolevel, transactionName));
+			tds.Execute (String.Format ("SET TRANSACTION ISOLATION LEVEL {0}\nBEGIN TRANSACTION {1}", isolevel, transactionName));
 			transaction = new SybaseTransaction (this, iso);
 			return transaction;
 		}
@@ -193,7 +193,7 @@ namespace Mono.Data.SybaseClient {
 				throw new ArgumentException (String.Format ("The database name {0} is not valid."));
 			if (State != ConnectionState.Open)
 				throw new InvalidOperationException ("The connection is not open");
-			tds.ExecuteNonQuery (String.Format ("use {0}", database));
+			tds.Execute (String.Format ("use {0}", database));
 		}
 
 		private void ChangeState (ConnectionState currentState)
diff --git a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseParameter.cs b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseParameter.cs
index d271392e9bc..d4a72964fb1 100644
--- a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseParameter.cs
+++ b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseParameter.cs
@@ -10,6 +10,7 @@
 // Copyright (C) Tim Coleman, 2002
 //
 
+using Mono.Data.Tds;
 using Mono.Data.Tds.Protocol;
 using System;
 using System.ComponentModel;
@@ -23,22 +24,18 @@ namespace Mono.Data.SybaseClient {
 	{
 		#region Fields
 
+		TdsMetaParameter metaParameter;
+
 		SybaseParameterCollection container = null;
 		DbType dbType;
 		ParameterDirection direction = ParameterDirection.Input;
 		bool isNullable;
 		bool isSizeSet = false;
 		bool isTypeSet = false;
-		object objValue;
 		int offset;
-		string parameterName;
-		byte precision;
-		byte scale;
-		int size;
-		SybaseType sqlDbType;
+		SybaseType sybaseType;
 		string sourceColumn;
 		DataRowVersion sourceVersion;
-		string typeName;
 
 		#endregion // Fields
 
@@ -51,10 +48,9 @@ namespace Mono.Data.SybaseClient {
 
 		public SybaseParameter (string parameterName, object value) 
 		{
-			this.parameterName = parameterName;
-			this.objValue = value;
+			metaParameter = new TdsMetaParameter (parameterName, value);
 			this.sourceVersion = DataRowVersion.Current;
-			InferSqlType (value);
+			InferSybaseType (value);
 		}
 		
 		public SybaseParameter (string parameterName, SybaseType dbType) 
@@ -72,17 +68,13 @@ namespace Mono.Data.SybaseClient {
 		{
 		}
 		
+		[EditorBrowsable (EditorBrowsableState.Advanced)]	 
 		public SybaseParameter (string parameterName, SybaseType dbType, int size, ParameterDirection direction, bool isNullable, byte precision, byte scale, string sourceColumn, DataRowVersion sourceVersion, object value) 
 		{
-			SybaseType = dbType;
-			Size = size;
-			Value = value;
+			metaParameter = new TdsMetaParameter (parameterName, size, isNullable, precision, scale, value);
 
-			ParameterName = parameterName;
+			SybaseType = dbType;
 			Direction = direction;
-			IsNullable = isNullable;
-			Precision = precision;
-			Scale = scale;
 			SourceColumn = sourceColumn;
 			SourceVersion = sourceVersion;
 		}
@@ -92,33 +84,33 @@ namespace Mono.Data.SybaseClient {
 		// This is in SybaseCommand.DeriveParameters.
 		internal SybaseParameter (object[] dbValues)
 		{
-			precision = 0;
-			scale = 0;
-			direction = ParameterDirection.Input;
+			Precision = 0;
+			Scale = 0;
+			Direction = ParameterDirection.Input;
 
-			parameterName = (string) dbValues[3];
+			ParameterName = (string) dbValues[3];
 
 			switch ((short) dbValues[5]) {
 			case 1:
-				direction = ParameterDirection.Input;
+				Direction = ParameterDirection.Input;
 				break;
 			case 2:
-				direction = ParameterDirection.Output;
+				Direction = ParameterDirection.Output;
 				break;
 			case 3:
-				direction = ParameterDirection.InputOutput;
+				Direction = ParameterDirection.InputOutput;
 				break;
 			case 4:
-				direction = ParameterDirection.ReturnValue;
+				Direction = ParameterDirection.ReturnValue;
 				break;
 			}
 
-			isNullable = (bool) dbValues[8];
+			IsNullable = (bool) dbValues[8];
 
 			if (dbValues[12] != null)
-				precision = (byte) ((short) dbValues[12]);
+				Precision = (byte) ((short) dbValues[12]);
 			if (dbValues[13] != null)
-				scale = (byte) ((short) dbValues[13]);
+				Scale = (byte) ((short) dbValues[13]);
 
 			SetDbTypeName ((string) dbValues[16]);
 		}
@@ -144,17 +136,25 @@ namespace Mono.Data.SybaseClient {
 
 		public ParameterDirection Direction {
 			get { return direction; }
-			set { direction = value; }
+			set { 
+				direction = value; 
+				if (direction == ParameterDirection.Output)
+					MetaParameter.Direction = TdsParameterDirection.Output;
+			}
+		}
+
+		internal TdsMetaParameter MetaParameter {
+			get { return metaParameter; }
 		}
 
 		string IDataParameter.ParameterName {
-			get { return parameterName; }
-			set { parameterName = value; }
+			get { return metaParameter.ParameterName; }
+			set { metaParameter.ParameterName = value; }
 		}
 
 		public bool IsNullable	{
-			get { return isNullable; }
-			set { isNullable = value; }
+			get { return metaParameter.IsNullable; }
+			set { metaParameter.IsNullable = value; }
 		}
 
 		public int Offset {
@@ -163,26 +163,23 @@ namespace Mono.Data.SybaseClient {
 		}
 		
 		public string ParameterName {
-			get { return parameterName; }
-			set { parameterName = value; }
+			get { return metaParameter.ParameterName; }
+			set { metaParameter.ParameterName = value; }
 		}
 
 		public byte Precision {
-			get { return precision; }
-			set { precision = value; }
+			get { return metaParameter.Precision; }
+			set { metaParameter.Precision = value; }
 		}
 
                 public byte Scale {
-			get { return scale; }
-			set { scale = value; }
+			get { return metaParameter.Scale; }
+			set { metaParameter.Scale = value; }
 		}
 
                 public int Size {
-			get { return size; }
-			set { 
-				size = value; 
-				isSizeSet = true;
-			}
+			get { return metaParameter.Size; }
+			set { metaParameter.Size = value; }
 		}
 
 		public string SourceColumn {
@@ -196,7 +193,7 @@ namespace Mono.Data.SybaseClient {
 		}
 		
 		public SybaseType SybaseType {
-			get { return sqlDbType; }
+			get { return sybaseType; }
 			set { 
 				SetSybaseType (value); 
 				isTypeSet = true;
@@ -204,11 +201,11 @@ namespace Mono.Data.SybaseClient {
 		}
 
 		public object Value {
-			get { return objValue; }
+			get { return metaParameter.Value; }
 			set { 
 				if (!isTypeSet)
-					InferSqlType (value);
-				objValue = value; 
+					InferSybaseType (value);
+				metaParameter.Value = value; 
 			}
 		}
 
@@ -223,7 +220,7 @@ namespace Mono.Data.SybaseClient {
 
 		// If the value is set without the DbType/SybaseType being set, then we
 		// infer type information.
-		private void InferSqlType (object value)
+		private void InferSybaseType (object value)
 		{
 			Type type = value.GetType ();
 
@@ -274,37 +271,6 @@ namespace Mono.Data.SybaseClient {
 			}
 		}
 
-		internal string Prepare (string name)
-		{
-			StringBuilder result = new StringBuilder ();
-			result.Append (name);
-			result.Append (" ");
-			result.Append (typeName);
-
-			switch (sqlDbType) {
-			case SybaseType.VarBinary :
-			case SybaseType.NVarChar :
-			case SybaseType.VarChar :
-				if (!isSizeSet || size == 0)
-					throw new InvalidOperationException ("All variable length parameters must have an explicitly set non-zero size.");
-				result.Append (String.Format ("({0})", size));
-				break;
-			case SybaseType.NChar :
-			case SybaseType.Char :
-			case SybaseType.Binary :
-				if (size > 0) 
-					result.Append (String.Format ("({0})", size));
-				break;
-			case SybaseType.Decimal :
-				result.Append (String.Format ("({0},{1})", precision, scale));
-				break;
-                        default:
-                                break;
-                        }
-
-                        return result.ToString ();
-		}
-
 		// When the DbType is set, we also set the SybaseType, as well as the SQL Server
 		// string representation of the type name.  If the DbType is not convertible
 		// to an SybaseType, throw an exception.
@@ -314,77 +280,77 @@ namespace Mono.Data.SybaseClient {
 
 			switch (type) {
 			case DbType.AnsiString:
-				typeName = "varchar";
-				sqlDbType = SybaseType.VarChar;
+				MetaParameter.TypeName = "varchar";
+				sybaseType = SybaseType.VarChar;
 				break;
 			case DbType.AnsiStringFixedLength:
-				typeName = "char";
-				sqlDbType = SybaseType.Char;
+				MetaParameter.TypeName = "char";
+				sybaseType = SybaseType.Char;
 				break;
 			case DbType.Binary:
-				typeName = "varbinary";
-				sqlDbType = SybaseType.VarBinary;
+				MetaParameter.TypeName = "varbinary";
+				sybaseType = SybaseType.VarBinary;
 				break;
 			case DbType.Boolean:
-				typeName = "bit";
-				sqlDbType = SybaseType.Bit;
+				MetaParameter.TypeName = "bit";
+				sybaseType = SybaseType.Bit;
 				break;
 			case DbType.Byte:
-				typeName = "tinyint";
-				sqlDbType = SybaseType.TinyInt;
+				MetaParameter.TypeName = "tinyint";
+				sybaseType = SybaseType.TinyInt;
 				break;
 			case DbType.Currency:
-				sqlDbType = SybaseType.Money;
-				typeName = "money";
+				sybaseType = SybaseType.Money;
+				MetaParameter.TypeName = "money";
 				break;
 			case DbType.Date:
 			case DbType.DateTime:
-				typeName = "datetime";
-				sqlDbType = SybaseType.DateTime;
+				MetaParameter.TypeName = "datetime";
+				sybaseType = SybaseType.DateTime;
 				break;
 			case DbType.Decimal:
-				typeName = "decimal";
-				sqlDbType = SybaseType.Decimal;
+				MetaParameter.TypeName = "decimal";
+				sybaseType = SybaseType.Decimal;
 				break;
 			case DbType.Double:
-				typeName = "float";
-				sqlDbType = SybaseType.Float;
+				MetaParameter.TypeName = "float";
+				sybaseType = SybaseType.Float;
 				break;
 			case DbType.Guid:
-				typeName = "uniqueidentifier";
-				sqlDbType = SybaseType.UniqueIdentifier;
+				MetaParameter.TypeName = "uniqueidentifier";
+				sybaseType = SybaseType.UniqueIdentifier;
 				break;
 			case DbType.Int16:
-				typeName = "smallint";
-				sqlDbType = SybaseType.SmallInt;
+				MetaParameter.TypeName = "smallint";
+				sybaseType = SybaseType.SmallInt;
 				break;
 			case DbType.Int32:
-				typeName = "int";
-				sqlDbType = SybaseType.Int;
+				MetaParameter.TypeName = "int";
+				sybaseType = SybaseType.Int;
 				break;
 			case DbType.Int64:
-				typeName = "bigint";
-				sqlDbType = SybaseType.BigInt;
+				MetaParameter.TypeName = "bigint";
+				sybaseType = SybaseType.BigInt;
 				break;
 			case DbType.Object:
-				typeName = "sql_variant";
-				sqlDbType = SybaseType.Variant;
+				MetaParameter.TypeName = "sql_variant";
+				sybaseType = SybaseType.Variant;
 				break;
 			case DbType.Single:
-				typeName = "real";
-				sqlDbType = SybaseType.Real;
+				MetaParameter.TypeName = "real";
+				sybaseType = SybaseType.Real;
 				break;
 			case DbType.String:
-				typeName = "nvarchar";
-				sqlDbType = SybaseType.NVarChar;
+				MetaParameter.TypeName = "nvarchar";
+				sybaseType = SybaseType.NVarChar;
 				break;
 			case DbType.StringFixedLength:
-				typeName = "nchar";
-				sqlDbType = SybaseType.NChar;
+				MetaParameter.TypeName = "nchar";
+				sybaseType = SybaseType.NChar;
 				break;
 			case DbType.Time:
-				typeName = "datetime";
-				sqlDbType = SybaseType.DateTime;
+				MetaParameter.TypeName = "datetime";
+				sybaseType = SybaseType.DateTime;
 				break;
 			default:
 				throw new ArgumentException (exception);
@@ -480,110 +446,110 @@ namespace Mono.Data.SybaseClient {
 
 			switch (type) {
 			case SybaseType.BigInt:
-				typeName = "bigint";
+				MetaParameter.TypeName = "bigint";
 				dbType = DbType.Int64;
 				break;
 			case SybaseType.Binary:
-				typeName = "binary";
+				MetaParameter.TypeName = "binary";
 				dbType = DbType.Binary;
 				break;
 			case SybaseType.Timestamp:
-				typeName = "timestamp";
+				MetaParameter.TypeName = "timestamp";
 				dbType = DbType.Binary;
 				break;
 			case SybaseType.VarBinary:
-				typeName = "varbinary";
+				MetaParameter.TypeName = "varbinary";
 				dbType = DbType.Binary;
 				break;
 			case SybaseType.Bit:
-				typeName = "bit";
+				MetaParameter.TypeName = "bit";
 				dbType = DbType.Boolean;
 				break;
 			case SybaseType.Char:
-				typeName = "char";
+				MetaParameter.TypeName = "char";
 				dbType = DbType.AnsiStringFixedLength;
 				break;
 			case SybaseType.DateTime:
-				typeName = "datetime";
+				MetaParameter.TypeName = "datetime";
 				dbType = DbType.DateTime;
 				break;
 			case SybaseType.SmallDateTime:
-				typeName = "smalldatetime";
+				MetaParameter.TypeName = "smalldatetime";
 				dbType = DbType.DateTime;
 				break;
 			case SybaseType.Decimal:
-				typeName = "decimal";
+				MetaParameter.TypeName = "decimal";
 				dbType = DbType.Decimal;
 				break;
 			case SybaseType.Float:
-				typeName = "float";
+				MetaParameter.TypeName = "float";
 				dbType = DbType.Double;
 				break;
 			case SybaseType.Image:
-				typeName = "image";
+				MetaParameter.TypeName = "image";
 				dbType = DbType.Binary;
 				break;
 			case SybaseType.Int:
-				typeName = "int";
+				MetaParameter.TypeName = "int";
 				dbType = DbType.Int32;
 				break;
 			case SybaseType.Money:
-				typeName = "money";
+				MetaParameter.TypeName = "money";
 				dbType = DbType.Currency;
 				break;
 			case SybaseType.SmallMoney:
-				typeName = "smallmoney";
+				MetaParameter.TypeName = "smallmoney";
 				dbType = DbType.Currency;
 				break;
 			case SybaseType.NChar:
-				typeName = "nchar";
+				MetaParameter.TypeName = "nchar";
 				dbType = DbType.StringFixedLength;
 				break;
 			case SybaseType.NText:
-				typeName = "ntext";
+				MetaParameter.TypeName = "ntext";
 				dbType = DbType.String;
 				break;
 			case SybaseType.NVarChar:
-				typeName = "nvarchar";
+				MetaParameter.TypeName = "nvarchar";
 				dbType = DbType.String;
 				break;
 			case SybaseType.Real:
-				typeName = "real";
+				MetaParameter.TypeName = "real";
 				dbType = DbType.Single;
 				break;
 			case SybaseType.SmallInt:
-				typeName = "smallint";
+				MetaParameter.TypeName = "smallint";
 				dbType = DbType.Int16;
 				break;
 			case SybaseType.Text:
-				typeName = "text";
+				MetaParameter.TypeName = "text";
 				dbType = DbType.AnsiString;
 				break;
 			case SybaseType.VarChar:
-				typeName = "varchar";
+				MetaParameter.TypeName = "varchar";
 				dbType = DbType.AnsiString;
 				break;
 			case SybaseType.TinyInt:
-				typeName = "tinyint";
+				MetaParameter.TypeName = "tinyint";
 				dbType = DbType.Byte;
 				break;
 			case SybaseType.UniqueIdentifier:
-				typeName = "uniqueidentifier";
+				MetaParameter.TypeName = "uniqueidentifier";
 				dbType = DbType.Guid;
 				break;
 			case SybaseType.Variant:
-				typeName = "sql_variant";
+				MetaParameter.TypeName = "sql_variant";
 				dbType = DbType.Object;
 				break;
 			default:
 				throw new ArgumentException (exception);
 			}
-			sqlDbType = type;
+			sybaseType = type;
 		}
 
 		public override string ToString() 
 		{
-			return parameterName;
+			return ParameterName;
 		}
 
 		#endregion // Methods
diff --git a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseParameterCollection.cs b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseParameterCollection.cs
index 6468a4d5302..853d859a9fe 100644
--- a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseParameterCollection.cs
+++ b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseParameterCollection.cs
@@ -10,6 +10,7 @@
 // Copyright (C) Tim Coleman, 2002
 //
 
+using Mono.Data.Tds;
 using System;
 using System.ComponentModel;
 using System.Data;
@@ -23,6 +24,7 @@ namespace Mono.Data.SybaseClient {
 		#region Fields
 
 		ArrayList list = new ArrayList();
+		TdsMetaParameterCollection metaParameters;
 		SybaseCommand command;
 
 		#endregion // Fields
@@ -32,6 +34,7 @@ namespace Mono.Data.SybaseClient {
 		internal SybaseParameterCollection (SybaseCommand command)
 		{
 			this.command = command;
+			metaParameters = new TdsMetaParameterCollection ();
 		}
 
 		#endregion // Constructors
@@ -90,6 +93,10 @@ namespace Mono.Data.SybaseClient {
 		object ICollection.SyncRoot {
 			get { return list.SyncRoot; }
 		}
+
+		internal TdsMetaParameterCollection MetaParameters {
+			get { return metaParameters; }
+		}
 		
 		#endregion // Properties
 
@@ -110,6 +117,7 @@ namespace Mono.Data.SybaseClient {
 			
 			value.Container = this;
 			list.Add (value);
+			metaParameters.Add (value.MetaParameter);
 			return value;
 		}
 		
@@ -118,23 +126,24 @@ namespace Mono.Data.SybaseClient {
 			return Add (new SybaseParameter (parameterName, value));
 		}
 		
-		public SybaseParameter Add (string parameterName, SybaseType sqlDbType)
+		public SybaseParameter Add (string parameterName, SybaseType sybaseType)
 		{
-			return Add (new SybaseParameter (parameterName, sqlDbType));
+			return Add (new SybaseParameter (parameterName, sybaseType));
 		}
 
-		public SybaseParameter Add (string parameterName, SybaseType sqlDbType, int size)
+		public SybaseParameter Add (string parameterName, SybaseType sybaseType, int size)
 		{
-			return Add (new SybaseParameter (parameterName, sqlDbType, size));
+			return Add (new SybaseParameter (parameterName, sybaseType, size));
 		}
 
-		public SybaseParameter Add (string parameterName, SybaseType sqlDbType, int size, string sourceColumn)
+		public SybaseParameter Add (string parameterName, SybaseType sybaseType, int size, string sourceColumn)
 		{
-			return Add (new SybaseParameter (parameterName, sqlDbType, size, sourceColumn));
+			return Add (new SybaseParameter (parameterName, sybaseType, size, sourceColumn));
 		}
 
 		public void Clear()
 		{
+			metaParameters.Clear ();
 			list.Clear ();
 		}
 		
@@ -182,11 +191,13 @@ namespace Mono.Data.SybaseClient {
 
 		public void Remove (object value)
 		{
+			metaParameters.Remove (((SybaseParameter) value).MetaParameter);
 			list.Remove (value);
 		}
 
 		public void RemoveAt (int index)
 		{
+			metaParameters.RemoveAt (index);
 			list.RemoveAt (index);
 		}
 
diff --git a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseTransaction.cs b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseTransaction.cs
index 2e324ae3cbe..5a25751721e 100644
--- a/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseTransaction.cs
+++ b/mcs/class/Mono.Data.SybaseClient/Mono.Data.SybaseClient/SybaseTransaction.cs
@@ -61,7 +61,7 @@ namespace Mono.Data.SybaseClient {
 		{
 			if (!isOpen)
 				throw new InvalidOperationException ("The Transaction was not open.");
-			connection.Tds.ExecuteNonQuery ("COMMIT TRANSACTION");
+			connection.Tds.Execute ("COMMIT TRANSACTION");
 			connection.Transaction = null;
 			isOpen = false;
 		}		
@@ -90,7 +90,7 @@ namespace Mono.Data.SybaseClient {
 		{
 			if (!isOpen)
 				throw new InvalidOperationException ("The Transaction was not open.");
-			connection.Tds.ExecuteNonQuery (String.Format ("ROLLBACK TRANSACTION {0}", transactionName));
+			connection.Tds.Execute (String.Format ("ROLLBACK TRANSACTION {0}", transactionName));
 			isOpen = false;
 		}
 
@@ -98,7 +98,7 @@ namespace Mono.Data.SybaseClient {
 		{
 			if (!isOpen)
 				throw new InvalidOperationException ("The Transaction was not open.");
-			connection.Tds.ExecuteNonQuery (String.Format ("SAVE TRANSACTION {0}", savePointName));
+			connection.Tds.Execute (String.Format ("SAVE TRANSACTION {0}", savePointName));
 		}
 
 		#endregion // Methods