mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 19:10:23 -10:00
* Test/TestExecuteScalar.cs: added test for method ExecuteScalar in class SqlCommand. * System.Data/DataColumnCollection.cs - it should inherit properties from base InternalDataCollectionBase and use them instead of overriding them, such as, List. * System.Data/DataColumn.cs * System.Data/DataTable.cs: tweaks to retrieve meta data from the database * System.Data.SqlClient/PostgresLibrary.cs - added method OidToType to convert PostgreSQL oid type to System.Type. Renamed method OidTypeToSystem to ConvertPgTypeToSystem for converting the data value from a PostgreSQL type to a .NET System type. * System.Data.SqlClient/SqlCommand.cs: implemented method ExecuteReader which returns a SqlDataReader for a light forward only read only result set. It works on types int4 ==> Int32 and varchar ==> String. Other types will come later. * System.Data.SqlClient/SqlConnection.cs: added comment * System.Data.SqlClient/SqlDataReader.cs: implemented class. It works, but still lots to do. * Test/ReadPostgresData.cs: stuff * Test/TestSqlDataReader.cs: updated test for SqlDataReader to display meta data and the data svn path=/trunk/mcs/; revision=4247
550 lines
11 KiB
C#
550 lines
11 KiB
C#
//
|
|
// System.Data.SqlClient.SqlCommand.cs
|
|
//
|
|
// Author:
|
|
// Rodrigo Moya ([email protected])
|
|
// Daniel Morgan ([email protected])
|
|
//
|
|
// (C) Ximian, Inc 2002
|
|
//
|
|
|
|
// use #define DEBUG_SqlCommand if you want to spew debug messages
|
|
// #define DEBUG_SqlCommand
|
|
|
|
using System;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Data.Common;
|
|
using System.Runtime.InteropServices;
|
|
using System.Xml;
|
|
|
|
namespace System.Data.SqlClient
|
|
{
|
|
/// <summary>
|
|
/// Represents a SQL statement that is executed
|
|
/// while connected to a SQL database.
|
|
/// </summary>
|
|
// public sealed class SqlCommand : Component, IDbCommand, ICloneable
|
|
public sealed class SqlCommand : IDbCommand
|
|
{
|
|
// FIXME: Console.WriteLine() is used for debugging throughout
|
|
|
|
#region Fields
|
|
|
|
string sql = "";
|
|
int timeout = 30;
|
|
// default is 30 seconds
|
|
// for command execution
|
|
|
|
SqlConnection conn = null;
|
|
SqlTransaction trans = null;
|
|
CommandType cmdType = CommandType.Text;
|
|
bool designTime = false;
|
|
SqlParameterCollection parmCollection = new
|
|
SqlParameterCollection();
|
|
|
|
#endregion // Fields
|
|
|
|
#region Constructors
|
|
|
|
public SqlCommand()
|
|
{
|
|
sql = "";
|
|
}
|
|
|
|
public SqlCommand (string cmdText)
|
|
{
|
|
sql = cmdText;
|
|
}
|
|
|
|
public SqlCommand (string cmdText, SqlConnection connection)
|
|
{
|
|
sql = cmdText;
|
|
conn = connection;
|
|
}
|
|
|
|
public SqlCommand (string cmdText, SqlConnection connection,
|
|
SqlTransaction transaction)
|
|
{
|
|
sql = cmdText;
|
|
conn = connection;
|
|
trans = transaction;
|
|
}
|
|
|
|
#endregion // Constructors
|
|
|
|
#region Methods
|
|
|
|
[MonoTODO]
|
|
public void Cancel ()
|
|
{
|
|
// FIXME: use non-blocking Exec for this
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
// FIXME: is this the correct way to return a stronger type?
|
|
[MonoTODO]
|
|
IDbDataParameter IDbCommand.CreateParameter ()
|
|
{
|
|
return CreateParameter ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public SqlParameter CreateParameter ()
|
|
{
|
|
return new SqlParameter ();
|
|
}
|
|
|
|
public int ExecuteNonQuery ()
|
|
{
|
|
IntPtr pgResult; // PGresult
|
|
int rowsAffected = -1;
|
|
ExecStatusType execStatus;
|
|
String rowsAffectedString;
|
|
|
|
if(conn.State != ConnectionState.Open)
|
|
throw new InvalidOperationException(
|
|
"ConnnectionState is not Open");
|
|
|
|
// FIXME: PQexec blocks
|
|
// while PQsendQuery is non-blocking
|
|
// which is better to use?
|
|
// int PQsendQuery(PGconn *conn,
|
|
// const char *query);
|
|
|
|
// execute SQL command
|
|
// uses internal property to get the PGConn IntPtr
|
|
pgResult = PostgresLibrary.
|
|
PQexec (conn.PostgresConnection, sql);
|
|
|
|
execStatus = PostgresLibrary.
|
|
PQresultStatus (pgResult);
|
|
|
|
if(execStatus == ExecStatusType.PGRES_COMMAND_OK)
|
|
{
|
|
rowsAffectedString = PostgresLibrary.
|
|
PQcmdTuples (pgResult);
|
|
|
|
if(rowsAffectedString != null)
|
|
if(rowsAffectedString.Equals("") == false)
|
|
rowsAffected = int.Parse(rowsAffectedString);
|
|
|
|
PostgresLibrary.PQclear (pgResult);
|
|
}
|
|
else
|
|
{
|
|
String errorMessage;
|
|
|
|
errorMessage = PostgresLibrary.
|
|
PQresStatus(execStatus);
|
|
|
|
errorMessage += " " + PostgresLibrary.
|
|
PQresultErrorMessage(pgResult);
|
|
|
|
throw new SqlException(0, 0,
|
|
errorMessage, 0, "",
|
|
conn.DataSource, "SqlCommand", 0);
|
|
}
|
|
|
|
return rowsAffected;
|
|
}
|
|
|
|
[MonoTODO]
|
|
IDataReader IDbCommand.ExecuteReader ()
|
|
{
|
|
return ExecuteReader ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
SqlDataReader ExecuteReader ()
|
|
{
|
|
return ExecuteReader(CommandBehavior.Default);
|
|
}
|
|
|
|
[MonoTODO]
|
|
IDataReader IDbCommand.ExecuteReader (
|
|
CommandBehavior behavior)
|
|
{
|
|
return ExecuteReader (behavior);
|
|
}
|
|
|
|
[MonoTODO]
|
|
public SqlDataReader ExecuteReader (CommandBehavior behavior)
|
|
{
|
|
// FIXME: currently only works for a
|
|
// single result set
|
|
// ExecuteReader can be used
|
|
// for multiple result sets
|
|
SqlDataReader dataReader = null;
|
|
|
|
IntPtr pgResult; // PGresult
|
|
ExecStatusType execStatus;
|
|
|
|
if(conn.State != ConnectionState.Open)
|
|
throw new InvalidOperationException(
|
|
"ConnnectionState is not Open");
|
|
|
|
// FIXME: PQexec blocks
|
|
// while PQsendQuery is non-blocking
|
|
// which is better to use?
|
|
// int PQsendQuery(PGconn *conn,
|
|
// const char *query);
|
|
|
|
// execute SQL command
|
|
// uses internal property to get the PGConn IntPtr
|
|
pgResult = PostgresLibrary.
|
|
PQexec (conn.PostgresConnection, sql);
|
|
|
|
execStatus = PostgresLibrary.
|
|
PQresultStatus (pgResult);
|
|
|
|
if(execStatus == ExecStatusType.PGRES_TUPLES_OK) {
|
|
DataTable dt = null;
|
|
int rows, cols;
|
|
int[] oids;
|
|
|
|
// FIXME: maybe i should move the
|
|
// BuildTableSchema code
|
|
// to the SqlDataReader?
|
|
dt = BuildTableSchema(pgResult,
|
|
out rows, out cols, out oids);
|
|
dataReader = new SqlDataReader(this, dt, pgResult,
|
|
rows, cols, oids);
|
|
}
|
|
else {
|
|
String errorMessage;
|
|
|
|
errorMessage = PostgresLibrary.
|
|
PQresStatus(execStatus);
|
|
|
|
errorMessage += " " + PostgresLibrary.
|
|
PQresultErrorMessage(pgResult);
|
|
|
|
throw new SqlException(0, 0,
|
|
errorMessage, 0, "",
|
|
conn.DataSource, "SqlCommand", 0);
|
|
}
|
|
|
|
return dataReader;
|
|
}
|
|
|
|
internal DataTable BuildTableSchema (IntPtr pgResult,
|
|
out int nRows,
|
|
out int nFields,
|
|
out int[] oids) {
|
|
|
|
int nCol;
|
|
|
|
DataTable dt = new DataTable();
|
|
|
|
nRows = PostgresLibrary.
|
|
PQntuples(pgResult);
|
|
|
|
nFields = PostgresLibrary.
|
|
PQnfields(pgResult);
|
|
|
|
oids = new int[nFields];
|
|
|
|
for(nCol = 0; nCol < nFields; nCol++) {
|
|
// get column name
|
|
String fieldName;
|
|
fieldName = PostgresLibrary.
|
|
PQfname(pgResult, nCol);
|
|
|
|
// get PostgreSQL data type (OID)
|
|
oids[nCol] = PostgresLibrary.
|
|
PQftype(pgResult, nCol);
|
|
|
|
int definedSize;
|
|
// get defined size of column
|
|
definedSize = PostgresLibrary.
|
|
PQfsize(pgResult, nCol);
|
|
|
|
// build the data column and add it the table
|
|
DataColumn dc = new DataColumn(fieldName);
|
|
dc.DataType = PostgresHelper.OidToType(oids[nCol]);
|
|
dc.MaxLength = definedSize;
|
|
dc.SetTable(dt);
|
|
|
|
dt.Columns.Add(dc);
|
|
}
|
|
return dt;
|
|
}
|
|
|
|
[MonoTODO]
|
|
public object ExecuteScalar ()
|
|
{
|
|
IntPtr pgResult; // PGresult
|
|
ExecStatusType execStatus;
|
|
object obj = null; // return
|
|
int nRow = 0; // first row
|
|
int nCol = 0; // first column
|
|
String value;
|
|
int nRows;
|
|
int nFields;
|
|
|
|
if(conn.State != ConnectionState.Open)
|
|
throw new InvalidOperationException(
|
|
"ConnnectionState is not Open");
|
|
|
|
// FIXME: PQexec blocks
|
|
// while PQsendQuery is non-blocking
|
|
// which is better to use?
|
|
// int PQsendQuery(PGconn *conn,
|
|
// const char *query);
|
|
|
|
// execute SQL command
|
|
// uses internal property to get the PGConn IntPtr
|
|
pgResult = PostgresLibrary.
|
|
PQexec (conn.PostgresConnection, sql);
|
|
|
|
execStatus = PostgresLibrary.
|
|
PQresultStatus (pgResult);
|
|
|
|
if(execStatus == ExecStatusType.PGRES_TUPLES_OK) {
|
|
nRows = PostgresLibrary.
|
|
PQntuples(pgResult);
|
|
|
|
nFields = PostgresLibrary.
|
|
PQnfields(pgResult);
|
|
|
|
if(nRows > 0 && nFields > 0) {
|
|
|
|
// get column name
|
|
//String fieldName;
|
|
//fieldName = PostgresLibrary.
|
|
// PQfname(pgResult, nCol);
|
|
|
|
int oid;
|
|
// get PostgreSQL data type (OID)
|
|
oid = PostgresLibrary.
|
|
PQftype(pgResult, nCol);
|
|
|
|
int definedSize;
|
|
// get defined size of column
|
|
definedSize = PostgresLibrary.
|
|
PQfsize(pgResult, nCol);
|
|
|
|
// get data value
|
|
value = PostgresLibrary.
|
|
PQgetvalue(
|
|
pgResult,
|
|
nRow, nCol);
|
|
|
|
int columnIsNull;
|
|
// is column NULL?
|
|
columnIsNull = PostgresLibrary.
|
|
PQgetisnull(pgResult,
|
|
nRow, nCol);
|
|
|
|
int actualLength;
|
|
// get Actual Length
|
|
actualLength = PostgresLibrary.
|
|
PQgetlength(pgResult,
|
|
nRow, nCol);
|
|
|
|
obj = PostgresHelper.
|
|
ConvertPgTypeToSystem (oid, value);
|
|
}
|
|
|
|
// close result set
|
|
PostgresLibrary.PQclear (pgResult);
|
|
|
|
}
|
|
else {
|
|
String errorMessage;
|
|
|
|
errorMessage = PostgresLibrary.
|
|
PQresStatus(execStatus);
|
|
|
|
errorMessage += " " + PostgresLibrary.
|
|
PQresultErrorMessage(pgResult);
|
|
|
|
throw new SqlException(0, 0,
|
|
errorMessage, 0, "",
|
|
conn.DataSource, "SqlCommand", 0);
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
[MonoTODO]
|
|
public XmlReader ExecuteXmlReader ()
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public void Prepare ()
|
|
{
|
|
// FIXME: parameters have to be implemented for this
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
[MonoTODO]
|
|
public SqlCommand Clone ()
|
|
{
|
|
throw new NotImplementedException ();
|
|
}
|
|
|
|
#endregion // Methods
|
|
|
|
#region Properties
|
|
|
|
public string CommandText {
|
|
get {
|
|
return sql;
|
|
}
|
|
|
|
set {
|
|
sql = value;
|
|
}
|
|
}
|
|
|
|
public int CommandTimeout {
|
|
get {
|
|
return timeout;
|
|
}
|
|
|
|
set {
|
|
// FIXME: if value < 0, throw
|
|
// ArgumentException
|
|
// if (value < 0)
|
|
// throw ArgumentException;
|
|
timeout = value;
|
|
}
|
|
}
|
|
|
|
public CommandType CommandType {
|
|
get {
|
|
return cmdType;
|
|
}
|
|
|
|
set {
|
|
cmdType = value;
|
|
}
|
|
}
|
|
|
|
// FIXME: for property Connection, is this the correct
|
|
// way to handle a return of a stronger type?
|
|
IDbConnection IDbCommand.Connection {
|
|
get {
|
|
return Connection;
|
|
}
|
|
|
|
set {
|
|
// FIXME: throw an InvalidOperationException
|
|
// if the change was during a
|
|
// transaction in progress
|
|
|
|
// csc
|
|
Connection = (SqlConnection) value;
|
|
// mcs
|
|
// Connection = value;
|
|
|
|
// FIXME: set Transaction property to null
|
|
}
|
|
}
|
|
|
|
public SqlConnection Connection {
|
|
get {
|
|
// conn defaults to null
|
|
return conn;
|
|
}
|
|
|
|
set {
|
|
// FIXME: throw an InvalidOperationException
|
|
// if the change was during
|
|
// a transaction in progress
|
|
conn = value;
|
|
// FIXME: set Transaction property to null
|
|
}
|
|
}
|
|
|
|
public bool DesignTimeVisible {
|
|
get {
|
|
return designTime;
|
|
}
|
|
|
|
set{
|
|
designTime = value;
|
|
}
|
|
}
|
|
|
|
// FIXME; for property Parameters, is this the correct
|
|
// way to handle a stronger return type?
|
|
IDataParameterCollection IDbCommand.Parameters {
|
|
get {
|
|
return Parameters;
|
|
}
|
|
}
|
|
|
|
SqlParameterCollection Parameters {
|
|
get {
|
|
return parmCollection;
|
|
}
|
|
}
|
|
|
|
// FIXME: for property Transaction, is this the correct
|
|
// way to handle a return of a stronger type?
|
|
IDbTransaction IDbCommand.Transaction {
|
|
get {
|
|
return Transaction;
|
|
}
|
|
|
|
set {
|
|
// FIXME: error handling - do not allow
|
|
// setting of transaction if transaction
|
|
// has already begun
|
|
|
|
// csc
|
|
Transaction = (SqlTransaction) value;
|
|
// mcs
|
|
// Transaction = value;
|
|
}
|
|
}
|
|
|
|
public SqlTransaction Transaction {
|
|
get {
|
|
return trans;
|
|
}
|
|
|
|
set {
|
|
// FIXME: error handling
|
|
trans = value;
|
|
}
|
|
}
|
|
|
|
[MonoTODO]
|
|
public UpdateRowSource UpdatedRowSource {
|
|
// FIXME: do this once DbDataAdaptor
|
|
// and DataRow are done
|
|
get {
|
|
throw new NotImplementedException ();
|
|
}
|
|
set {
|
|
throw new NotImplementedException ();
|
|
}
|
|
}
|
|
|
|
#endregion // Properties
|
|
|
|
#region Destructors
|
|
|
|
[MonoTODO]
|
|
public void Dispose() {
|
|
// FIXME: need proper way to release resources
|
|
// Dispose(true);
|
|
}
|
|
|
|
[MonoTODO]
|
|
~SqlCommand()
|
|
{
|
|
// FIXME: need proper way to release resources
|
|
// Dispose(false);
|
|
}
|
|
|
|
#endregion //Destructors
|
|
}
|
|
}
|