using System.Data;
using System.Data.Common;
using System.Collections;
+using System.Runtime.InteropServices;
namespace System.Data.OleDb
{
bool designTimeVisible;
OleDbDataReader dataReader;
CommandBehavior behavior;
- ArrayList gdaCommands;
- ArrayList gdaResults;
+ IntPtr gdaCommand;
#endregion // Fields
designTimeVisible = false;
dataReader = null;
behavior = CommandBehavior.Default;
- gdaCommands = new ArrayList ();
- gdaResults = new ArrayList ();
+ gdaCommand = IntPtr.Zero;
}
- public OleDbCommand (string cmdText)
- : this ()
+ public OleDbCommand (string cmdText) : this ()
{
CommandText = cmdText;
}
Connection = connection;
}
- public OleDbCommand (string cmdText, OleDbConnection connection, OleDbTransaction transaction)
- : this (cmdText, connection)
+ public OleDbCommand (string cmdText,
+ OleDbConnection connection,
+ OleDbTransaction transaction) : this (cmdText, connection)
{
this.transaction = transaction;
}
public string CommandText
{
- get { return commandText; }
+ get {
+ return commandText;
+ }
set {
- string[] queries = value.Split (new Char[] {';'});
- gdaCommands.Clear ();
-
- foreach (string query in queries)
- gdaCommands.Add (libgda.gda_command_new (query, 0, 0));
-
- commandText = value;
+ commandText = value;
}
}
public int CommandTimeout {
- get { return timeout; }
- set { timeout = value; }
+ get {
+ return timeout;
+ }
+ set {
+ timeout = value;
+ }
}
public CommandType CommandType {
- get { return commandType; }
- set { commandType = value; }
+ get {
+ return commandType;
+ }
+ set {
+ commandType = value;
+ }
}
public OleDbConnection Connection {
- get { return connection; }
- set { connection = value; }
+ get {
+ return connection;
+ }
+ set {
+ connection = value;
+ }
}
public bool DesignTimeVisible {
- get { return designTimeVisible; }
- set { designTimeVisible = value; }
+ get {
+ return designTimeVisible;
+ }
+ set {
+ designTimeVisible = value;
+ }
}
public OleDbParameterCollection Parameters {
- get { return parameters; }
- set { parameters = value; }
+ get {
+ return parameters;
+ }
+ set {
+ parameters = value;
+ }
}
public OleDbTransaction Transaction {
- get { return transaction; }
- set { transaction = value; }
+ get {
+ return transaction;
+ }
+ set {
+ transaction = value;
+ }
}
public UpdateRowSource UpdatedRowSource {
[MonoTODO]
- get { throw new NotImplementedException (); }
+ get {
+ throw new NotImplementedException ();
+ }
[MonoTODO]
- set { throw new NotImplementedException (); }
+ set {
+ throw new NotImplementedException ();
+ }
}
IDbConnection IDbCommand.Connection {
- get { return Connection; }
- set { Connection = (OleDbConnection) value; }
+ get {
+ return Connection;
+ }
+ set {
+ Connection = (OleDbConnection) value;
+ }
}
IDataParameterCollection IDbCommand.Parameters {
- get { return Parameters; }
+ get {
+ return Parameters;
+ }
}
IDbTransaction IDbCommand.Transaction {
- get { return Transaction; }
- set { Transaction = (OleDbTransaction) value; }
- }
-
- internal ArrayList GdaResults {
- get { return gdaResults; }
+ get {
+ return Transaction;
+ }
+ set {
+ Transaction = (OleDbTransaction) value;
+ }
}
#endregion // Properties
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 ();
+ throw new InvalidOperationException ("connection == null");
if (connection.State == ConnectionState.Closed)
- throw new InvalidOperationException ();
+ throw new InvalidOperationException ("State == Closed");
// FIXME: a third check is mentioned in .NET docs
IntPtr gdaConnection = connection.GdaConnection;
IntPtr gdaParameterList = parameters.GdaParameterList;
- return libgda.gda_connection_execute_non_query (gdaConnection, (IntPtr) gdaCommands[0], 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 ();
+ IntPtr rs_list;
+ GdaList glist_node;
+
if (connection.State != ConnectionState.Open)
- throw new InvalidOperationException ();
+ throw new InvalidOperationException ("State != Open");
this.behavior = behavior;
IntPtr gdaConnection = connection.GdaConnection;
IntPtr gdaParameterList = parameters.GdaParameterList;
- foreach (IntPtr gdaCommand in gdaCommands)
- GdaResults.Add (libgda.gda_connection_execute_single_command (gdaConnection, gdaCommand, gdaParameterList));
-
- dataReader = new OleDbDataReader (this);
-
- dataReader.NextResult ();
+ /* execute the command */
+ SetupGdaCommand ();
+ rs_list = libgda.gda_connection_execute_command (
+ gdaConnection,
+ gdaCommand,
+ gdaParameterList);
+ if (rs_list != IntPtr.Zero) {
+ glist_node = (GdaList) Marshal.PtrToStructure (rs_list, typeof (GdaList));
+
+ while (glist_node != null) {
+ results.Add (glist_node.data);
+ if (glist_node.next == IntPtr.Zero)
+ break;
+
+ glist_node = (GdaList) Marshal.PtrToStructure (glist_node.next,
+ typeof (GdaList));
+ }
+ dataReader = new OleDbDataReader (this, results);
+ dataReader.NextResult ();
+ }
return dataReader;
}
- [MonoTODO]
- public object ExecuteScalar ()
- {
- throw new NotImplementedException ();
- }
-
- [MonoTODO]
- object ICloneable.Clone ()
- {
- throw new NotImplementedException ();
- }
-
- [MonoTODO]
- IDbDataParameter IDbCommand.CreateParameter ()
+ IDataReader IDbCommand.ExecuteReader (CommandBehavior behavior)
{
- throw new NotImplementedException ();
+ return ExecuteReader (behavior);
}
-
- [MonoTODO]
- IDataReader IDbCommand.ExecuteReader ()
+
+ public object ExecuteScalar ()
{
- throw new NotImplementedException ();
+ SetupGdaCommand ();
+ OleDbDataReader reader = ExecuteReader ();
+ if (reader == null) {
+ return null;
+ }
+ if (!reader.Read ()) {
+ reader.Close ();
+ return null;
+ }
+ object o = reader.GetValue (0);
+ reader.Close ();
+ return o;
}
[MonoTODO]
- IDataReader IDbCommand.ExecuteReader (CommandBehavior behavior)
+ object ICloneable.Clone ()
{
throw new NotImplementedException ();
}
}
#endregion
-
- #region Internal Methods
-
- // only meant to be used between OleDbConnectioin,
- // OleDbCommand, and OleDbDataReader
- internal void OpenReader (OleDbDataReader reader)
- {
- connection.OpenReader (reader);
- }
-
- #endregion
-
}
}
projects / mono.git / blobdiff