Files
mono/mcs/class/System.Data/System.Data.OleDb/OleDbCommand.cs
T
Rodrigo Moya 11d169f36a 2002-07-29 Rodrigo Moya <[email protected]>
* OleDbDataReader.cs (OleDbDataReader constructor): changed to receive
	a second argument (ArrayList results).
	(NextResult): implemented.

	* OleDbCommand.cs: don't store the ArrayList of results, since we'll
	pass that to the OleDbDataReader.
	(OleDbCommand constructor): don't create the ArrayList of results.
	(GdaResults): removed property.
	(ExecuteReader): create a temporary ArrayList and pass that to the
	OleDbDataReader constructor.

svn path=/trunk/mcs/; revision=6236
2002-07-29 10:12:21 +00:00

282 lines
5.9 KiB
C#

//
// System.Data.OleDb.OleDbCommand
//
// Authors:
// Rodrigo Moya ([email protected])
// Tim Coleman ([email protected])
//
// Copyright (C) Rodrigo Moya, 2002
// Copyright (C) Tim Coleman, 2002
//
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Collections;
namespace System.Data.OleDb
{
/// <summary>
/// Represents an SQL statement or stored procedure to execute against a data source.
/// </summary>
public sealed class OleDbCommand : Component, ICloneable, IDbCommand
{
#region Fields
string commandText;
int timeout;
CommandType commandType;
OleDbConnection connection;
OleDbParameterCollection parameters;
OleDbTransaction transaction;
bool designTimeVisible;
OleDbDataReader dataReader;
CommandBehavior behavior;
IntPtr gdaCommand;
#endregion // Fields
#region Constructors
public OleDbCommand ()
{
commandText = String.Empty;
timeout = 30; // default timeout per .NET
commandType = CommandType.Text;
connection = null;
parameters = new OleDbParameterCollection ();
transaction = null;
designTimeVisible = false;
dataReader = null;
behavior = CommandBehavior.Default;
gdaCommand = IntPtr.Zero;
}
public OleDbCommand (string cmdText)
: this ()
{
CommandText = cmdText;
}
public OleDbCommand (string cmdText, OleDbConnection connection)
: this (cmdText)
{
Connection = connection;
}
public OleDbCommand (string cmdText, OleDbConnection connection, OleDbTransaction transaction)
: this (cmdText, connection)
{
this.transaction = transaction;
}
#endregion // Constructors
#region Properties
public string CommandText
{
get { return commandText; }
set {
commandText = value;
}
}
public int CommandTimeout {
get { return timeout; }
set { timeout = value; }
}
public CommandType CommandType {
get { return commandType; }
set { commandType = value; }
}
public OleDbConnection Connection {
get { return connection; }
set { connection = value; }
}
public bool DesignTimeVisible {
get { return designTimeVisible; }
set { designTimeVisible = value; }
}
public OleDbParameterCollection Parameters {
get { return parameters; }
set { parameters = value; }
}
public OleDbTransaction Transaction {
get { return transaction; }
set { transaction = value; }
}
public UpdateRowSource UpdatedRowSource {
[MonoTODO]
get { throw new NotImplementedException (); }
[MonoTODO]
set { throw new NotImplementedException (); }
}
IDbConnection IDbCommand.Connection {
get { return Connection; }
set { Connection = (OleDbConnection) value; }
}
IDataParameterCollection IDbCommand.Parameters {
get { return Parameters; }
}
IDbTransaction IDbCommand.Transaction {
get { return Transaction; }
set { Transaction = (OleDbTransaction) value; }
}
#endregion // Properties
#region Methods
[MonoTODO]
public void Cancel ()
{
throw new NotImplementedException ();
}
public OleDbParameter CreateParameter ()
{
return new OleDbParameter ();
}
IDbDataParameter IDbCommand.CreateParameter ()
{
return CreateParameter ();
}
[MonoTODO]
protected override void Dispose (bool disposing)
{
throw new NotImplementedException ();
}
private void SetupGdaCommand ()
{
GdaCommandType type;
switch (commandType) {
case CommandType.TableDirect :
type = GdaCommandType.Table;
break;
case CommandType.StoredProcedure :
type = GdaCommandType.Procedure;
break;
case CommandType.Text :
default :
type = GdaCommandType.Sql;
break;
}
if (gdaCommand != IntPtr.Zero) {
libgda.gda_command_set_text (gdaCommand, commandText);
libgda.gda_command_set_command_type (gdaCommand, type);
} else {
gdaCommand = libgda.gda_command_new (commandText, type, 0);
}
//libgda.gda_command_set_transaction
}
public int ExecuteNonQuery ()
{
if (connection == null)
throw new InvalidOperationException ();
if (connection.State == ConnectionState.Closed)
throw new InvalidOperationException ();
// FIXME: a third check is mentioned in .NET docs
IntPtr gdaConnection = connection.GdaConnection;
IntPtr gdaParameterList = parameters.GdaParameterList;
SetupGdaCommand ();
return libgda.gda_connection_execute_non_query (gdaConnection, (IntPtr) gdaCommand, gdaParameterList);
}
public OleDbDataReader ExecuteReader ()
{
return ExecuteReader (CommandBehavior.Default);
}
IDataReader IDbCommand.ExecuteReader ()
{
return ExecuteReader ();
}
public OleDbDataReader ExecuteReader (CommandBehavior behavior)
{
ArrayList results = new ArrayList ();
if (connection.State != ConnectionState.Open)
throw new InvalidOperationException ();
this.behavior = behavior;
IntPtr gdaConnection = connection.GdaConnection;
IntPtr gdaParameterList = parameters.GdaParameterList;
/* FIXME: split all returned resultsets into the array
list of results */
results.Add (libgda.gda_connection_execute_command (
gdaConnection,
gdaCommand,
gdaParameterList));
dataReader = new OleDbDataReader (this, results);
dataReader.NextResult ();
return dataReader;
}
IDataReader IDbCommand.ExecuteReader (CommandBehavior behavior)
{
return ExecuteReader (behavior);
}
[MonoTODO]
public object ExecuteScalar ()
{
throw new NotImplementedException ();
}
[MonoTODO]
object ICloneable.Clone ()
{
throw new NotImplementedException ();
}
[MonoTODO]
public void Prepare ()
{
throw new NotImplementedException ();
}
public void ResetCommandTimeout ()
{
timeout = 30;
}
#endregion
#region Internal Methods
// only meant to be used between OleDbConnection,
// OleDbCommand, and OleDbDataReader
internal void OpenReader (OleDbDataReader reader)
{
connection.OpenReader (reader);
}
#endregion
}
}