+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:
<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"/>
// Copyright (C) Tim Coleman, 2002
//
+using Mono.Data.Tds;
using Mono.Data.Tds.Protocol;
using System;
using System.Collections;
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
#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
public string CommandText {
get { return commandText; }
- set { commandText = value; }
+ set {
+ if (value != commandText && preparedStatement != null)
+ Unprepare ();
+ commandText = value;
+ }
}
public int CommandTimeout {
#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)
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];
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);
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;
}
{
ValidateCommand ("ExecuteScalar");
try {
- Connection.Tds.ExecuteQuery (BuildCommand (), CommandTimeout);
+ Execute (CommandBehavior.Default, true);
}
catch (TdsTimeoutException e) {
throw SybaseException.FromTdsInternalException ((TdsInternalException) e);
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 ();
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 ()
commandTimeout = 30;
}
+ private void Unprepare ()
+ {
+ Connection.Tds.Unprepare (preparedStatement);
+ preparedStatement = null;
+ }
+
private void ValidateCommand (string method)
{
if (Connection == null)
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;
}
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)
// Copyright (C) Tim Coleman, 2002
//
+using Mono.Data.Tds;
using Mono.Data.Tds.Protocol;
using System;
using System.ComponentModel;
{
#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
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)
{
}
+ [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;
}
// 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]);
}
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 {
}
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 {
}
public SybaseType SybaseType {
- get { return sqlDbType; }
+ get { return sybaseType; }
set {
SetSybaseType (value);
isTypeSet = true;
}
public object Value {
- get { return objValue; }
+ get { return metaParameter.Value; }
set {
if (!isTypeSet)
- InferSqlType (value);
- objValue = value;
+ InferSybaseType (value);
+ metaParameter.Value = value;
}
}
// 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 ();
}
}
- 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.
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);
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
// Copyright (C) Tim Coleman, 2002
//
+using Mono.Data.Tds;
using System;
using System.ComponentModel;
using System.Data;
#region Fields
ArrayList list = new ArrayList();
+ TdsMetaParameterCollection metaParameters;
SybaseCommand command;
#endregion // Fields
internal SybaseParameterCollection (SybaseCommand command)
{
this.command = command;
+ metaParameters = new TdsMetaParameterCollection ();
}
#endregion // Constructors
object ICollection.SyncRoot {
get { return list.SyncRoot; }
}
+
+ internal TdsMetaParameterCollection MetaParameters {
+ get { return metaParameters; }
+ }
#endregion // Properties
value.Container = this;
list.Add (value);
+ metaParameters.Add (value.MetaParameter);
return value;
}
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 ();
}
public void Remove (object value)
{
+ metaParameters.Remove (((SybaseParameter) value).MetaParameter);
list.Remove (value);
}
public void RemoveAt (int index)
{
+ metaParameters.RemoveAt (index);
list.RemoveAt (index);
}
{
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;
}
{
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;
}
{
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
projects / mono.git / commitdiff