<?xml version="1.0"?>
<doc>
<assembly>
<name>AMS.ADO</name>
</assembly>
<members>
<member name="T:AMS.ADO.ICommand">
<summary>
Generic representation of an SQL command to be executed against a database. </summary>
</member>
<member name="M:AMS.ADO.ICommand.ExecuteDataSet(System.String[])">
<summary>
Opens a temporary database connection, executes the query, and
returns the results inside a DataSet object. </summary>
<param name="tables">
The array of names of the source tables to use for table mapping. </param>
<returns>
The return value is a DataSet object. </returns>
</member>
<member name="M:AMS.ADO.ICommand.ExecuteDataSet(System.Data.DataSet,System.String[])">
<summary>
Opens a temporary database connection, executes the query, and
appends the results to a DataSet object. </summary>
<param name="ds">
The DataSet object to be filled with the results of the cmd. </param>
<param name="tables">
The array of names of the source tables to use for table mapping. </param>
<returns>
The return value is the same DataSet object passed in as a parameter. </returns>
</member>
<member name="M:AMS.ADO.ICommand.ExecuteString">
<summary>
Calls <see cref="M:System.Data.IDbCommand.ExecuteScalar"/> and casts the result to a string. </summary>
<returns>
The return value is the first column of the first row in the result set
converted to a string. If the first column of the first row is DBNull.Value, the return
value is an empty string. If the result set is empty, the return value is null. </returns>
</member>
<member name="M:AMS.ADO.ICommand.ExecuteInt">
<summary>
Calls <see cref="M:System.Data.IDbCommand.ExecuteScalar"/> and casts the result to an int. </summary>
<returns>
The return value is the first column of the first row in the result set
cast to an int. If the first column of the first row is DBNull.Value or cannot be
converted to an int, the return value is 0. If the result set is empty,
the return value is 0. </returns>
</member>
<member name="P:AMS.ADO.ICommand.ConnectionString">
<summary>
Gets or sets the connection string to use when connecting to the
database where the command will be executed. </summary>
</member>
<member name="T:AMS.ADO.Odbc.SQL">
<summary>
Represents an SQL statement to be executed against an ODBC data source. </summary>
<remarks>
This class encapsulates the OdbcCommand class with the added convenience of connection
management. It automatically opens the connection if it needs to, uses it, and closes
it if it's no longer needed. This can significantly cut down the amount of repetitive
code normally required for connection management and helps to ensure that a connection
is not left open inadvertently. </remarks>
</member>
<member name="F:AMS.ADO.Odbc.SQL.m_command">
<summary>
OdbcCommand object used for command execution. </summary>
</member>
<member name="F:AMS.ADO.Odbc.SQL.m_connectionWasOpen">
<summary>
Indicator of whether the connection is already open when the command gets executed
so that it can be left alone when Dispose is called. </summary>
</member>
<member name="F:AMS.ADO.Odbc.SQL.m_connectionString">
<summary>
String used by the OdbcConnection object to connect to the database. </summary>
</member>
<member name="M:AMS.ADO.Odbc.SQL.#ctor">
<summary>
Constructs the object. </summary>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.Odbc.SQL.CommandText"/>
and <see cref="P:AMS.ADO.Odbc.SQL.ConnectionString"/> properties be set before the command
can be executed.
<example>Here's an example:
<code>
SQL sql = new SQL();
sql.ConnectionString = connectionString;
sql.CommandText = "INSERT INTO ...";
sql.Parameters.Add("?", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Odbc.SQL.#ctor(System.String)">
<summary>
Constructs the object and sets the text for the command. </summary>
<param name="sql">
The text for the command to be executed. </param>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.Odbc.SQL.ConnectionString"/>
property be set before the command can be executed.
<example>Here's an example:
<code>
SQL sql = new SQL("SELECT COUNT(*) FROM ...");
sql.ConnectionString = connectionString;
sql.Parameters.Add("?", value);
int count = sql.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Odbc.SQL.#ctor(System.String,System.String)">
<summary>
Constructs the object and sets the text for the command
and the connection string. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connectionString">
The connection string to use when connecting to the database where
the command will be executed. </param>
<remarks>
This constructor offers the most convenient way to create the SQL object. The
SQL and connection string are passed together and commands may then be executed
without worrying about connection management issues.
After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT Description FROM ...", connectionString);
sql.Parameters.Add("?", value);
string description = sql.ExecuteString(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Odbc.SQL.#ctor(System.String,System.Data.Odbc.OdbcConnection)">
<summary>
Constructs the object and sets the text for the command
and the connection to use. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connection">
The connection object to be used by the internal OdbcCommand object
that will execute the command. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OdbcConnection object is already available. The SQL object will automatically
open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("UPDATE ...", connection);
sql.Parameters.Add("?", value);
int rows = sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Odbc.SQL.#ctor(System.String,System.Data.Odbc.OdbcConnection,System.Data.Odbc.OdbcTransaction)">
<summary>
Constructs the object and sets the text for the command
and the connection and transaction to use. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connection">
The connection object to be used by the internal OdbcCommand object
that will execute the command. </param>
<param name="transaction">
The transaction object to be used by the internal OdbcCommand object
that will execute the command. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OdbcConnection object and an OdbcTransaction object are already available. The SQL
object will automatically open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("INSERT INTO ...", connection, transaction);
sql.Parameters.Add("?", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Odbc.SQL.Connect">
<summary>
Opens the connection of the internal OdbcCommand object, based on
the <see cref="P:AMS.ADO.Odbc.SQL.ConnectionString"/> or connection previously set. </summary>
<exception cref="T:System.NullReferenceException">Both ConnectionString and Connection are null. </exception>
</member>
<member name="M:AMS.ADO.Odbc.SQL.Dispose">
<summary>
Disposes of the internal OdbcCommand object's connection, if it was created locally;
otherwise it is left in the same state as it was found. </summary>
</member>
<member name="M:AMS.ADO.Odbc.SQL.ExecuteReader">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteReader on the internal OdbcCommand object.</summary>
<returns>
The return value is an OdbcDataReader object. </returns>
<remarks>
If a temporary connection is created or a connection was passed in
a Closed state, it will be automatically closed when the OdbcDataReader
object is closed.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT * FROM ...", connectionString);
sql.Parameters.Add("?", value);
using (OdbcDataReader reader = sql.ExecuteReader())
{
...
} // disposes of reader and the query's connection </code></example></remarks>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#ExecuteReader">
<summary>
Opens a database connection and executes the query by
calling ExecuteReader on the internal IDbCommand object.</summary>
<returns>
The return value is an IDataReader object. </returns>
<remarks>
If a temporary connection is created or a connection was passed in
a Closed state, it will be automatically closed when the IDataReader
object is closed. </remarks>
</member>
<member name="M:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#ExecuteReader(System.Data.CommandBehavior)">
<summary>
Opens a database connection and executes the query by
calling ExecuteReader on the internal IDbCommand object.</summary>
<param name="behavior">
One of the CommandBehavior values. </param>
<returns>
The return value is an IDataReader object. </returns>
</member>
<member name="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])">
<summary>
Opens a temporary database connection, executes the query, and
returns the results inside a DataSet object. </summary>
<param name="tables">
The array of names of the source tables to use for table mapping. </param>
<returns>
The return value is a DataSet object. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT * FROM ...", connectionString);
sql.Parameters.Add("?", value);
DataSet ds = sql.ExecuteDataSet(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])">
<summary>
Opens a temporary database connection, executes the query, and
appends the results to a DataSet object. </summary>
<param name="ds">
The DataSet object to be filled with the results of the sql. </param>
<param name="tables">
The array of names of the source tables to use for table mapping. </param>
<returns>
The return value is the same DataSet object passed in as a parameter. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
DataSet ds = new DataSet();
...
SQL sql = new SQL("SELECT * FROM SomeTable", connectionString);
sql.Parameters.Add("?", value);
sql.ExecuteDataSet(ds, "SomeTable"); </code></example></remarks>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Odbc.SQL.ExecuteScalar">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteScalar on the internal OdbcCommand object.</summary>
<returns>
The return value is the first column of the first row in the result set,
or null if the result set is empty. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT COUNT(*) FROM ...", connectionString);
sql.Parameters.Add("?", value);
int count = (int)sql.ExecuteScalar(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Odbc.SQL.ExecuteString">
<summary>
Calls <see cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/> and casts the result to a string. </summary>
<returns>
The return value is the first column of the first row in the result set
converted to a string. If the first column of the first row is DBNull.Value, the return
value is an empty string. If the result set is empty, the return value is null. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT name FROM ...", connectionString);
sql.Parameters.Add("?", value);
string name = sql.ExecuteString(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Odbc.SQL.ExecuteInt">
<summary>
Calls <see cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/> and casts the result to an int. </summary>
<returns>
The return value is the first column of the first row in the result set
cast to an int. If the first column of the first row is DBNull.Value or cannot be
converted to an int, the return value is 0. If the result set is empty,
the return value is 0. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT age FROM ...", connectionString);
sql.Parameters.Add("?", value);
int age = sql.ExecuteInt(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Odbc.SQL.ExecuteNonQuery">
<summary>
Opens a temporary database connection and executes the command by
calling ExecuteNonQuery on the internal OdbcCommand object. </summary>
<returns>
The return value is the number of rows affected. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("INSERT INTO ...", connection);
sql.Parameters.Add("?", value);
int rows = sql.ExecuteNonQuery(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Odbc.SQL.ExecuteDataSet(System.String[])"/>
</member>
<member name="M:AMS.ADO.Odbc.SQL.Cancel">
<summary>
Attempts to cancels the execution of the internal OdbcCommand object. </summary>
<remarks>
If there is nothing to cancel, nothing happens. However, if there is a command
in process, and the attempt to cancel fails, no exception is generated. </remarks>
</member>
<member name="M:AMS.ADO.Odbc.SQL.CreateParameter">
<summary>
Creates a new instance of an OdbcParameter object. </summary>
</member>
<member name="M:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#CreateParameter">
<summary>
Creates a new instance of an IDbDataParameter object. </summary>
</member>
<member name="M:AMS.ADO.Odbc.SQL.Prepare">
<summary>
Opens a database connection and creates a prepared
(or compiled) version of the command on the data source. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.CommandText">
<summary>
Gets or sets the text for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.CommandType">
<summary>
Gets or sets the type for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.CommandTimeout">
<summary>
Gets or sets the timeout for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.ConnectionString">
<summary>
Gets or sets the connection string to use when connecting to the
database where the command will be executed. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.Connection">
<summary>
Gets the OdbcConnection object associated with the internal OdbcCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#Connection">
<summary>
Gets or sets the OdbcConnection object associated with the internal OdbcCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.Transaction">
<summary>
Gets the OdbcTransaction object associated with the internal OdbcCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#Transaction">
<summary>
Gets or sets the OdbcTransaction object associated with the internal OdbcCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.Parameters">
<summary>
Gets the collection of OdbcParameter objects associated with the
internal OdbcCommand object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.System#Data#IDbCommand#Parameters">
<summary>
Gets the collection of IDataParameter objects associated with the
internal OdbcCommand object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Odbc.SQL.UpdatedRowSource">
<summary>
Gets or sets how command results are applied to the DataRow when
used by the Update method of a DbDataAdapter. </summary>
</member>
<member name="T:AMS.ADO.Odbc.StoredProcedure">
<summary>
Represents a stored procedure to be executed against an ODBC data source. </summary>
<remarks>
This class encapsulates the OdbcCommand class (configured to execute a stored procedure)
with the added convenience of connection management. It automatically opens the connection
if it needs to, uses it, and closes it if it's no longer needed. This can significantly cut
down the amount of repetitive code normally required for connection management and helps
to ensure that a connection is not left open inadvertently. </remarks>
</member>
<member name="M:AMS.ADO.Odbc.StoredProcedure.#ctor">
<summary>
Constructs the object. </summary>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.Odbc.SQL.CommandText"/>
and <see cref="P:AMS.ADO.Odbc.SQL.ConnectionString"/> properties be set before the command
can be executed.
<example>Here's an example:
<code>
StoredProcedure sp = new StoredProcedure();
sp.ConnectionString = connectionString;
sp.CommandText = "{call spGetEmployees(?)}";
sp.Parameters.Add("?", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Odbc.StoredProcedure.#ctor(System.String)">
<summary>
Constructs the object and sets the text for the command. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.Odbc.SQL.ConnectionString"/>
property be set before the command can be executed.
<example>Here's an example:
<code>
StoredProcedure sp = new StoredProcedure("{call spGetEmployees(?)}");
sp.ConnectionString = connectionString;
sp.Parameters.Add("?", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Odbc.StoredProcedure.#ctor(System.String,System.String)">
<summary>
Constructs the object and sets the text for the command
and the connection string. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connectionString">
The connection string to use when connecting to the database where
the command will be executed. </param>
<remarks>
This constructor offers the most convenient way to create the StoredProcedure object. The
SQL and connection string are passed together and commands may then be executed
without worrying about connection management issues.
After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("{call spGetEmployees(?)}", connectionString);
sp.Parameters.Add("?", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Odbc.StoredProcedure.#ctor(System.String,System.Data.Odbc.OdbcConnection)">
<summary>
Constructs the object and sets the text for the statement
and the connection to use. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connection">
The connection object to be used by the internal OdbcCommand object
that will execute the statement. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OdbcConnection object is already available. The SQL object will automatically
open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("{call spGetEmployees(?)}", connection);
sp.Parameters.Add("?", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Odbc.StoredProcedure.#ctor(System.String,System.Data.Odbc.OdbcConnection,System.Data.Odbc.OdbcTransaction)">
<summary>
Constructs the object and sets the text for the statement
and the connection and transaction to use. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connection">
The connection object to be used by the internal OdbcCommand object
that will execute the statement. </param>
<param name="transaction">
The transaction object to be used by the internal OdbcCommand object
that will execute the statement. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OdbcConnection object and an OdbcTransaction object are already available. The SQL
object will automatically open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.Odbc.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("{call spGetEmployees(?)}", connection, transaction);
sp.Parameters.Add("?", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="T:AMS.ADO.OleDb.SQL">
<summary>
Represents an SQL statement to be executed against an OLEDB data source. </summary>
<remarks>
This class encapsulates the OleDbCommand class with the added convenience of connection
management. It automatically opens the connection if it needs to, uses it, and closes
it if it's no longer needed. This can significantly cut down the amount of repetitive
code normally required for connection management and helps to ensure that a connection
is not left open inadvertently. </remarks>
</member>
<member name="F:AMS.ADO.OleDb.SQL.m_command">
<summary>
OleDbCommand object used for command execution. </summary>
</member>
<member name="F:AMS.ADO.OleDb.SQL.m_connectionWasOpen">
<summary>
Indicator of whether the connection is already open when the command gets executed
so that it can be left alone when Dispose is called. </summary>
</member>
<member name="F:AMS.ADO.OleDb.SQL.m_connectionString">
<summary>
String used by the OleDbConnection object to connect to the database. </summary>
</member>
<member name="M:AMS.ADO.OleDb.SQL.#ctor">
<summary>
Constructs the object. </summary>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.OleDb.SQL.CommandText"/>
and <see cref="P:AMS.ADO.OleDb.SQL.ConnectionString"/> properties be set before the command
can be executed.
<example>Here's an example:
<code>
SQL sql = new SQL();
sql.ConnectionString = connectionString;
sql.CommandText = "INSERT INTO ...";
sql.Parameters.Add("?", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OleDb.SQL.#ctor(System.String)">
<summary>
Constructs the object and sets the text for the command. </summary>
<param name="sql">
The text for the command to be executed. </param>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.OleDb.SQL.ConnectionString"/>
property be set before the command can be executed.
<example>Here's an example:
<code>
SQL sql = new SQL("SELECT COUNT(*) FROM ...");
sql.ConnectionString = connectionString;
sql.Parameters.Add("?", value);
int count = sql.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OleDb.SQL.#ctor(System.String,System.String)">
<summary>
Constructs the object and sets the text for the command
and the connection string. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connectionString">
The connection string to use when connecting to the database where
the command will be executed. </param>
<remarks>
This constructor offers the most convenient way to create the SQL object. The
SQL and connection string are passed together and commands may then be executed
without worrying about connection management issues.
After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT Description FROM ...", connectionString);
sql.Parameters.Add("?", value);
string description = sql.ExecuteString(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OleDb.SQL.#ctor(System.String,System.Data.OleDb.OleDbConnection)">
<summary>
Constructs the object and sets the text for the command
and the connection to use. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connection">
The connection object to be used by the internal OleDbCommand object
that will execute the command. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OleDbConnection object is already available. The SQL object will automatically
open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("UPDATE ...", connection);
sql.Parameters.Add("?", value);
int rows = sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OleDb.SQL.#ctor(System.String,System.Data.OleDb.OleDbConnection,System.Data.OleDb.OleDbTransaction)">
<summary>
Constructs the object and sets the text for the command
and the connection and transaction to use. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connection">
The connection object to be used by the internal OleDbCommand object
that will execute the command. </param>
<param name="transaction">
The transaction object to be used by the internal OleDbCommand object
that will execute the command. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OleDbConnection object and an OleDbTransaction object are already available. The SQL
object will automatically open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("INSERT INTO ...", connection, transaction);
sql.Parameters.Add("?", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OleDb.SQL.Connect">
<summary>
Opens the connection of the internal OleDbCommand object, based on
the <see cref="P:AMS.ADO.OleDb.SQL.ConnectionString"/> or connection previously set. </summary>
<exception cref="T:System.NullReferenceException">Both ConnectionString and Connection are null. </exception>
</member>
<member name="M:AMS.ADO.OleDb.SQL.Dispose">
<summary>
Disposes of the internal OleDbCommand object's connection, if it was created locally;
otherwise it is left in the same state as it was found. </summary>
</member>
<member name="M:AMS.ADO.OleDb.SQL.ExecuteReader">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteReader on the internal OleDbCommand object.</summary>
<returns>
The return value is an OleDbDataReader object. </returns>
<remarks>
If a temporary connection is created or a connection was passed in
a Closed state, it will be automatically closed when the OleDbDataReader
object is closed.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT * FROM ...", connectionString);
sql.Parameters.Add("?", value);
using (OleDbDataReader reader = sql.ExecuteReader())
{
...
} // disposes of reader and the query's connection </code></example></remarks>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#ExecuteReader">
<summary>
Opens a database connection and executes the query by
calling ExecuteReader on the internal IDbCommand object.</summary>
<returns>
The return value is an IDataReader object. </returns>
<remarks>
If a temporary connection is created or a connection was passed in
a Closed state, it will be automatically closed when the IDataReader
object is closed. </remarks>
</member>
<member name="M:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#ExecuteReader(System.Data.CommandBehavior)">
<summary>
Opens a database connection and executes the query by
calling ExecuteReader on the internal IDbCommand object.</summary>
<param name="behavior">
One of the CommandBehavior values. </param>
<returns>
The return value is an IDataReader object. </returns>
</member>
<member name="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])">
<summary>
Opens a temporary database connection, executes the query, and
returns the results inside a DataSet object. </summary>
<param name="tables">
The array of names of the source tables to use for table mapping. </param>
<returns>
The return value is a DataSet object. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT * FROM ...", connectionString);
sql.Parameters.Add("?", value);
DataSet ds = sql.ExecuteDataSet(); </code></example></remarks>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])">
<summary>
Opens a temporary database connection, executes the query, and
appends the results to a DataSet object. </summary>
<param name="ds">
The DataSet object to be filled with the results of the sql. </param>
<param name="tables">
The array of names of the source tables to use for table mapping. </param>
<returns>
The return value is the same DataSet object passed in as a parameter. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
DataSet ds = new DataSet();
...
SQL sql = new SQL("SELECT * FROM SomeTable", connectionString);
sql.Parameters.Add("?", value);
sql.ExecuteDataSet(ds, "SomeTable"); </code></example></remarks>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OleDb.SQL.ExecuteScalar">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteScalar on the internal OleDbCommand object.</summary>
<returns>
The return value is the first column of the first row in the result set,
or null if the result set is empty. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT COUNT(*) FROM ...", connectionString);
sql.Parameters.Add("?", value);
int count = (int)sql.ExecuteScalar(); </code></example></remarks>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OleDb.SQL.ExecuteString">
<summary>
Calls <see cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/> and casts the result to a string. </summary>
<returns>
The return value is the first column of the first row in the result set
converted to a string. If the first column of the first row is DBNull.Value, the return
value is an empty string. If the result set is empty, the return value is null. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT name FROM ...", connectionString);
sql.Parameters.Add("?", value);
string name = sql.ExecuteString(); </code></example></remarks>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OleDb.SQL.ExecuteInt">
<summary>
Calls <see cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/> and casts the result to an int. </summary>
<returns>
The return value is the first column of the first row in the result set
cast to an int. If the first column of the first row is DBNull.Value or cannot be
converted to an int, the return value is 0. If the result set is empty,
the return value is 0. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT age FROM ...", connectionString);
sql.Parameters.Add("?", value);
int age = sql.ExecuteInt(); </code></example></remarks>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OleDb.SQL.ExecuteNonQuery">
<summary>
Opens a temporary database connection and executes the command by
calling ExecuteNonQuery on the internal OleDbCommand object. </summary>
<returns>
The return value is the number of rows affected. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("INSERT INTO ...", connection);
sql.Parameters.Add("?", value);
int rows = sql.ExecuteNonQuery(); </code></example></remarks>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OleDb.SQL.ExecuteDataSet(System.String[])"/>
</member>
<member name="M:AMS.ADO.OleDb.SQL.Cancel">
<summary>
Attempts to cancels the execution of the internal OleDbCommand object. </summary>
<remarks>
If there is nothing to cancel, nothing happens. However, if there is a command
in process, and the attempt to cancel fails, no exception is generated. </remarks>
</member>
<member name="M:AMS.ADO.OleDb.SQL.CreateParameter">
<summary>
Creates a new instance of a OleDbParameter object. </summary>
</member>
<member name="M:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#CreateParameter">
<summary>
Creates a new instance of an IDbDataParameter object. </summary>
</member>
<member name="M:AMS.ADO.OleDb.SQL.Prepare">
<summary>
Opens a database connection and creates a prepared
(or compiled) version of the command on the data source. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.CommandText">
<summary>
Gets or sets the text for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.CommandType">
<summary>
Gets or sets the type for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.CommandTimeout">
<summary>
Gets or sets the timeout for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.ConnectionString">
<summary>
Gets or sets the connection string to use when connecting to the
database where the command will be executed. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.Connection">
<summary>
Gets the OleDbConnection object associated with the internal OleDbCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#Connection">
<summary>
Gets or sets the OleDbConnection object associated with the internal OleDbCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.Transaction">
<summary>
Gets the OleDbTransaction object associated with the internal OleDbCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#Transaction">
<summary>
Gets or sets the OleDbTransaction object associated with the internal OleDbCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.Parameters">
<summary>
Gets the collection of OleDbParameter objects associated with the
internal OleDbCommand object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.System#Data#IDbCommand#Parameters">
<summary>
Gets the collection of IDataParameter objects associated with the
internal OleDbCommand object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OleDb.SQL.UpdatedRowSource">
<summary>
Gets or sets how command results are applied to the DataRow when
used by the Update method of a DbDataAdapter. </summary>
</member>
<member name="T:AMS.ADO.OleDb.StoredProcedure">
<summary>
Represents a stored procedure to be executed against an OLEDB data source. </summary>
<remarks>
This class encapsulates the OleDbCommand class (configured to execute a stored procedure)
with the added convenience of connection management. It automatically opens the connection
if it needs to, uses it, and closes it if it's no longer needed. This can significantly cut
down the amount of repetitive code normally required for connection management and helps
to ensure that a connection is not left open inadvertently. </remarks>
</member>
<member name="M:AMS.ADO.OleDb.StoredProcedure.#ctor">
<summary>
Constructs the object. </summary>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.OleDb.SQL.CommandText"/>
and <see cref="P:AMS.ADO.OleDb.SQL.ConnectionString"/> properties be set before the command
can be executed.
<example>Here's an example:
<code>
StoredProcedure sp = new StoredProcedure();
sp.ConnectionString = connectionString;
sp.CommandText = "spGetEmployees";
sp.Parameters.Add("?", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OleDb.StoredProcedure.#ctor(System.String)">
<summary>
Constructs the object and sets the text for the command. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.OleDb.SQL.ConnectionString"/>
property be set before the command can be executed.
<example>Here's an example:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees");
sp.ConnectionString = connectionString;
sp.Parameters.Add("?", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OleDb.StoredProcedure.#ctor(System.String,System.String)">
<summary>
Constructs the object and sets the text for the command
and the connection string. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connectionString">
The connection string to use when connecting to the database where
the command will be executed. </param>
<remarks>
This constructor offers the most convenient way to create the StoredProcedure object. The
SQL and connection string are passed together and commands may then be executed
without worrying about connection management issues.
After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees", connectionString);
sp.Parameters.Add("?", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OleDb.StoredProcedure.#ctor(System.String,System.Data.OleDb.OleDbConnection)">
<summary>
Constructs the object and sets the text for the statement
and the connection to use. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connection">
The connection object to be used by the internal OleDbCommand object
that will execute the statement. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OleDbConnection object is already available. The SQL object will automatically
open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees", connection);
sp.Parameters.Add("?", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OleDb.StoredProcedure.#ctor(System.String,System.Data.OleDb.OleDbConnection,System.Data.OleDb.OleDbTransaction)">
<summary>
Constructs the object and sets the text for the statement
and the connection and transaction to use. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connection">
The connection object to be used by the internal OleDbCommand object
that will execute the statement. </param>
<param name="transaction">
The transaction object to be used by the internal OleDbCommand object
that will execute the statement. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OleDbConnection object and an OleDbTransaction object are already available. The SQL
object will automatically open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.OleDb.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees", connection, transaction);
sp.Parameters.Add("?", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="T:AMS.ADO.OracleClient.SQL">
<summary>
Represents an SQL statement to be executed against an Oracle database. </summary>
<remarks>
This class encapsulates the OracleCommand class with the added convenience of connection
management. It automatically opens the connection if it needs to, uses it, and closes
it if it's no longer needed. This can significantly cut down the amount of repetitive
code normally required for connection management and helps to ensure that a connection
is not left open inadvertently. </remarks>
</member>
<member name="F:AMS.ADO.OracleClient.SQL.m_command">
<summary>
OracleCommand object used for command execution. </summary>
</member>
<member name="F:AMS.ADO.OracleClient.SQL.m_connectionWasOpen">
<summary>
Indicator of whether the connection is already open when the command gets executed
so that it can be left alone when Dispose is called. </summary>
</member>
<member name="F:AMS.ADO.OracleClient.SQL.m_connectionString">
<summary>
String used by the OracleConnection object to connect to the database. </summary>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.#ctor">
<summary>
Constructs the object. </summary>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.OracleClient.SQL.CommandText"/>
and <see cref="P:AMS.ADO.OracleClient.SQL.ConnectionString"/> properties be set before the command
can be executed.
<example>Here's an example:
<code>
SQL sql = new SQL();
sql.ConnectionString = connectionString;
sql.CommandText = "INSERT INTO ...";
sql.Parameters.Add("P1", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.#ctor(System.String)">
<summary>
Constructs the object and sets the text for the command. </summary>
<param name="sql">
The text for the command to be executed. </param>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.OracleClient.SQL.ConnectionString"/>
property be set before the command can be executed.
<example>Here's an example:
<code>
SQL sql = new SQL("SELECT COUNT(*) FROM ...");
sql.ConnectionString = connectionString;
sql.Parameters.Add("P1", value);
int count = sql.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.#ctor(System.String,System.String)">
<summary>
Constructs the object and sets the text for the command
and the connection string. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connectionString">
The connection string to use when connecting to the database where
the command will be executed. </param>
<remarks>
This constructor offers the most convenient way to create the SQL object. The
SQL and connection string are passed together and commands may then be executed
without worrying about connection management issues.
After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT Description FROM ...", connectionString);
sql.Parameters.Add("P1", value);
string description = sql.ExecuteString(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.#ctor(System.String,System.Data.OracleClient.OracleConnection)">
<summary>
Constructs the object and sets the text for the command
and the connection to use. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connection">
The connection object to be used by the internal OracleCommand object
that will execute the command. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OracleConnection object is already available. The SQL object will automatically
open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("UPDATE ...", connection);
sql.Parameters.Add("P1", value);
int rows = sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.#ctor(System.String,System.Data.OracleClient.OracleConnection,System.Data.OracleClient.OracleTransaction)">
<summary>
Constructs the object and sets the text for the command
and the connection and transaction to use. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connection">
The connection object to be used by the internal OracleCommand object
that will execute the command. </param>
<param name="transaction">
The transaction object to be used by the internal OracleCommand object
that will execute the command. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OracleConnection object and an OracleTransaction object are already available. The SQL
object will automatically open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("INSERT INTO ...", connection, transaction);
sql.Parameters.Add("P1", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.Connect">
<summary>
Opens the connection of the internal OracleCommand object, based on
the <see cref="P:AMS.ADO.OracleClient.SQL.ConnectionString"/> or connection previously set. </summary>
<exception cref="T:System.NullReferenceException">Both ConnectionString and Connection are null. </exception>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.Dispose">
<summary>
Disposes of the internal OracleCommand object's connection, if it was created locally;
otherwise it is left in the same state as it was found. </summary>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.ExecuteReader">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteReader on the internal OracleCommand object.</summary>
<returns>
The return value is an OracleDataReader object. </returns>
<remarks>
If a temporary connection is created or a connection was passed in
a Closed state, it will be automatically closed when the OracleDataReader
object is closed.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT * FROM ...", connectionString);
sql.Parameters.Add("P1", value);
using (OracleDataReader reader = sql.ExecuteReader())
{
...
} // disposes of reader and the query's connection </code></example></remarks>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#ExecuteReader">
<summary>
Opens a database connection and executes the query by
calling ExecuteReader on the internal IDbCommand object.</summary>
<returns>
The return value is an IDataReader object. </returns>
<remarks>
If a temporary connection is created or a connection was passed in
a Closed state, it will be automatically closed when the IDataReader
object is closed. </remarks>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#ExecuteReader(System.Data.CommandBehavior)">
<summary>
Opens a database connection and executes the query by
calling ExecuteReader on the internal IDbCommand object.</summary>
<param name="behavior">
One of the CommandBehavior values. </param>
<returns>
The return value is an IDataReader object. </returns>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])">
<summary>
Opens a temporary database connection, executes the query, and
returns the results inside a DataSet object. </summary>
<param name="tables">
The array of names of the source tables to use for table mapping. </param>
<returns>
The return value is a DataSet object. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT * FROM ...", connectionString);
sql.Parameters.Add("P1", value);
DataSet ds = sql.ExecuteDataSet(); </code></example></remarks>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])">
<summary>
Opens a temporary database connection, executes the query, and
appends the results to a DataSet object. </summary>
<param name="ds">
The DataSet object to be filled with the results of the sql. </param>
<param name="tables">
The array of names of the source tables to use for table mapping. </param>
<returns>
The return value is the same DataSet object passed in as a parameter. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
DataSet ds = new DataSet();
...
SQL sql = new SQL("SELECT * FROM SomeTable", connectionString);
sql.Parameters.Add("P1", value);
sql.ExecuteDataSet(ds, "SomeTable"); </code></example></remarks>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.ExecuteScalar">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteScalar on the internal OracleCommand object.</summary>
<returns>
The return value is the first column of the first row in the result set,
or null if the result set is empty. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT COUNT(*) FROM ...", connectionString);
sql.Parameters.Add("P1", value);
int count = (int)sql.ExecuteScalar(); </code></example></remarks>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.ExecuteString">
<summary>
Calls <see cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/> and casts the result to a string. </summary>
<returns>
The return value is the first column of the first row in the result set
converted to a string. If the first column of the first row is DBNull.Value, the return
value is an empty string. If the result set is empty, the return value is null. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT name FROM ...", connectionString);
sql.Parameters.Add("P1", value);
string name = sql.ExecuteString(); </code></example></remarks>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.ExecuteInt">
<summary>
Calls <see cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/> and casts the result to an int. </summary>
<returns>
The return value is the first column of the first row in the result set
cast to an int. If the first column of the first row is DBNull.Value or cannot be
converted to an int, the return value is 0. If the result set is empty,
the return value is 0. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT age FROM ...", connectionString);
sql.Parameters.Add("P1", value);
int age = sql.ExecuteInt(); </code></example></remarks>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.ExecuteNonQuery">
<summary>
Opens a temporary database connection and executes the command by
calling ExecuteNonQuery on the internal OracleCommand object. </summary>
<returns>
The return value is the number of rows affected. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("INSERT INTO ...", connection);
sql.Parameters.Add("P1", value);
int rows = sql.ExecuteNonQuery(); </code></example></remarks>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteDataSet(System.String[])"/>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.Cancel">
<summary>
Attempts to cancels the execution of the internal OracleCommand object. </summary>
<remarks>
If there is nothing to cancel, nothing happens. However, if there is a command
in process, and the attempt to cancel fails, no exception is generated. </remarks>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.CreateParameter">
<summary>
Creates a new instance of a OracleParameter object. </summary>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#CreateParameter">
<summary>
Creates a new instance of an IDbDataParameter object. </summary>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.Prepare">
<summary>
Opens a database connection and creates a prepared
(or compiled) version of the command on the data source. </summary>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.CommandText">
<summary>
Gets or sets the text for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.CommandType">
<summary>
Gets or sets the type for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#CommandTimeout">
<summary>
Gets or sets the timeout for the command to be executed. </summary>
<remarks>
Note: This property is not part of OracleCommand until .NET 2.0. </remarks>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.ConnectionString">
<summary>
Gets or sets the connection string to use when connecting to the
database where the command will be executed. </summary>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.Connection">
<summary>
Gets the OracleConnection object associated with the internal OracleCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#Connection">
<summary>
Gets or sets the OracleConnection object associated with the internal OracleCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.Transaction">
<summary>
Gets the OracleTransaction object associated with the internal OracleCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#Transaction">
<summary>
Gets or sets the OracleTransaction object associated with the internal OracleCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.Parameters">
<summary>
Gets the collection of OracleParameter objects associated with the
internal OracleCommand object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.System#Data#IDbCommand#Parameters">
<summary>
Gets the collection of IDataParameter objects associated with the
internal OracleCommand object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.OracleClient.SQL.UpdatedRowSource">
<summary>
Gets or sets how command results are applied to the DataRow when
used by the Update method of a DbDataAdapter. </summary>
</member>
<member name="T:AMS.ADO.OracleClient.StoredProcedure">
<summary>
Represents a stored procedure to be executed against an Oracle database. </summary>
<remarks>
This class encapsulates the OracleCommand class (configured to execute a stored procedure)
with the added convenience of connection management. It automatically opens the connection
if it needs to, uses it, and closes it if it's no longer needed. This can significantly cut
down the amount of repetitive code normally required for connection management and helps
to ensure that a connection is not left open inadvertently. </remarks>
</member>
<member name="M:AMS.ADO.OracleClient.StoredProcedure.#ctor">
<summary>
Constructs the object. </summary>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.OracleClient.SQL.CommandText"/>
and <see cref="P:AMS.ADO.OracleClient.SQL.ConnectionString"/> properties be set before the command
can be executed.
<example>Here's an example:
<code>
StoredProcedure sp = new StoredProcedure();
sp.ConnectionString = connectionString;
sp.CommandText = "spGetEmployees";
sp.Parameters.Add("P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OracleClient.StoredProcedure.#ctor(System.String)">
<summary>
Constructs the object and sets the text for the command. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.OracleClient.SQL.ConnectionString"/>
property be set before the command can be executed.
<example>Here's an example:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees");
sp.ConnectionString = connectionString;
sp.Parameters.Add("P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OracleClient.StoredProcedure.#ctor(System.String,System.String)">
<summary>
Constructs the object and sets the text for the command
and the connection string. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connectionString">
The connection string to use when connecting to the database where
the command will be executed. </param>
<remarks>
This constructor offers the most convenient way to create the StoredProcedure object. The
SQL and connection string are passed together and commands may then be executed
without worrying about connection management issues.
After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees", connectionString);
sp.Parameters.Add("P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OracleClient.StoredProcedure.#ctor(System.String,System.Data.OracleClient.OracleConnection)">
<summary>
Constructs the object and sets the text for the statement
and the connection to use. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connection">
The connection object to be used by the internal OracleCommand object
that will execute the statement. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OracleConnection object is already available. The SQL object will automatically
open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees", connection);
sp.Parameters.Add("P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OracleClient.StoredProcedure.#ctor(System.String,System.Data.OracleClient.OracleConnection,System.Data.OracleClient.OracleTransaction)">
<summary>
Constructs the object and sets the text for the statement
and the connection and transaction to use. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connection">
The connection object to be used by the internal OracleCommand object
that will execute the statement. </param>
<param name="transaction">
The transaction object to be used by the internal OracleCommand object
that will execute the statement. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
OracleConnection object and an OracleTransaction object are already available. The SQL
object will automatically open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.OracleClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees", connection, transaction);
sp.Parameters.Add("P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="T:AMS.ADO.SqlClient.SQL">
<summary>
Represents an SQL statement to be executed against an SQL Server database. </summary>
<remarks>
This class encapsulates the SqlCommand class with the added convenience of connection
management. It automatically opens the connection if it needs to, uses it, and closes
it if it's no longer needed. This can significantly cut down the amount of repetitive
code normally required for connection management and helps to ensure that a connection
is not left open inadvertently. </remarks>
</member>
<member name="F:AMS.ADO.SqlClient.SQL.m_command">
<summary>
SqlCommand object used for command execution. </summary>
</member>
<member name="F:AMS.ADO.SqlClient.SQL.m_connectionWasOpen">
<summary>
Indicator of whether the connection is already open when the command gets executed
so that it can be left alone when Dispose is called. </summary>
</member>
<member name="F:AMS.ADO.SqlClient.SQL.m_connectionString">
<summary>
String used by the SqlConnection object to connect to the database. </summary>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.#ctor">
<summary>
Constructs the object. </summary>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.SqlClient.SQL.CommandText"/>
and <see cref="P:AMS.ADO.SqlClient.SQL.ConnectionString"/> properties be set before the command
can be executed.
<example>Here's an example:
<code>
SQL sql = new SQL();
sql.ConnectionString = connectionString;
sql.CommandText = "INSERT INTO ...";
sql.Parameters.Add("@P1", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.#ctor(System.String)">
<summary>
Constructs the object and sets the text for the command. </summary>
<param name="sql">
The text for the command to be executed. </param>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.SqlClient.SQL.ConnectionString"/>
property be set before the command can be executed.
<example>Here's an example:
<code>
SQL sql = new SQL("SELECT COUNT(*) FROM ...");
sql.ConnectionString = connectionString;
sql.Parameters.Add("@P1", value);
int count = sql.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.#ctor(System.String,System.String)">
<summary>
Constructs the object and sets the text for the command
and the connection string. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connectionString">
The connection string to use when connecting to the database where
the command will be executed. </param>
<remarks>
This constructor offers the most convenient way to create the SQL object. The
SQL and connection string are passed together and commands may then be executed
without worrying about connection management issues.
After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT Description FROM ...", connectionString);
sql.Parameters.Add("@P1", value);
string description = sql.ExecuteString(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.#ctor(System.String,System.Data.SqlClient.SqlConnection)">
<summary>
Constructs the object and sets the text for the command
and the connection to use. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connection">
The connection object to be used by the internal SqlCommand object
that will execute the command. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
SqlConnection object is already available. The SQL object will automatically
open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("UPDATE ...", connection);
sql.Parameters.Add("@P1", value);
int rows = sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.#ctor(System.String,System.Data.SqlClient.SqlConnection,System.Data.SqlClient.SqlTransaction)">
<summary>
Constructs the object and sets the text for the command
and the connection and transaction to use. </summary>
<param name="sql">
The text for the command to be executed. </param>
<param name="connection">
The connection object to be used by the internal SqlCommand object
that will execute the command. </param>
<param name="transaction">
The transaction object to be used by the internal SqlCommand object
that will execute the command. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
SqlConnection object and an SqlTransaction object are already available. The SQL
object will automatically open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("INSERT INTO ...", connection, transaction);
sql.Parameters.Add("@P1", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.Connect">
<summary>
Opens the connection of the internal SqlCommand object, based on
the <see cref="P:AMS.ADO.SqlClient.SQL.ConnectionString"/> or connection previously set. </summary>
<exception cref="T:System.NullReferenceException">Both ConnectionString and Connection are null. </exception>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.Dispose">
<summary>
Disposes of the internal SqlCommand object's connection, if it was created locally;
otherwise it is left in the same state as it was found. </summary>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.ExecuteReader">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteReader on the internal SqlCommand object.</summary>
<returns>
The return value is an SqlDataReader object. </returns>
<remarks>
If a temporary connection is created or a connection was passed in
a Closed state, it will be automatically closed when the SqlDataReader
object is closed.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT * FROM ...", connectionString);
sql.Parameters.Add("@P1", value);
using (SqlDataReader reader = sql.ExecuteReader())
{
...
} // disposes of reader and the query's connection </code></example></remarks>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#ExecuteReader">
<summary>
Opens a database connection and executes the query by
calling ExecuteReader on the internal IDbCommand object.</summary>
<returns>
The return value is an IDataReader object. </returns>
<remarks>
If a temporary connection is created or a connection was passed in
a Closed state, it will be automatically closed when the IDataReader
object is closed. </remarks>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#ExecuteReader(System.Data.CommandBehavior)">
<summary>
Opens a database connection and executes the query by
calling ExecuteReader on the internal IDbCommand object.</summary>
<param name="behavior">
One of the CommandBehavior values. </param>
<returns>
The return value is an IDataReader object. </returns>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])">
<summary>
Opens a temporary database connection, executes the query, and
returns the results inside a DataSet object. </summary>
<param name="tables">
The array of names of the source tables to use for table mapping. </param>
<returns>
The return value is a DataSet object. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT * FROM ...", connectionString);
sql.Parameters.Add("@P1", value);
DataSet ds = sql.ExecuteDataSet(); </code></example></remarks>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.Data.DataSet,System.String[])">
<summary>
Opens a temporary database connection, executes the query, and
appends the results to a DataSet object. </summary>
<param name="ds">
The DataSet object to be filled with the results of the sql. </param>
<param name="tables">
The array of names of the source tables to use for table mapping. </param>
<returns>
The return value is the same DataSet object passed in as a parameter. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
DataSet ds = new DataSet();
...
SQL sql = new SQL("SELECT * FROM SomeTable", connectionString);
sql.Parameters.Add("@P1", value);
sql.ExecuteDataSet(ds, "SomeTable"); </code></example></remarks>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.ExecuteScalar">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteScalar on the internal SqlCommand object.</summary>
<returns>
The return value is the first column of the first row in the result set,
or null if the result set is empty. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT COUNT(*) FROM ...", connectionString);
sql.Parameters.Add("@P1", value);
int count = (int)sql.ExecuteScalar(); </code></example></remarks>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.ExecuteString">
<summary>
Calls <see cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/> and casts the result to a string. </summary>
<returns>
The return value is the first column of the first row in the result set
converted to a string. If the first column of the first row is DBNull.Value, the return
value is an empty string. If the result set is empty, the return value is null. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT name FROM ...", connectionString);
sql.Parameters.Add("@P1", value);
string name = sql.ExecuteString(); </code></example></remarks>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.ExecuteInt">
<summary>
Calls <see cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/> and casts the result to an int. </summary>
<returns>
The return value is the first column of the first row in the result set
cast to an int. If the first column of the first row is DBNull.Value or cannot be
converted to an int, the return value is 0. If the result set is empty,
the return value is 0. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT age FROM ...", connectionString);
sql.Parameters.Add("@P1", value);
int age = sql.ExecuteInt(); </code></example></remarks>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.ExecuteNonQuery">
<summary>
Opens a temporary database connection and executes the command by
calling ExecuteNonQuery on the internal SqlCommand object. </summary>
<returns>
The return value is the number of rows affected. </returns>
<remarks>
If a temporary connection is created, it is automatically disposed of; otherwise
it is opened and left in the same state as it was found.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("INSERT INTO ...", connection);
sql.Parameters.Add("@P1", value);
int rows = sql.ExecuteNonQuery(); </code></example></remarks>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteReader"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.ExecuteXmlReader">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteXmlReader on the internal SqlCommand object.</summary>
<returns>
The return value is an XmlReader object. </returns>
<remarks>
If a connection is created internally or a connection object was passed in
a Closed state, it will be automatically closed when the SqlDataReader
object is closed.
<example>Here's an example of its usage:
<code>
using (SQL sql = new SQL("SELECT * FROM ... FOR XML AUTO", connectionString))
{
sql.Parameters.Add("@P1", value);
using (XmlReader reader = sql.ExecuteXmlReader())
{
...
} // disposed of reader
} // disposed of the query's connection </code></example></remarks>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteString"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteInt"/>
<seealso cref="M:AMS.ADO.SqlClient.SQL.ExecuteDataSet(System.String[])"/>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.Cancel">
<summary>
Attempts to cancels the execution of the internal SqlCommand object. </summary>
<remarks>
If there is nothing to cancel, nothing happens. However, if there is a command
in process, and the attempt to cancel fails, no exception is generated. </remarks>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.CreateParameter">
<summary>
Creates a new instance of a SqlParameter object. </summary>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#CreateParameter">
<summary>
Creates a new instance of an IDbDataParameter object. </summary>
</member>
<member name="M:AMS.ADO.SqlClient.SQL.Prepare">
<summary>
Opens a database connection and creates a prepared
(or compiled) version of the command on the data source. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.CommandText">
<summary>
Gets or sets the text for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.CommandType">
<summary>
Gets or sets the type for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.CommandTimeout">
<summary>
Gets or sets the timeout for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.ConnectionString">
<summary>
Gets or sets the connection string to use when connecting to the
database where the command will be executed. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.Connection">
<summary>
Gets the SqlConnection object associated with the internal SqlCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#Connection">
<summary>
Gets or sets the SqlConnection object associated with the internal SqlCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.Transaction">
<summary>
Gets the SqlTransaction object associated with the internal SqlCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#Transaction">
<summary>
Gets the SqlTransaction object associated with the internal SqlCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.Parameters">
<summary>
Gets the collection of SqlParameter objects associated with the
internal SqlCommand object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.System#Data#IDbCommand#Parameters">
<summary>
Gets the collection of IDataParameter objects associated with the
internal SqlCommand object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.SqlClient.SQL.UpdatedRowSource">
<summary>
Gets or sets how command results are applied to the DataRow when
used by the Update method of a DbDataAdapter. </summary>
</member>
<member name="T:AMS.ADO.SqlClient.StoredProcedure">
<summary>
Represents a stored procedure to be executed against an SQL Server database. </summary>
<remarks>
This class encapsulates the SqlCommand class (configured to execute a stored procedure)
with the added convenience of connection management. It automatically opens the connection
if it needs to, uses it, and closes it if it's no longer needed. This can significantly cut
down the amount of repetitive code normally required for connection management and helps
to ensure that a connection is not left open inadvertently. </remarks>
</member>
<member name="M:AMS.ADO.SqlClient.StoredProcedure.#ctor">
<summary>
Constructs the object. </summary>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.SqlClient.SQL.CommandText"/>
and <see cref="P:AMS.ADO.SqlClient.SQL.ConnectionString"/> properties be set before the command
can be executed.
<example>Here's an example:
<code>
StoredProcedure sp = new StoredProcedure();
sp.ConnectionString = connectionString;
sp.CommandText = "SELECT COUNT(*) FROM ...";
sp.Parameters.Add("@P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.SqlClient.StoredProcedure.#ctor(System.String)">
<summary>
Constructs the object and sets the text for the command. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.SqlClient.SQL.ConnectionString"/>
property be set before the command can be executed.
<example>Here's an example:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees");
sp.ConnectionString = connectionString;
sp.Parameters.Add("@P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.SqlClient.StoredProcedure.#ctor(System.String,System.String)">
<summary>
Constructs the object and sets the text for the command
and the connection string. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connectionString">
The connection string to use when connecting to the database where
the command will be executed. </param>
<remarks>
This constructor offers the most convenient way to create the StoredProcedure object. The
SQL and connection string are passed together and commands may then be executed
without worrying about connection management issues.
After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees", connectionString);
sp.Parameters.Add("@P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.SqlClient.StoredProcedure.#ctor(System.String,System.Data.SqlClient.SqlConnection)">
<summary>
Constructs the object and sets the text for the statement
and the connection to use. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connection">
The connection object to be used by the internal SqlCommand object
that will execute the statement. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
SqlConnection object is already available. The SQL object will automatically
open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("spGetEmployees", connection);
sp.Parameters.Add("@P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.SqlClient.StoredProcedure.#ctor(System.String,System.Data.SqlClient.SqlConnection,System.Data.SqlClient.SqlTransaction)">
<summary>
Constructs the object and sets the text for the statement
and the connection and transaction to use. </summary>
<param name="name">
The name of the stored procedure to be executed. </param>
<param name="connection">
The connection object to be used by the internal SqlCommand object
that will execute the statement. </param>
<param name="transaction">
The transaction object to be used by the internal SqlCommand object
that will execute the statement. </param>
<remarks>
This constructor offers a convenient way to create the SQL object when an
SqlConnection object and an SqlTransaction object are already available. The SQL
object will automatically open the connection if necessary and return it to its original state when finished with it.
After creating the object, use the <see cref="P:AMS.ADO.SqlClient.SQL.Parameters"/> property to
assign values to any of its parameters and one of the Execute
methods to run it.
<example>Here's an example of its usage:
<code>
StoredProcedure sp = new StoredProcedure("SELECT COUNT(*) FROM ...", connection, transaction);
sp.Parameters.Add("@P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
</members>
</doc>
Submit an article or tip