WebDocs Home | Show Navigation Hide Navigation

Glossary

autocommit

A mode in which each SQL operation results in a transaction that is automatically committed after the statement is executed.

bind variable

A host variable used for sending data values to the database.

BLOB

(binary large object) Binary data that exceeds a database’s normal maximum column size for binary data.

channel

A database connection control. Each connection (login) is maintained by channel ID.

clientside cursor

(SQL Server concept) A cursor implemented on the client for a result set that’s cached on the client. The firehose cursor (though it’s not a true cursor) is the only clientside cursor for SQL Server.

CLOB

(character large object) Character data that exceeds a database’s normal maximum column size for character data.

commit

A procedure that finishes a transaction and makes changes permanent.

concurrency control

Methods used by relational databases to ensure that changes made to data by one user are not overwritten with changes made concurrently by other users. The two main types of concurrency control are optimistic locking and pessimistic locking.

connect string

A string use by SQL Connection to connect to and log onto a database. The connect string is passed in a call to %SSC_CONNECT. If SQL OpenNet is used for the network layer, the connect string includes a network string (see network string).

connection

A database login.

cursor

A processed SQL statement (one that's been parsed, optimized, etc., by the database) and/or an associated database mechanism that traverses a result set and maintains a position on a row in the result set. With SQL Connection, cursors are accessed using the number returned in the dbcursor argument for %SSC_OPEN.

See also logical cursor.

defined variable

A host variable used for storing data values retrieved from the database.

direct connection

A database connection that does not use SQL OpenNet. Direct connections must be to a local database or database client. Connect strings for direct connections start with the name or keyword of a database driver (e.g., VTX0).

drop table

To delete or remove a table from a database.

dynamic cursor

(SQL Server concept) A serverside cursor that reflects all changes made to the underlying data while the cursor is open. Dynamic cursors are also known as sensitive cursors, and are the only cursors you can use with SQL Server for updates and deletes. Dynamic cursors are the default cursors for VTX12_SQLNATIVE.

fetch

An operation that retrieves a row or a set of rows from a result set. Cursor settings and type determine which row(s) will be fetched. For SQL Connection, %SSC_MOVE performs fetches.

firehose cursor

(SQL Server concept) Not really a cursor, but instead the recommended mechanism when using VTX12_SQLNATIVE. With a firehose cursor, data is cached on the client and is forwardonly and readonly. Firehose cursors minimize overhead and are faster than real cursors (dynamic, static, etc.), but they return only one row at a time, and with a firehose cursor, you can have only one active statement for a connection (though MARS may allow multiple active statements in some cases). No other statement can be executed until all results have been fetched or until the statement has been canceled.

FOR BROWSE mode

The default database locking mode. Optimistic locking is used; the lock is advisory only. The application must check whether data has changed before updating.

FOR UPDATE mode

A data locking method that invokes the database engine’s inherent locking method, typically a pessimistic lock. Oracle, for example, uses pessimistic locking when a SELECT FOR UPDATE operation is performed.

forwardonly cursor

A cursor that cannot be scrolled. With a forwardonly cursor, the next row fetched will be the next row in the result set. Forwardonly cursors are the only type of cursor that most databases support and are the default when using any SQL Connection database driver except VTX12_SQLNATIVE.

GUID

A globally unique identification number used like ROWID. GUIDs are guaranteed to be unique not only to the database, but everywhere: no other computer in the world will generate a duplicate of a GUID value.

host variable

A Synergy DBL variable used to store database data. See defined variable and bind variable.

insensitive cursor

See static cursor.

keysetdriven cursor

(SQL Server concept) A serverside cursor that reflects updates made to rows that were part of the result set when it was established. Keysetdriven cursors do not reflect deletes or inserts.

logical cursor

An SQL Connection mechanism for caching softclosed cursors.

network string

A string that contains the information needed to connect to an SQL OpenNet service on a machine that has either the database or a client for the database. Network strings are part of connect strings (see connect string).

nonpositioned cursor

A logical cursor that can’t be used for positioned updates, but that is more efficient in other cases.

optimistic locking

An approach to concurrency control where the database does not lock data accessed for update or delete. Optimistic locking assumes that the frontend application will ensure data integrity. The advantage to optimistic locking is that it improves throughput. The disadvantage is that a user may be able to access rows of data only to get an error when attempting to write data to those rows because another user who concurrently accessed the data submitted changes first.

pessimistic locking

An approach to concurrency control that locks data resources for much of the duration of a transaction. For SQL Connection (when the correct commands are used), pessimistic locking locks rows from the first fetch (with %SSC_MOVE) or an insert until the transaction ends with %SSC_COMMIT, and an error is returned if another user attempts to access locked data. The advantage to pessimistic locking is that users are always able to submit changes to records and delete records without the possibility that these changes will conflict with other users’ changes. The disadvantage is that throughput may suffer.

pointer

An identifier stored in a database and used by the database engine to keep track of data locations, usually by row. Analogous to a ROWID.

positioned

When discussing cursors, the current processing location for the result set. For example, if an application fetches the first two rows of a result set, the cursor will be positioned on the third row. With some databases, SQL Connection enables an application to move directly to a specific position in a cursor without performing a fetch.

positioned update

A change (update, insert, or delete) made to the underlying data at the current processing location of the result set (the row where the cursor is currently positioned). Positioned updates are invoked by a WHERE CURRENT OF clause in the update statement or by a FOR UPDATE OF clause in the select statement.

prefetch buffer

A memory resource used for improving network performance. Data from the database is retrieved and held in the prefetch buffer in anticipation of a function call.

pseudocolumn

A relational database column that is part of a database table but is typically invisible to the end user. ROWID is the most common example.

result set

A dataset that contains the results of a select statement. Result set is synonymous with rowset.

rollback

A procedure that reverses any pending changes during the current transaction, instead of committing them. Rollbacks can occur, for instance, in the event of data locking.

row locking

See optimistic locking and pessimistic locking.

row size

The aggregate size of each returned row.

ROWID

A pseudocolumn used in relational database to uniquely identify each row in the database. Typically this column is not retrieved during SELECT * operations.

rowset

See result set.

scrolling cursor

A serverside cursor that enables you to determine which row will be retrieved with the next fetch. Using the %SSC_CMD option, SSQL_CMD_SCROLL, you can specify whether the next fetched row will be the current row, the first row in the result set, the last row in the result set, or a row at a given location in the result set (specified with an absolute or relative value).

sensitive cursor

See dynamic cursor.

serverside cursor

(SQL Server concept) A cursor implemented on the server. Only fetched rows are sent to the client. Serverside cursors generally offer more functionality than clientside cursors, but they usually don’t perform as well.

SQL OpenNet

A Connectivity Series component that enables SQL Connection (and xfODBC) to work in a client/server configuration. For more information, see “Configuring Connectivity Series”.

SQL OpenNet connection

A database connection that uses SQL OpenNet for the network layer. Connect strings for SQL OpenNet connections start with “net:”.

standard cursor

See nonpositioned cursor.

static cursor

(SQL Server concept) A serverside cursor that does not reflect any changes made to the database after the result set was established. Static cursors are also known as insensitive cursors or snapshot cursors.

stored procedure

A precompiled, readytoexecute command stored in a database and managed as a database object. Stored procedures may limit portability.

timestamp column

For SQL Server, this is analogous to the ROWID column. It uniquely identifies each row in a relational database by issuing a datetime stamp for the last moment data was committed in each row.

update

To change data in a database. The terms “update” and “edit” are often used interchangeably.

vtxnetd/vtxnet2

The SQL OpenNet connection manager. For more information, see “Configuring Connectivity Series”.