From 769a0e50e395a6f75b040fbe7a325384ef02417d Mon Sep 17 00:00:00 2001 From: Tim Coleman Date: Tue, 26 Nov 2002 06:36:38 +0000 Subject: 2002-11-26 Tim Coleman * 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 --- mcs/class/Mono.Data.SybaseClient/ChangeLog | 11 + .../Mono.Data.SybaseClient.build | 1 + .../Mono.Data.SybaseClient/SybaseCommand.cs | 247 +++++--------------- .../Mono.Data.SybaseClient/SybaseConnection.cs | 4 +- .../Mono.Data.SybaseClient/SybaseParameter.cs | 250 +++++++++------------ .../SybaseParameterCollection.cs | 23 +- .../Mono.Data.SybaseClient/SybaseTransaction.cs | 6 +- 7 files changed, 203 insertions(+), 339 deletions(-) (limited to 'mcs/class/Mono.Data.SybaseClient') 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 + * 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 * 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 @@ + 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 -- cgit v1.2.3