.NET Data Provider Classes¶

The .NET Data Provider is the runtime component that provides the interface between the .NET application and Ingres or Actian Data Platform.

The .NET Data Provider namespace (Ingres.Client) and its contents follow the same pattern as the Microsoft data providers.

All public static members are safe for multithreaded operations. To reduce unnecessary overhead, instance members are not guaranteed to be thread-safe. If a thread-safe operation on the instance is needed, wrap the operation in one of .NET’s System.Threading synchronization methods to protect the state of the critical section of code.

The base class and interface definition for each class is provided in C# and VB.NET syntax as shown below. However, .NET’s language interoperability feature allows any managed language to use the .NET Data Provider.

C#:Public sealed class IngresParameter : System.Data.Common.DbParameter, IDataParameter, IDbDataParameter, ICloneable

VB.NET:NotInheritable public class IngresParameter Inherits System.Data.Common.DbParameter Implements IDataParameter, IDbDataParameter, ICloneable

For more information on data provider classes, including information on other .NET language syntax and inherited methods and properties, see the Microsoft .NET Framework Developer’s Guide and Microsoft .NET Framework Class Library documentation.

IngresCommand Class¶

The IngresCommand class represents a SQL command or a database procedure that executes against an Ingres or Enterprise Access database.

Parameter placeholders in the SQL command text are represented by a question mark (?).

Database procedures can be invoked by either setting CommandText=”myproc” and CommandType=CommandType.StoredProcedure, or by using the escape sequence format and setting CommandText=”{ call myproc }” and CommandType=CommandType.Text.

The .NET Data Provider does not currently support the following features:

• Multiple active results-sets

• Batched commands consisting of multiple Ingres SQL commands in one IngresCommand object

• Support for Ingres SQL command COPY TABLE

• Support for Ingres SQL command SAVEPOINT

• IngresCommand.ExecuteReader(CommandBehavior.SchemaOnly) is supported for SELECT commands only

IngresCommand Class Declaration¶

The IngresCommand class declarations are:

C#:public sealed class IngresCommand : System.Data.Common.DbCommand, IDbCommand, IDisposable, ICloneable

VB.NET:NotInheritable Public Class IngresCommand Inherits System.Data.Common.DbCommand Implements IDbCommand, IDisposable, ICloneable

IngresCommand Class Example¶

IngresCommand cmd = new IngresCommand(

“SELECT id, name FROM employee WHERE id = ?”);

IngresCommand Class Properties¶

The IngresCommand class properties are:

IngresCommand Class Public Methods¶

The public methods for the IngresCommand class are:

IngresCommand Class Constructors¶

The constructors for the IngresCommand class are:

Sample Program Constructed with .NET Data Provider¶

To construct an application using the .NET Data Provider, the developer creates a series of objects from the data provider’s classes. The following is a simple C# program employing four data provider classes.

.NET 2.0 Programming Model¶

using System;

using System.Configuration;

using System.Data;

using System.Data.Common;

using System.IO;

using Ingres.Client;

class App

{

static public void Main()

{

ConnectionStringSettingsCollection connectionSettings =

        ConfigurationManager.ConnectionStrings;

if (connectionSettings.Count == 0)

        throw new InvalidOperationException(

         "No connection information specified in application configuration file.");

ConnectionStringSettings connectionSetting = connectionSettings[0];

string invariantName      = connectionSetting.ProviderName;

string myConnectionString = connectionSetting.ConnectionString;

DbProviderFactory factory = DbProviderFactories.GetFactory(invariantName);

DbConnection conn =

         factory.CreateConnection();

conn.ConnectionString = myConnectionString;

conn.Open();   // open the Ingres connection

string cmdtext =

        "select table_owner, table_name, " +

        " create_date from iitables " +

        " where table_type in ('T','V') and " +

        " table_name not like 'ii%' and" +

        " table_name not like 'II%'";

DbCommand cmd = conn.CreateCommand();

cmd.CommandText = cmdtext;

//          read the data using the DataReader method

DbDataReader   datareader = cmd.ExecuteReader();

//          write header labels

Console.WriteLine(datareader.GetName(0).PadRight(18) +

datareader.GetName(1).PadRight(34) +

datareader.GetName(2).PadRight(34));

int i = 0;

while (i++ < 10  &&  datareader.Read())

// read and write out a few data rows

{     // write out the three columns to the console

        Console.WriteLine(

        datareader.GetString(0).Substring(0,16).PadRight(18) +

        datareader.GetString(1).PadRight(34) +

                datareader.GetString(2));

}

datareader.Close();

DataSet  ds  = new DataSet("my_list_of_tables");

//          read the data using the DataAdapter method

DbDataAdapter adapter = factory.CreateDataAdapter();

DbCommand adapterCmd = conn.CreateCommand();

adapterCmd.CommandText = cmdtext;

adapter.SelectCommand = adapterCmd;

adapter.Fill(ds);  // fill the dataset

//          write the dataset to an XML file

ds.WriteXml("c:/temp/temp.xml");

conn.Close();   // close the connection

}  // end Main()

}  // end class App

.NET 1.1 Programming Model¶

using System;

using System.IO;

using System.Data;

using Ingres.Client;

class App

{

static public void Main()

{

string myConnectionString =

"Host=myserver.mycompany.com;" +

"User Id=myname;PWD=mypass;" +

"Database=mydatabase";

IngresConnection conn = new IngresConnection(

myConnectionString );

conn.Open();   // open the Ingres connection

string cmdtext = "select table_owner, table_name, " +

"create_date from iitables " +

" where table_type in ('T','V') and " +

" table_name not like 'ii%' and" +

" table_name not like 'II%'";

IngresCommand cmd = new IngresCommand(cmdtext, conn);

//          read the data using the DataReader method

IngresDataReader   datareader = cmd.ExecuteReader();

//          write header labels

Console.WriteLine(datareader.GetName(0).PadRight(18) +

datareader.GetName(1).PadRight(34) +

datareader.GetName(2).PadRight(34));

int i = 0;

while (i++ < 10  &&  datareader.Read())

// read and write out a few data rows

{     // write out the three columns to the console

        Console.WriteLine(

        datareader.GetString(0).Substring(0,16).PadRight(18) +

        datareader.GetString(1).PadRight(34) +

                datareader.GetString(2));

}

datareader.Close();

DataSet  ds  = new DataSet("my_list_of_tables");

//          read the data using the DataAdapter method

IngresDataAdapter adapter = new IngresDataAdapter();

adapter.SelectCommand = new IngresCommand(cmdtext, conn);

adapter.Fill(ds);  // fill the dataset

//          write the dataset to an XML file

ds.WriteXml("c:/temp/temp.xml");

conn.Close();   // close the connection

}  // end Main()

}  // end class App

IngresCommandBuilder Class¶

The IngresCommandBuilder class automatically generates INSERT, DELETE, and UPDATE commands into an IngresDataAdapter object for a simple single-table SELECT query. These commands can be used to reconcile DataSet changes through the IngresDataAdapter associated with the Ingres or Actian Data Platform database.

IngresCommandBuilder Class Declaration¶

The IngresCommandBuilder class can be declared as follows:

C#: public sealed class IngresCommandBuilder : DbCommandBuilder

VB.NET: NotInheritable Public Class IngresCommandBuilder Inherits DbCommandBuilder

IngresCommandBuilder Class Properties¶

The IngresCommandBuilder class properties are:

IngresCommandBuilder Class Methods¶

The public methods available to the IngresCommandBuilder class are:

IngresCommandBuilder Class Constructors¶

The IngresCommandBuilder class has the following constructors:

IngresConnection Class¶

The IngresConnection class represents an open connection to an Ingres database. This class requires a connection string to connect to a target server and database.

IngresConnection Class Declaration¶

The IngresConnection class declaration method signature is:

C#:public sealed class IngresConnection : System.Data.Common.DbConnection, IDbConnection, IDisposable

VB.NET:NotInheritable Public Class IngresConnection Inherits System.Data.Common.DbConnection Implements IDbConnection, IDisposable

IngresConnection Class Example¶

IngresConnection conn = new IngresConnection(“Host=myserver.mycompany.com;Database=mydatabase;” +“User ID=myuid;Password=mypassword;”);conn.Open( );

IngresConnection Class Properties¶

The IngresConnection class has these properties:

IngresConnection Class Public Methods¶

The public methods for the IngresConnection class are:

IngresConnection Class Events¶

The events generated by the IngresConnection are:

IngresConnection Class Constructors¶

The constructors for the IngresConnection class are:

Connection String Keywords¶

Keywords for the ConnectionString property of the IngresConnection class are as follows.

Connection string keywords are case-insensitive. Certain keywords have synonyms. For example, keywords Server and Address are synonyms of Host. Spaces in values are retained. Values can be delimited by double quotes.

BlankDate

Specifies how an Ingresdate blank (empty) result value is to be returned to the application:

BlankDate=null

Returns a null value.

BlankDate=default

Returns the default (9999-12-31 23:59:59).

BlankDate=datetime

Returns a .NET DateTime value with the customized BlankDate value. This option lets you specify your own "magic" DateTime value to represent an Ingres blank date. The format of datetimemust be yyyy-mm-dd hhss [GMT], and the value must be a valid .NET DateTime and Ingresdate value.

If the GMT specification is included, the returned .NET DateTime value is adjusted for the local time zone and returned as a .NET DateTime with DateTimeKind.Local property. For example:

"BlankDate=2099-12-31 12:00:00 GMT;" returns 2099-12-31 12:00:00 GMT converted to local time.

Note:Be careful if the application does an INSERT or UPDATE of the Ingresdate column. If the column is to contain a blank Ingresdate value, the application must map the DBNull or .NET DateTime value back to the Ingresdate column value of blank date. Applications that specify their own BlankDate “magic” values should be consistent with a value. Failure to INSERT or UPDATE these mapped values properly can lead to an inconsistent, confusing mix of blank dates and various “magic” date values in the database.

Character Encoding

Specifies the .NET character encoding name (for example, windows-1252) used for conversions between Unicode and character data types. This keyword allows an alternate .NET character encoding to be specified as an override, or a valid .NET character encoding to be used if the data provider is unable to map the Data Access Server’s installation character set. A code page name can also be specified in “cp” format (for example, “cp1252”).

Compress

Specifies whether network communication blocks are compressed between the data provider and server:

true – (Default) Enables compression. Connection fails if compression is not possible with the server.

false – No compression.

The keyword “compression” is a synonym for “compress.”

Connection Lifetime or Connect Lifetime

Specifies an interval, in seconds, that defines the lifetime of the connection. An inactive connection that has existed longer than the specified interval beyond when it was first opened is removed from the connection pool and is closed.

This parameter will increase the number of physical connections required over the life of the system, but allows the system administrator to release connections and system resources, or balance servers regardless of other pool parameters such as Min Pool Size.

Default: 0 (no checking)

Connection Timeout or Connect Timeout

Specifies the time, in seconds, to wait for an attempted connection to time out if the connection has not completed. Default is 15.

Cursor_mode

Specifies the default cursor concurrency mode, which determines the concurrency of cursors that are not explicitly assigned in the command text (for example, FOR UPDATE or FOR READONLY). Options are:

readonly – (Default) Provides non-updatable cursors for best performance

update – Provides updatable cursors

dbms – The warehouse assigns the cursor concurrency mode.

Database or DB

Specifies the name of the database being connected to: db.

Date_alias

Specifies the alias for the DATE data type. This property is not used directly by the data provider but is sent to the DBMS and affects the processing of query text. Options are:

ansidate – Sets ANSIDATE as the alias (default if SendIngresDates is not set or is set to FALSE).

ingresdate – Sets INGRESDATE as the alias (default if SendIngresDates is set to TRUE).

Date_format or Date_fmt

Specifies the Ingres format for date literals. It corresponds to the Ingres environment variable II_DATE_FORMAT and is assigned the same values. This option is not used directly by the data provider, but is sent to the DBMS and affects the parsing of date literals in query text.

Dbms_user

Specifies the user name to be associated with the DBMS session. This name is equivalent to the Ingres -u flag, which can require administrator privileges.

Dbms_password

Specifies the DBMS password of the user, which is equivalent to the Ingres -P flag.

Decimal_char

Specifies the character that the warehouse will use to separate fractional and non-fractional parts of a number. It corresponds to the Ingres environment variable II_DECIMAL and is assigned the same values. This option is not used directly by the data provider, but is sent to the DBMS and affects the parsing and construction of numeric literals.

Decimal_char=',' specifies the comma (,) character.

Default: period (.) as in 12.34.

Encrypt

Specifies whether encryption is enabled for the connection:

false – (Default) Disables encryption.

true – Enables encryption. Connection fails if encryption is not possible with the server.

Encryption AES Key Size

Specifies the size of the AES key in bits. When client and server have different capabilities, the largest common key size will be used. Valid values are: 128, 192, or 256.

Default: 128

Encryption RSA Key Scope

Defines the scope where an RSA key is used. Options are:

process – (Default) Generates one RSA key in a process. Key is used for all connections originating from that process.

connection – Generates an RSA key for each connection. Key is used only for that connection.

Encryption RSA Key Size

Specifies the size of the RSA key in bits. Valid values are: 1024, 2048, 3072, 4096.

Default: 1024

Enlist

Specifies whether the IngresConnection in the transaction context is automatically enlisted if the creation thread is within a transaction context as established by System.EnterpriseServices.ServicedComponent.

Default: true

Group ID

Specifies the group identifier that has permissions for a group of users.

Host or Server or Address

Specifies the name of the target host server machine with the Data Access Server (DAS).

Multiple host names can be specified as a semicolon-separated list enclosed in parentheses with optional port lists:

Server=(hostname1[:port[,port]];hostname2[:port[,port]])

Example connection string:

Server=(myserver1;myserver2);db=mydatabase;

If a port ID is attached to a host name, any additional port IDs outside the list or specified in the PORT keyword are ignored. If a host name does not have an explicit port ID in the specification, then port IDs in the list that follows the PORT keyword are distributed to the hostname. For example:

Host=(myservera:II6;myserverb);Port=II8,II9;Database=mydb;

is equivalent to:

Host=(myservera:II6;myserverb):II8,II9;Database=mydb;

is equivalent to:

Host=(myservera:II6;myserverb:II8;myserverb:II9);Database=mydb;

To maintain performance, the connection string should specify a hostname and port that the DAS servers typically listen to.

Example: Assume that four DAS servers are started and listening on symbolic ports II7, II8, II9, and II10. The following IngresConnection.ConnectionString will connect a .NET application to the Ingres database using one of the four ports:

Host=myserver;Port=II7,II8,II9,II10;UserID=myuserid;Pwd=mypwd;Database=mydb;

or

Host=myserver:II7,II8,II9,II10;UserID=myuserid;Pwd=mypwd;Database=mydb;

Identifier_Delimiter or IdentifierDelimiter or ID_Delimiter or IDDelimiter

Specifies the character recognized by the data provider to delimit an identifier. Options are:

dquote – (Default) Recognizes only double-quotes.

bracket – Recognizes both double-quotes and brackets. This keyword is for use with products such as Microsoft SQL Server Analysis Services (SSAS), which generate bracket-delimited identifiers in their processing of SQL table and column references.

Max Pool Size

Specifies the maximum number of connections that can be in the pool.

Default: 100

Min Pool Size

Specifies the minimum number of connections that can be in the pool.

Default: 0

Money_format or Money_fmt

Specifies the Ingres format for money literals. It corresponds to the Ingres environment variable II_MONEY_FORMAT and is assigned the same values. This option is not used directly by the data provider, but is sent to the DBMS and affects the processing of query text.

Money_precision or Money_prec

Specifies the precision of money data values. It corresponds to the Ingres environment variable II_MONEY_PREC and is assigned the same values. This option is not used directly by the data provider, but is sent to the DBMS and affects the processing of money values.

Password or PWD

Specifies the password to the database. This value may be case-sensitive depending on the target server.

Persist Security Info

Specifies whether password information from the connection string is returned in a get of the ConnectionString property:

false – (Default) Does not return password information.

true – Returns password information.

Pool Check Interval

Specifies the interval, in seconds, at which inactive connections in the pool that are waiting for work are checked to test if the session is still responsive. Non-responsive connections are closed and removed from the pool.

A value that is too low generates needless query traffic to the warehouse. A value that is too high delays detection of non-responsive servers. An interval of 300 seconds may be a reasonable starting value.

Default: 0 (no checking)

Pool Check Timeout

Specifies the time, in seconds, for an inactive connection in the pool to wait on a non-responsive server before timing out and disconnecting. This keyword has no effect if Pool Check Interval is 0.

Default: 5

Pooling

Enables or disables connection pooling:

true – (Default) Enables connection pooling.

false – Disables connection pooling.

Port

Specifies the port number 27839.

PrefetchBlocks

Specifies the number of data blocks to be prefetched. By default, the rows that fit in one communication data block are prefetched. When this property is set, the prefetch block count is multiplied by the default prefetch row count to determine the number of rows to be prefetched. Depending on the row size and unused space in the rows, the number of blocks retrieved may be different.

Default: 1 (no override to default algorithm)

Role ID

Specifies the role identifier that has associated privileges for the role.

Role Password or Role PWD

Specifies the role password associated with the Role ID.

SendIngresDates

Specifies whether .NET DateTime parameter data is sent as INGRESDATE data type rather than as ANSI date and time data type. Options are:

false – Sends as ANSI date and time type. (Default if date_alias is not set or is set to ANSIDATE.)

true – Sends as INGRESDATE type. (Default if date_alias is set to INGRESDATE.)

For more information, see SendIngresDates Connection Keyword.

Timezone or TZ

Specifies the time zone associated with the client's location. Corresponds to the Ingres environment variable II_TIMEZONE_NAME and is assigned the same values. This information is not used directly by the data provider, but is sent to the DBMS and affects the processing of dates.

User ID or UID

Specifies the name of the authorized user connecting to the warehouse. This value may be case-sensitive depending on the target server.

Vnode_usage

Allows the .NET application to control the portions of the vnode information that are used to establish the connection to the remote warehouse through the Data Access Server. Options are:

connect – (Default) Uses only the vnode connection information.

login – Uses both the vnode connection and login information.

For more information, see User ID Options for the Data Provider.

User ID Options for the Data Provider¶

When the .NET client application is running on the same machine as the Data Access Server (DAS), and DBMS authentication is not enabled, the .NET Data Provider does not require a user ID and password to establish a DBMS connection. The .NET client process user ID is used to establish the connection when a user ID and password are not provided.

If DBMS authentication is enabled and the user password is required, then the user ID and password must be provided even if the connection is to the same machine.

If the target database name specification includes a VNODE name specification, the VNODE login information is used to access the DBMS machine. Optionally, a user ID and password can be provided and is handled as described next.

When the DAS and warehouses are on different machines, a VNODE name is required in the target database specification of the form vnodename::dbname. The VNODE provides the connection and (optionally) login information needed to establish the DBMS connection.

The connection string keyword Vnode_usage determines how the VNODE is used to access the DBMS. Vnode_usage also determines the context (DAS or DBMS) in which the application user ID/password is used. If the target database specification does not contain a VNODE name, the Vnode_usage specification is ignored.

When Vnode_usage is set to CONNECT, only global VNODE connection information is used to establish the DBMS connection. The application-provided user ID and password are used in the DBMS context to access the DBMS machine.

When Vnode_usage is set to LOGIN, both connection and login VNODE information is used to access the DBMS machine. The application-provided User ID and Password are used in the DAS context, allowing access to private and global VNODEs on the DAS server.

The .NET Data Provider supports IPv6 addressing. IPv6 addresses should be enclosed in brackets [ ] because of the different address format—for example: [fe80::127:dff:fe7c:fecc].

If a hostname is associated with multiple IP addresses, the data provider sequentially tries to connect to each IP address in the AddressList returned by System.Net.Dns.GetHostEntry until it achieves a successful socket connection or until it reaches the end of the list. If the connection to the first address is down, the data provider attempts a connection to the next entry in the AddressList. Although performance will suffer as each Exception from a failed connection is caught, this re-attempt allows a secondary IP (backup) for a connection to a server.

SendIngresDates Connection Keyword¶

The .NET Data Provider sends .NET DateTime parameter data to the Data Access Server (DAS) and the DBMS. The format of this DateTime parameter data sent by the provider depends on the level of support of the ANSI datetime data types.

In releases prior to Ingres 9.1 (also known as 2006 Release 2), the data is sent as a data type of INGRESDATE with a GMT timezone. Beginning with Ingres 9.1, the datetime data is sent with a data type of ANSI TIMESTAMP_WITH_TIMEZONE (TS_W_TZ) with a local datetime, local timezone, and microsecond data. This flexibility and adaptability to the capabilities of the DBMS is useful, but can have a side-effect when upgrading to new releases of Ingres.

When upgrading from a release of Ingres prior to 9.1, the behavior of the program can change under certain circumstances when datetime formerly sent as an INGRESDATE type is now sent as a TS_W_TZ type. Typically, no problem occurs because the TS_W_TZ data is converted as needed and any components of the data such as microseconds are discarded, depending on the target data type. In some cases, however, the change in data type can change the semantics of processing enough to become an issue.

For example, if datetime parameter data is sent to a query containing the the IFNULL( ? , ' ') function, the function may succeed or fail depending on the data type sent by the provider. If the provider sends the data as INGRESDATE type, then IFNULL(, ' ' ) will execute correctly (returning the date or the empty string date if the parameter is null). Upon upgrade to Ingres 9.1 and later, the datetime parameter data is sent by the drivers as TIMESTAMP_WITH_TIMEZONE data type, and the IFNULL(, ' ' ) will fail because the empty string date is not permitted in combination with ANSI TIMESTAMP_WITH_TIMEZONE.

The work-around for this problem is to wrap the INGRESDATE function around the parameter: IFNULL( INGRESDATE(?) , ' '). Changing every source reference in an application, however, may not be feasible.

Using the SendIngresDates=TRUE connection keyword tells the .NET Data Provider to send the datetime parameter data as INGRESDATE type and value (as if the server was pre-Ingres 9.1) to force the old behavior.

IngresConnection.GetSchema Method¶

The IngresConnection.GetSchema method is used to return information on the schema of a database. The collection of metadata returned describes the tables, columns, and so on, that are defined in the database. The schema information is returned in the form of a .NET Framework DataTable.

GetSchema takes zero or more parameters. The first parameter is the collection name (for example: “Tables” or “Columns”). Optional restriction parameters in a String array ("restrictionValues") allow the returned metadata to be filtered to only those rows for a specified value, for example, only those columns for a specific table name. If GetSchema is invoked with no parameters or with a collection name of “MetaDataCollections” then a DataTable is returned that lists the collection names. Each row in the DataTable lists the collection name and number of restrictions supported for that collection.

The following collections are supported:

MetaDataCollection

DataSourceInformation

DataTypes

Restrictions

ReservedWords

Tables

Views

Columns

Indexes

Procedures

ProcedureParameters

1. Can be used as a restriction in the first entry of restrictionValues array.

2. Can be used as a restriction in the second entry of restrictionValues array.

3. Can be used as a restriction in the third entry of restrictionValues array.

4. Can be used as a restriction in the fourth entry of restrictionValues array.

Enlistment in Distributed Transactions¶

The .NET Data Provider supports enlistment in distributed transactions through the MS Distributed Transaction Coordinator (MSDTC) and the XA two-phase commit protocol.

Developers should be aware of MSDTC performance with distributed transactions and the lag time in communicating with all voters of the two-phase commit protocol. For performance reasons, distributed transactions should be used carefully. While the enlistment in a distributed transaction is not slow, it is not as fast as an enlistment in a local transaction.

To use the EnlistTransaction and EnlistDistributedTransaction methods in the .NET Data Provider, the administrator of the Windows machine must enable XA transactions through Component Services.

System.Transactions Programming Models¶

The .NET Framework System.Transactions namespace offers two programming models to the .NET application programmer to create a transaction. The .NET Data Provider supports both models:

• The explicit programming model allows the programmer to create, enlist into, and control the transaction manually.
• The implicit programming model allows .NET to automatically perform these operations. The implicit programming model is recommended as a best practice since there are fewer chances for programming errors and it frees the programmer from the details of managing enlistment in the System.Transactions.Transaction.

Implicit Automatic Enlistment using TransactionScope¶

The System.Transactions.TransactionScope class allows a .NET application to establish a transaction context. When a TransactionScope is instantiated, a current transaction context is established by .NET. Resource managers such as Ingres by default enlist in this ambient transaction. If an IngresConnection.Open() is issued by the application within the scope of this current transaction, and if the ConnectionString contains Enlist=yes (the default), then the IngresConnection automatically enlists the IngresConnection into the transaction.

Within the scope of the TransactionScope, the application calls the TransactionScope.Complete() method to indicate that the database unit of work should be committed. If the method is not called, the work is rolled back. When the TransactionScope is Disposed, updates to the Ingres database are committed or rolled back as directed by the .NET Transaction Manager. The Transaction Manager examines whether TransactionScope.Complete() method was called and issues the appropriate commit or rollback statements to Ingres.

The .NET application programmer can prevent automatic enlistment of the IngresConnection in the transaction context if the IngresConnection.ConnectionString includes the Enlist=No keyword/value pair.

The advantage to coding a “using” statement and TransactionScope is that if any of the database operations throws an exception, flow of control jumps out of the "using (TransactionScope)" block and a rollback of the transaction automatically occurs. The ease of programming and reliability of rollback or commit within the TransactionScope makes this model of enlistment a better programming practice.

This example shows the enlistment of an Ingres database session in a distributed transaction managed by a using TransactionScope block. When the IngresConnection.Open( ) method is issued, the Ingres connection will enlist in the distributed transaction represented by the Transaction object within the TransactionScope. After the update, the TransactionScope is marked Complete(), and the updates to the Ingres database will be committed when the TransactionScope object is disposed.

static void TestEnlistTransactionImplicitSample(

      string connstring)

{

   using (TransactionScope scope = new TransactionScope())

   {

      using (IngresConnection conn1 =

         new IngresConnection(connstring))

      {

         conn1.Open();

         IngresCommand cmd = conn1.CreateCommand();

         cmd.CommandText =

            "update authors set au_id = '409-56-7008' " +

            "where au_id = '409-56-7008'";

         cmd.ExecuteNonQuery();

         scope.Complete();

      }  // end using (IngresConnection)

   }     // end using (TransactionScope)

}

Explicit Enlistment by EnlistTransaction() Method¶

A .NET application can disable automatic transaction enlistment and manually enlist the Ingres connection in the transaction if desired. The application programmer can prevent automatic enlistment of the IngresConnection in the current transaction context if the IngresConnection.ConnectionString includes the Enlist=no or Enlist=false keyword/value pair. Later, the application can manually enlist the Ingres connection in the transaction by calling the IngresConnection.EnlistTransaction method. The .NET Transaction Manager will issue a commit to the Ingres transaction if the .NET System.Transactions.Transaction is marked complete before the Transaction object is disposed, else the Ingres transaction will be rollbacked.

Actian Data Platform Enlistment in a .NET Transaction¶

Whether the enlistment is automatic or manual, when an Actian Data Platform connection is enlisted in a .NET transaction, the .NET Data Provider participates as a resource manager within the transaction. The data provider works with the Microsoft Distributed Transaction Coordinator (MSDTC), Actian Warehouse, and the Ingres XA Distributed Transaction Processing (DTP) subsystem to allow the warehouse connection to participate in the distributed transaction on Windows with other participants. The participants are polled in a vote to commit in a two-phase commit protocol (2PC). If the vote to commit is unanimous, all participants are directed to commit; otherwise, they are directed to roll back the database updates as an atomic unit of work.

IngresConnectionStringBuilder Class¶

The IngresConnectionStringBuilder class provides a series of properties and methods to create syntactically correct connection string and to parse and rebuild existing connection strings.

IngresConnectionStringBuilder Class Declaration¶

The IngresConnectionStringBuilder class can be declared as follows:

C#: public sealed class IngresConnectionStringBuilder : DbConnectionStringBuilder

VB.NET: NotInheritable Public Class IngresConnectionStringBuilder Inherits DbConnectionStringBuilder

IngresConnectionStringBuilder Class Properties¶

The IngresConnectionStringBuilder class has these properties:

IngresConnectionStringBuilder Class Methods¶

The public methods available to the IngresConnectionStringBuilder class are:

IngresConnectionStringBuilder Class Constructors¶

The IngresConnectionStringBuilder class has the following constructors:

IngresDataReader Class¶

IngresDataReader provides a means of reading a forward-only stream of rows from a result-set created by a SELECT query or a row-producing database procedure.

When an IngresDataReader is open, the IngresConnection is busy and no other operations are allowed on the IngresConnection (other than IngresConnection.Close) until IngresDataReader.Close is issued. Created by the IngresCommand.ExecuteReader methods.

IngresDataReader Class Declaration¶

The IngresDataReader can be declared as follows:

C#:public sealed class IngresDataReader : System.Data.Common.DbDataReader

VB.NET:NotInheritable Public Class IngresDataReader Inherits System.Data.Common.DbDataReader

IngresDataReader Class Example¶

The following is an example implementation of the IngresDataReader class:

static void ReaderDemo(string connstring)

{

    IngresConnection conn = new IngresConnection(connstring);

    string strNumber;

    string strName;

    string strSSN;

    conn.Open();

    IngresCommand cmd = new IngresCommand(

        "select number, name, ssn  from personnel", conn);

    IngresDataReader reader = cmd.ExecuteReader();

    Console.Write(reader.GetName(0) + "\t");

    Console.Write(reader.GetName(1) + "\t");

    Console.Write(reader.GetName(2));

    Console.WriteLine();

    while (reader.Read())

    {

        strNumber= reader.IsDBNull(0)?

            "<none>":reader.GetInt32(0).ToString();

        strName  = reader.IsDBNull(1)?

            "<none>":reader.GetString(1);

        strSSN   = reader.IsDBNull(2)?

            "<none>":reader.GetString(2);

        Console.WriteLine(

        strNumber + "\t" + strName + "\t" + strSSN);

    }

    reader.Close();

    conn.Close();

}

IngresDataReader Class Properties¶

The IngresDataReader class contains these properties:

IngresDataReader Class Public Methods¶

The public methods available to the IngresDataReader class are:

Always call IsDBNull on a column if there is any chance of it being null before attempting to call one of the GetXXXaccessor to retrieve the data.

GetSchemaTable Columns Returned¶

The GetSchemaTable describes the column metadata of the IngresDataReader.

Mapping of Ingres Native Types to .NET Types¶

The following table maps the native Ingres database types supported by the .NET Data Provider to their corresponding .NET type. It also maps the typed accessor that a .NET application uses for an Ingres native database type to be obtained as a .NET type.

IngresDataAdapter Class¶

The IngresDataAdapter class represents a set of SQL statements and a database connection that are used to fill a DataSet and, optionally, update the Ingres database. The IngresDataAdapter object acts as a bridge between a .NET DataSet and the Ingres database for retrieving and updating data.

IngresDataAdapter Class Declaration¶

The declarations for the IngresDataAdapter class are:

C#:public sealed class IngresDataAdapter : DbDataAdapter, IDbDataAdapter, ICloneable

VB.NET:NotInheritable Public Class DataAdapter Inherits DbDataAdapter Implements IDbDataAdapter, ICloneable

IngresDataAdapter Class Example¶

public DataSet CreateDataSet(

    string dsName, string connectionString, string commandText)

{

    IngresConnection connection =

        new IngresConnection(connectionString);

    IngresCommand command =

        new IngresCommand(commandText, connection);

    IngresDataAdapter adapter = new IngresDataAdapter(command);

    DataSet ds = new DataSet();

    adapter.Fill(ds, dsName);

    return ds;

}

IngresDataAdapter Class Properties¶

The IngresDataAdapter class has these properties:

IngresDataAdapter Class Public Methods¶

The public methods available to the IngresDataAdapter Class are:

IngresDataAdapter Class Events¶

The events generated by the IngresDataAdapter class are:

IngresDataAdapter Class Constructors¶

The IngresDataAdapter class contains the following constructors:

Batch Statement Execution¶

The IngresDataAdapter class supports batch processing through the UpdateBatchSize property. This property directs the data adapter to gather several INSERT, UPDATE, and DELETE statements and their parameter sets from a DataSet or DataTable into a single block and send it to the server instead of processing one operation at a time.

The IngresDataAdapter is the Actian Data Platform implementation of the .NET DbDataAdapter class and can be used to manage the flow of Actian Data Platform data between the .NET application and the Actian Data Platform data source. The data adapter contains the SELECT command to fill a DataTable with DataRows and also contains the INSERT, UPDATE, and DELETE commands to update the database. As the application makes updates in the DataTable, the value and state change of each DataRow is recorded in the DataRow but the changes are not committed to the database until the application calls the data adapter's Update() method. When the method is called, the data adapter sweeps the DataRows of the DataTable. If the DataRow has a RowState of Added, Changed, or Deleted, the data adapter invokes the respective INSERT, UPDATE, or DELETE command.

The Microsoft .NET Framework allows a .NET application to specify that the updates be gathered into a batch by the DbDataAdapter for processing by the database. You can use the UpdateBatchSize property of the .NET DbDataAdapter to control the batch size. An UpdateBatchSize value of 1 (the default) disables batch processing—that is, each update is processed individually in a call to the database server. An UpdateBatchSize > 1 specifies the number of rows to be updated by the batch. If UpdateBatchSize is set to 0 then the batch size is left to the discretion of the data provider.

The value you choose for UpdateBatchSize depends on the application and its environment. The slower the channel between the client and server machines, the better the relative performance will be due to batch support. The benefit of .NET batch is that fewer I/Os result in reduced elapsed time. While some batch sizes will have a dramatic improvement in rows processed per second, increasingly larger batch sizes will reach a point of diminishing returns as the constant database processing time overshadows the decreasing I/O time. Experimentation in the client/server system will suggest a good value for UpdateBatchSize that balances I/Os, CPU, memory resources, .NET Garbage Collection (GC) timing, server resources to process the batch, and overall performance. A good starting value for UpdateBatchSize is 1000. A higher or lower value may be better for your environment.

The data adapter and UpdateBatchSize property can be used to bulk load a database table. A .NET DataTable is loaded with the new rows, the DataTable is associated with the IngresDataAdapter, the IngresDataAdapter.UpdateBatchSize is set to an efficient value > 1, and the IngresDataAdapter.Update() method invoked to drive a batch of rows to be INSERTed instead of one row at a time. Faster batched inserts can be achieved if the following conditions are met:

• Inserts must be into a base table (not an updatable view or index).

• The table should not have any rules or integrities (while they are allowed, they slow processing).

• The table must not be a gateway table (for example, an IMA table, security audit log file, or an Enterprise Access table).

IngresError Class¶

The IngresError class represents error or warning information returned by the Ingres database.

IngresError Class Declaration¶

The IngresError class can be declared as follows:

C#:[Serializable] public sealed class IngresError

VB.NET:NotInheritable Public Class IngresError

IngresError Class Example¶

The following is an implementation of the IngresError class:

static void PrintErrorCollection(IngresErrorCollection errcol)

{

    foreach(IngresError err in errcol)

    {

        PrintError(err);

    }

    Console.WriteLine("");

}

static void PrintError(IngresError err)

{

    Console.Write(err.GetType().ToString() + ":\n");

    Console.Write("\t" + "Message         = " +

        (err.Message    !=null?

            err.Message.ToString()    :"<null>") + "\n");

    Console.Write("\t" + "Source = " +

        (err.Source!=null?err.Source.ToString():"<null>") + "\n");

    Console.Write("\t" + "ToString: " + err.ToString() + "\n");

    Console.Write("\t" + "Number       = " +

        (err.Number.ToString()) + "\n");

    Console.Write("\t" + "SQLState       = " +

        (err.SQLState  !=null?

            err.SQLState.ToString()  :"<null>") + "\n");

    Console.WriteLine("");

}

IngresError Class Properties¶

The IngresError class has these properties:

IngresError Class Public Methods¶

The public methods available to the IngresError class are:

IngresErrorCollection Class¶

The IngresErrorCollection class represents a collection of the IngresError objects returned by the Ingres database. Created by IngresException, an IngresErrorCollection collection always contains at least one instance of IngresError.

IngresErrorCollection Class Declaration¶

The declarations for the IngresErrorCollection class are:

C#:[Serializable] public sealed class IngresErrorCollection : ICollection, IEnumerable

VB.NET: NotInheritable Public Class IngresError Inherits ICollection Implements IEnumerable

IngresErrorCollection Class Example¶

The following is an example implementation of the IngresErrorCollection class:

static void PrintErrorCollection(IngresErrorCollection errcol)

{

    foreach(IngresError err in errcol)

    {

        PrintError(err);

    }

    Console.WriteLine("");

}

static void PrintError(IngresError err)

{

    Console.Write(err.GetType().ToString() + ":\n");

    Console.Write("\t" + "Message         = " +

        (err.Message    !=null?

            err.Message.ToString()    :"<null>") + "\n");

    Console.Write("\t" + "Source = " +

        (err.Source!=null?err.Source.ToString():"<null>") + "\n");

    Console.Write("\t" + "ToString: " + err.ToString() + "\n");

    Console.Write("\t" + "Number       = " +

        (err.Number.ToString()) + "\n");

    Console.Write("\t" + "SQLState       = " +

        (err.SQLState  !=null?

            err.SQLState.ToString()  :"<null>") + "\n");

    Console.WriteLine("");

}

IngresErrorCollection Class Properties¶

The IngresErrorCollection class has these properties:

IngresErrorCollection Class Public Methods¶

The public methods available to the IngresErrorCollection class are:

IngresException Class¶

The IngresException class represents the exception that is thrown when error information is returned by the Ingres database.

IngresException Class Declaration¶

The IngresException is declared as follows:

C#:[Serializable] public sealed class IngresException : SystemException

VB.NET: NotInheritable Public Class IngresException Inherits SystemException

IngresException Class Example¶

The following is an example implementation of the IngresException class:

static void PrintException(IngresException ex){

    Console.Write(ex.GetType().ToString() + ":\n");

    Console.Write("\t" + "Errors         = " +

        (ex.Errors    !=null?ex.Errors.ToString()    :

            "<null>") + "\n");

    Console.Write("\t" + "HelpLink       = " +

        (ex.HelpLink  !=null?ex.HelpLink.ToString()  :

            "<null>") + "\n");

    Console.Write("\t" + "InnerException = " +

                (ex.InnerException!=null?ex.InnerException.ToString():

            "<null>") + "\n");

    Console.Write("\t" + "Source = " +

        (ex.Source    !=null?ex.Source.ToString()    :

            "<null>") + "\n");

    Console.Write("\t" + "TargetSite = " +

                (ex.TargetSite!=null?ex.TargetSite.ToString():"<null>") + "\n");

    Console.WriteLine("");

}

IngresException Class Properties¶

The IngresException class contains these properties:

IngresException Class Public Methods¶

The public methods available to the IngresException class are:

IngresFactory Class¶

The IngresFactory class helps generate many of the other Ingres classes in an inter-operable data provider model. For each Ingres class that the factory wants to construct, simply call the Ingres constructor for that class and return the object instance.

IngresFactory Class Declaration¶

The IngresFactory class can be declared as follows:

C#: public sealed class IngresFactory : DbProviderFactory

VB.NET: NotInheritable Public Class IngresFactory Inherits DbProviderFactory

IngresFactory Class Public Fields¶

The IngresFactory class has the following public fields:

IngresFactory Class Public Methods¶

The public methods available to the IngresFactory class are:

IngresInfoMessageEventArgs Class¶

The IngresInfoMessageEventArgs class provides the information on warnings from the database to the delegate method that handles the InfoMessage event.

IngresInfoMessageEventArgs Class Declaration¶

The IngresInfoMessageEventArgs class is declared as follows:

C#:public sealed class IngresInfoMessageEventArgs : EventArgs

VB.NET:NotInheritable Public Class IngresInfoMessageEventArgs Inherits EventArgs

IngresInfoMessageEventArgs Class Example¶

The following is an implementation of the IngresInfoMessageEventArgs class:

static void OnInfoMessage(

    Object sender, IngresInfoMessageEventArgs e)

{

    Console.WriteLine("OnInfoMessage event args: ("+

        "ErrorCode=" + e.Number +

        ", Errors=" + e.Errors +

        ", Message=\"" + e.Message + "\"" +

        ", Source=" + e.Source +")");

}

IngresInfoMessageEventArgs Class Properties¶

The following are the properties of the IngresInfoMessageEventArgs class:

IngresInfoMessageEventHandler Class¶

The IngresInfoMessageEventHandler delegate represents the delegate method that handles the InfoMessage event.

IngresInfoMessageEventHandler Class Declaration¶

The IngresInfoMessageEventHandler class has the following message declaration:

C#:[Serializable] public delegate void IngresInfoMessageEventHandler (object sender, IngresInfoMessageEventArgs e)

VB.NET: Public Delegate Sub IngresInfoMessageEventHandler _ (ByVal sender As Object, ByVal e As IngresInfoMessageEventArgs)

IngresInfoMessageEventHandler Class Example¶

The following is an implementation of the IngresInfoMessageEventHandler class:

static void DoWork(string connstring)

{

    IngresConnection conn = new IngresConnection(connstring);

    conn.InfoMessage += new

    IngresInfoMessageEventHandler(OnInfoMessage);

<do additional work>

 }

static void OnInfoMessage(

    Object sender, IngresInfoMessageEventArgs e)

{

    Console.WriteLine("OnInfoMessage event args: ("+

        "ErrorCode=" + e.Number +

        ", Errors=" + e.Errors +

        ", Message=\"" + e.Message + "\"" +

        ", Source=" + e.Source +")");

}

IngresMetaDataCollectionNames Class¶

The IngresMetaDataCollectionNames class presents information on metadata, such as tables, views, and columns. Each member of the class is a constant string suitable for use as collectionName argument for the IngresConnection.GetSchema method.

The collectionNames supported are:

• Columns

• Indexes

• ProcedureParameters

• Procedures

• Tables

• Views

IngresMetaDataCollectionNames Class Declaration¶

The IngresMetaDataCollectionNames Class can be declared as follows:

C#: public static class IngresMetaDataCollectionNames

VB.NET: Public Shared Class IngresMetaDataCollectionNames

IngresParameter Class¶

The IngresParameter class represents a parameter for an IngresCommand for each question mark (?) placeholder in the command and, optionally, its mapping to a DataSet column.

The IngresParameter constructor determines the data type of the parameter in the following ways:

• The constructor specifies an IngresType enumeration

• The constructor specifies a System.DbType enumeration

• Through the .NET Framework System.Type of the Value object if no specific data type is in the constructor

Positional Parameters¶

The data provider supports the positional (unnamed) parameter marker placeholder syntax using the question mark character (?) similar to ODBC and JDBC. Parameter data is accessed from the IngresParameterCollection in the same relative order as the parameter markers in the SQL statement.

Named Parameters¶

The data provider supports named parameters. A named parameter marker is constructed by an initial character of question mark (?), at-sign (@), or colon (:) followed by a name. The name is an alphanumeric identifier or an integer. Databases vary in the use of the initial character for a named parameter. While the Ingres recommended initial parameter marker character is the question mark, the .NET Data Provider supports all three characters.

If one parameter is named then all of the parameters must be named. If one parameter is unnamed (positional) then all of the parameters must be unnamed. For the sake of code readability, a mix of named parameters and unnamed parameters is not permitted.

For the sake of code readability, a mix of named parameters, each with a different initial parameter marker character in a single SQL statement is also not permitted.

Multiple occurrences of the same named parameter marker in the SQL statement is permitted.

Excess named parameters that are not referenced in the SQL statement are permitted in the IngresParameterCollection and are ignored.

The name comparison between the named parameter marker in the SQL statement and the named parameter in the IngresParameterCollection is not case sensitive.

Named Parameters Example¶

The following is an example of using named parameters:

cmd = conn.CreateCommand();

cmd.CommandText =

      "insert into mytable  values ( ?key,  ?col1  ?col2  ?col3  )";

cmd.Parameters.AddWithValue("?key",  mykey);

cmd.Parameters.AddWithValue("?col3", mystring3);

cmd.Parameters.AddWithValue("?col1", mystring1);

cmd.Parameters.AddWithValue("?col2", mystring2);

cmd.ExecuteNonQuery();

cmd = conn.CreateCommand

cmd.CommandText =

      "insert into mytable  values ( @key,  @col1  @col2  @col3  )";

cmd.Parameters.AddWithValue("@key",  mykey);

cmd.Parameters.AddWithValue("@col3", mystring3);

cmd.Parameters.AddWithValue("@col1", mystring1);

cmd.Parameters.AddWithValue("@col2", mystring2);

cmd.ExecuteNonQuery();

cmd = conn.CreateCommand();

cmd.CommandText =

      "insert into mytable  values ( :key,  :col1  :col2  :col3  )";

cmd.Parameters.AddWithValue(":key",  mykey);

cmd.Parameters.AddWithValue(":col3", mystring3);

cmd.Parameters.AddWithValue(":col1", mystring1);

cmd.Parameters.AddWithValue(":col2", mystring2);

cmd.ExecuteNonQuery();

IngresParameter Class Example¶

The following is an implementation of the IngresParameter class:

static string DemoParameterSSN(

    string connstring, int intNumber, string strSSN)

{

    IngresConnection conn = new IngresConnection(connstring);    string strName = null;    conn.Open();    IngresCommand cmd = new IngresCommand(

        "select name from demo_personnel where number = ? and ssn = ?",

        conn);    // add two parameters to the command's IngresParameterCollection

    cmd.Parameters.Add(new IngresParameter("Number", intNumber));

    IngresParameter parm =

        new IngresParameter("SSN", IngresType.VarChar);

    parm.Value = strSSN;

    cmd.Parameters.Add(parm);    IngresDataReader reader = cmd.ExecuteReader();    while (reader.Read())

    {

        if (reader.IsDBNull(0))

            break;

        strName  = reader.GetString(0);

    }    reader.Close();

    conn.Close();    return strName;

}

IngresParameter Class Declaration¶

The class declaration for IngresParameter class is:

C#:public sealed class IngresParameter : System.Data.Common.DbParameter, IDataParameter, IDbDataParameter, ICloneable

VB.NET:NotInheritable Public Class IngresParameter Inherits System.Data.Common.DbParameter Implements IDataParameter, IDbDataParameter, ICloneable

IngresParameter Class Properties¶

The properties for the IngresParameter are:

IngresParameter Class Public Methods¶

The public methods available for the IngresParameter class are:

IngresParameter Class Constructors¶

The constructors available to the IngresParameter class are:

IngresParameterCollection Class¶

The IngresParameterCollection class represents a collection of all parameters for an IngresCommand object and their mapping to a DataSet object.

IngresParameterCollection Class Declaration¶

The class declaration for IngresParameterCollection class is as follows:

C#:public sealed class IngresParameterCollection : System.Data.Common.DbParameterCollection, IDataParameterCollection, IList, ICollection, IEnumerable

VB.NET:NotInheritable Public Class IngresParameterCollection Inherits System.Data.Common.DbParameterCollection Implements IDataParameterCollection, IList, ICollection, IEnumerable

IngresParameterCollection Class Example¶

For an example of adding parameters to an IngresParameterCollection, see IngresParameter Class Example.

IngresParameterCollection Class Properties¶

The IngresParameterCollection has these properties:

IngresParameterCollection Class Public Methods¶

The public methods available to the IngresParameterCollection class are:

IngresPermission Class¶

The IngresPermission class provides additional information that a user has a security level sufficient to access the Ingres database. At present, the class is not used by the .NET Data Provider. The class is included in the Ingres data provider to provide completeness for the Factory interoperability model. Instead, standard Ingres security and access control is used.

The IngresPermission class can be declared as follows:

C#: public sealed class IngresPermission : DBPermission

VB.NET: NotInheritable Public Class IngresPermission Inherits DBPermission

IngresRowUpdatedEventArgs Class¶

The IngresRowUpdatedEventArgs class provides the information for the RowUpdated event of an IngresDataAdapter.

IngresRowUpdatedEventArgs Class Declaration¶

The class declaration for IngresRowUpdateEventArgs is as follows:

C#:public sealed class IngresRowUpdatedEventArgs : RowUpdatedEventArgs

VB.NET:NotInheritable Public Class IngresRowUpdatedEventArgs Inherits RowUpdatedEventArgs

IngresRowUpdatedEventArgs Class Properties¶

The IngresRowUpdatedEventArgs has these properties:

IngresRowUpdatedEventHandler Class¶

The IngresRowUpdatedEventHandler delegate represents a delegate method that handles the RowUpdated event of an IngresDataAdapter.

IngresRowUpdatedEventHandler Class Declaration¶

The IngresRowUpdateEventHandler class has the following declaration:

C#:[Serializable] public delegate void Ingres RowUpdated EventHandler ( object sender, IngresRowUpdated EventArgs e)

VB.NET: Public Delegate Sub Ingres RowUpdatedEventHandler _ (ByVal sender As Object, ByVal e As IngresRowUpdatedEventArgs)

IngresRowUpdatingEventArgs Class¶

The IngresRowUpdatingEventArgs class provides the information for the RowUpdating event of an IngresDataAdapter.

IngresRowUpdatingEventArgs Class Declaration¶

The IngresRowUpdatingEventArgs class has the following declaration:

C#:public sealed class IngresRowUpdatingEventArgs : RowUpdatingEventArgs

VB.NET:NotInheritable Public Class Ingres RowUpdatingEventArgs Inherits RowUpdatingEventArgs

IngresRowUpdatingEventArgs Class Properties¶

The IngresRowUpdatingEventArgs class has these properties:

IngresRowUpdatingEventHandler Class¶

The IngresRowUpdatingEventHandler delegate represents a delegate method that handles the RowUpdating event of an IngresDataAdapter.

IngresRowUpdatingEventHandler Class Declaration¶

The IngresRowUpdatingEventHandler class declaration is as follows:

C#:[Serializable] public delegate void IngresRowUpdatingEventHandler ( object sender, IngresRowUpdatingEventArgs e)

VB.NET: Public Delegate Sub Ingres RowUpdatingEventHandler _ (ByVal sender As Object, ByVal e As IngresRowUpdatingEventArgs)

IngresTransaction Class¶

The IngresTransaction class represents a local, non-distributed database transaction. Each connection is associated with a transaction. This object allows manual commit or rollback control over the pending local transaction.

Created by the BeginTransaction method in the IngresConnection object. After Commit() or Rollback has been issued against the transaction, the IngresTransaction object can not be reused and a new IngresTransaction object must be obtained from the IngresConnection.BeginTransaction method if another transaction is desired.

IngresTransaction Class Declaration¶

The IngresTransaction class declaration is as follows:

C#:public sealed class IngresTransaction : System.Data.Common.DbTransaction

VB.NET:NotInheritable Public Class IngresTransaction Inherits System.Data.Common.DbTransaction

IngresTransaction Class Example¶

The following is an implementation of the IngresTransaction class:

static void DemoTxn(string connstring)

{    IngresConnection conn = new IngresConnection(connstring);    ProviderTransaction txn;    conn.Open();    txn = conn.BeginTransaction();    IngresCommand cmd = new IngresCommand(        "update demo_personnel set name = 'Howard Lane' "+        "  where number = 200", conn, txn);    int numberOfRecordsAffected = cmd.ExecuteNonQuery();    Console.WriteLine(numberOfRecordsAffected.ToString() +        " records updated.");    txn.Commit();    conn.Close();}

IngresTransaction Class Properties¶

The IngresTransaction class has these properties:

IngresTransaction Class Methods¶

The IngresTransaction class contains the following methods: