<?xml version="1.0"?>
<doc>
<assembly>
<name>AMS.ADO</name>
</assembly>
<members>
<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="T:AMS.ADO.Command`7">
<summary>
Generic class used to encapsulate an SQL command to be executed against a database. </summary>
</member>
<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``1(``0,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="F:AMS.ADO.Command`7.m_command">
<summary>
CommandClass object used for command execution. </summary>
</member>
<member name="F:AMS.ADO.Command`7.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.Command`7.m_connectionString">
<summary>
String used by the ConnectionClass object to connect to the database. </summary>
</member>
<member name="M:AMS.ADO.Command`7.#ctor">
<summary>
Constructs the object. </summary>
<remarks>
Creating the object this way requires that the <see cref="P:AMS.ADO.Command`7.CommandText"/>
and <see cref="P:AMS.ADO.Command`7.ConnectionString"/> properties be set before the command
can be executed.
<example>Here's an example:
<code>
Command cmd = new Command();
cmd.ConnectionString = connectionString;
cmd.CommandText = "INSERT INTO ...";
cmd.Parameters.AddWithValue("@P1", value);
cmd.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Command`7.#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.Command`7.ConnectionString"/>
property be set before the command can be executed.
<example>Here's an example:
<code>
Command cmd = new Command("SELECT COUNT(*) FROM ...");
cmd.ConnectionString = connectionString;
cmd.Parameters.AddWithValue("@P1", value);
int count = cmd.ExecuteInt(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Command`7.#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 Command 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.Command`7.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>
Command cmd = new Command("SELECT Description FROM ...", connectionString);
cmd.Parameters.AddWithValue("@P1", value);
string description = cmd.ExecuteString(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Command`7.#ctor(System.String,`0)">
<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 CommandClass object
that will execute the command. </param>
<remarks>
This constructor offers a convenient way to create the Command object when a
ConnectionClass object is already available. The Command 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.Command`7.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>
Command cmd = new Command("UPDATE ...", connection);
cmd.Parameters.AddWithValue("@P1", value);
int rows = cmd.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Command`7.#ctor(System.String,`0,`1)">
<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 CommandClass object
that will execute the command. </param>
<param name="transaction">
The transaction object to be used by the internal CommandClass object
that will execute the command. </param>
<remarks>
This constructor offers a convenient way to create the Command object when a
ConnectionClass object and a TransactionClass object are already available. The Command
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.Command`7.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>
Command cmd = new Command("INSERT INTO ...", connection, transaction);
cmd.Parameters.AddWithValue("@P1", value);
cmd.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.Command`7.Connect">
<summary>
Opens the connection of the internal CommandClass object, based on
the <see cref="P:AMS.ADO.Command`7.ConnectionString"/> or connection previously set. </summary>
<exception cref="T:System.NullReferenceException">Both ConnectionString and Connection are null. </exception>
</member>
<member name="M:AMS.ADO.Command`7.Dispose">
<summary>
Disposes of the internal CommandClass 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.Command`7.ExecuteReader">
<summary>
Opens a database connection and executes the query by
calling ExecuteReader on the internal CommandClass object.</summary>
<returns>
The return value is a DataReaderClass 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 DataReaderClass
object is closed.
<example>Here's an example of its usage:
<code>
SQL sql = new SQL("SELECT * FROM ...", connectionString);
sql.Parameters.AddWithValue("@P1", value);
using (SqlDataReader reader = sql.ExecuteReader())
{
...
} // disposes of reader and the query's connection </code></example></remarks>
<seealso cref="M:AMS.ADO.Command`7.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteString"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Command`7.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.Command`7.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.Command`7.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.AddWithValue("@P1", value);
DataSet ds = sql.ExecuteDataSet(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Command`7.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteString"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Command`7.ExecuteDataSet``1(``0,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>
<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.AddWithValue("@P1", value);
sql.ExecuteDataSet(ds, "SomeTable"); </code></example></remarks>
<seealso cref="M:AMS.ADO.Command`7.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteString"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Command`7.ExecuteScalar">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteScalar on the internal CommandClass 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.AddWithValue("@P1", value);
int count = (int)sql.ExecuteScalar(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Command`7.ExecuteString"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Command`7.ExecuteString">
<summary>
Calls <see cref="M:AMS.ADO.Command`7.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.AddWithValue("@P1", value);
string name = sql.ExecuteString(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Command`7.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Command`7.ExecuteInt">
<summary>
Calls <see cref="M:AMS.ADO.Command`7.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.AddWithValue("@P1", value);
int age = sql.ExecuteInt(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Command`7.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteString"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteNonQuery"/>
</member>
<member name="M:AMS.ADO.Command`7.ExecuteNonQuery">
<summary>
Opens a temporary database connection and executes the command by
calling ExecuteNonQuery on the internal CommandClass 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.AddWithValue("@P1", value);
int rows = sql.ExecuteNonQuery(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Command`7.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteString"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteDataSet(System.String[])"/>
</member>
<member name="M:AMS.ADO.Command`7.Cancel">
<summary>
Attempts to cancels the execution of the internal CommandClass 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.Command`7.CreateParameter">
<summary>
Creates a new instance of a ParameterClass object. </summary>
</member>
<member name="M:AMS.ADO.Command`7.System#Data#IDbCommand#CreateParameter">
<summary>
Creates a new instance of an IDbDataParameter object. </summary>
</member>
<member name="M:AMS.ADO.Command`7.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.Command`7.CommandText">
<summary>
Gets or sets the text for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.Command`7.CommandType">
<summary>
Gets or sets the type for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.Command`7.CommandTimeout">
<summary>
Gets or sets the timeout for the command to be executed. </summary>
</member>
<member name="P:AMS.ADO.Command`7.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.Command`7.Connection">
<summary>
Gets the ConnectionClass object associated with the internal CommandClass
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Command`7.System#Data#IDbCommand#Connection">
<summary>
Gets or sets the IDbConnection object associated with the internal IDbCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Command`7.Transaction">
<summary>
Gets the TransactionClass object associated with the internal CommandClass
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Command`7.System#Data#IDbCommand#Transaction">
<summary>
Gets or sets the IDbTransaction object associated with the internal IDbCommand
object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Command`7.Parameters">
<summary>
Gets the collection of IDataParameter objects associated with the
internal CommandClass object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Command`7.System#Data#IDbCommand#Parameters">
<summary>
Gets the collection of IDataParameter objects associated with the
internal IDbCommand object used to execute the command. </summary>
</member>
<member name="P:AMS.ADO.Command`7.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="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.Command`7.CommandText"/>
and <see cref="P:AMS.ADO.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@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 statement
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 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.Command`7.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.AddWithValue("@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 statement
and the connection and transaction to use. </summary>
<param name="sql">
The text for the statement 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.Command`7.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.AddWithValue("@P1", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</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.Command`7.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteString"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteDataSet(System.String[])"/>
</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.Command`7.CommandText"/>
and <see cref="P:AMS.ADO.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</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="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.Command`7.CommandText"/>
and <see cref="P:AMS.ADO.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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 statement
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 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.Command`7.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.AddWithValue("@P1", 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 statement
and the connection and transaction to use. </summary>
<param name="sql">
The text for the statement 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.Command`7.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.AddWithValue("@P1", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</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.Command`7.CommandText"/>
and <see cref="P:AMS.ADO.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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="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.Command`7.CommandText"/>
and <see cref="P:AMS.ADO.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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 statement
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 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.Command`7.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.AddWithValue("@P1", 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 statement
and the connection and transaction to use. </summary>
<param name="sql">
The text for the statement 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.Command`7.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.AddWithValue("@P1", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</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.Command`7.CommandText"/>
and <see cref="P:AMS.ADO.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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.Command`7.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.AddWithValue("@P1", 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="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.Command`7.CommandText"/>
and <see cref="P:AMS.ADO.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@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 statement
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 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.Command`7.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.AddWithValue("@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 statement
and the connection and transaction to use. </summary>
<param name="sql">
The text for the statement 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.Command`7.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.AddWithValue("@P1", value);
sql.ExecuteNonQuery(); </code></example></remarks>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.ExecuteOracleNonQuery(System.Data.OracleClient.OracleString@)">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteOracleNonQuery on the internal OracleCommand object. </summary>
<param name="rowid">
A base64 string representation of the actual row ID in the server. </param>
<returns>
For UPDATE, INSERT, and DELETE statements, the return value is the number of rows affected by the command.
For CREATE TABLE and DROP TABLE statements, the return value is 0.
For all other types of statements, the return value is -1. </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.AddWithValue("@P1", value);
OracleString rowid;
int rows = sql.ExecuteOracleNonQuery(rowid); </code></example></remarks>
<seealso cref="M:AMS.ADO.Command`7.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteString"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteOracleScalar"/>
</member>
<member name="M:AMS.ADO.OracleClient.SQL.ExecuteOracleScalar">
<summary>
Opens a temporary database connection and executes the query by
calling ExecuteOracleScalar on the internal OracleCommand object. </summary>
<returns>
The first column of the first row in the result set as an Oracle-specific data type,
or a null reference if the result is a REF CURSOR. </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(*) ...", connection);
sql.Parameters.AddWithValue("@P1", value);
object count = sql.ExecuteOracleScalar(); </code></example></remarks>
<seealso cref="M:AMS.ADO.Command`7.ExecuteScalar"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteInt"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteString"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteReader"/>
<seealso cref="M:AMS.ADO.Command`7.ExecuteDataSet(System.String[])"/>
<seealso cref="M:AMS.ADO.OracleClient.SQL.ExecuteOracleNonQuery(System.Data.OracleClient.OracleString@)"/>
</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.Command`7.CommandText"/>
and <see cref="P:AMS.ADO.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@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.Command`7.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.AddWithValue("@P1", value);
int count = sp.ExecuteInt(); </code></example></remarks>
</member>
</members>
</doc>