Home

	Expand Search

Open Client Client-Library/C Reference Manual

Glossary

Glossary

A server in Sybase's client/server architecture. Adaptive Server manages multiple databases and multiple users, keeps track of the actual location of data on disks, maintains mapping of logical data description to physical data storage, and maintains data and procedure caches in memory.

Beginning with version 11.5, SQL Server's name was changed to Adaptive Server Enterprise.

A structure composed of multiple identical variables that can be individually addressed.

The process of binding a result column to an array variable. At fetch time, multiple rows' worth of the column are copied into the variable.

Occurring at any time without regard to the main control flow of a program. Compare to . Client-Library has two asynchronous modes of operation, and .

In Client-Library, any routine that interacts with the network. The asynchronous routines are those that can return CS_PENDING.

A group of commands or statements.

A Client-Library command batch is one or more Client-Library commands terminated by an application's call to ct_send. For example, an application can batch together commands to declare, set rows for, and open a cursor.

A Transact-SQL statement batch is one or more Transact-SQL statements submitted to SQL Server or Adaptive Server by means of a single Client-Library command or Embedded SQL statement.

Browse mode is a method that DB-Library and Client-Library applications can use to browse through database rows, updating their values one row at a time. Cursors provide similar functionality and are generally more portable and flexible.

A network interface provided by Adaptive Server for high-speed transfer of data into database tables. The bcp utility allows administrators to copy data in and out of databases via the bulk copy interface. Client-Library and Server-Library programmers can use to access this interface. (DB-Library programs must use the Bulk-Copy special library built into DB-Library.

A hidden control structure (CS_BLKDESC) used by Bulk-Library to manage bulk copy operations. See also , .

A collection of routines that allow Client-Library and Server-Library applications to access the Adaptive Server bulk copy interface. See also .

A result set sorted into subgroups. A bylist is generated by using the compute clause with the keyword by, followed by a list of columns.

A routine that Open Client or Open Server calls in response to a triggering event, known as a callback event.

In Client-Library applications, a method of handling errors where the program installs functions to be called when Client-Library or CS-Library detects an error or when the server has sent a server message. See also , , , .

In Open Client and Open Server, a callback event is an occurrence that triggers a callback routine.

The set of features that are supported by the version of the communication protocol that is used for a client/server connection. Client-Library applications can call ct_capability to check whether a connection supports a particular type of client request or server response. A client application can also prevent certain types of server responses by calling ct_capability before a connection is opened. Capabilities are determined when a connection is opened and cannot be changed afterwards. See also , .

A set of specific (usually standardized) characters with an encoding scheme that uniquely defines each character. ASCII and ISO 8859-1 (Latin 1) are two common character sets. See also , .

Changing the encoding scheme of a set of characters on the way into or out of a server. Conversion is used when a server and a client communicating with it use a different . For example, if a server uses ISO 8859-1 and a client uses Code Page 850, character set conversion must be turned on so that both server and client interpret the data passing back and forth in the same way.

In client/server systems, the client is the part of the system that sends requests to servers and processes the results of those requests.

In a client/server system, the used by the client application. The client character set can differ from the character set used by the server. See also .

Part of Open Client, Client-Library is a collection of routines for use in writing client applications. Client-Library is new in System 10 and designed to accommodate cursors, distributed network services, and other advanced features in the Sybase System 10 and later product lines. See also , .

An error or informational message generated by Client-Library to inform the application of an error or exceptional condition. See also , , .

An application routine that is called each time Client-Library generates a client message to describe an error or unusual condition. See also .

See .

See .

In Client-Library, a command is a server request initiated by an application's call to ct_command, ct_dynamic, or ct_cursor and terminated by the application's call to ct_send.

A command structure (CS_COMMAND) is a hidden Client-Library control structure that Client-Library applications use to send commands and process results.

Entries may also have a that is unique only among entries that have the same parent node. See .

In Client-Library applications, a type of application routine. On connections, Client-Library automatically invokes the application's completion callback to communicate the of each call to an .

In Client-Library applications, the final return status of a call to an . On synchronous connections, asynchronous routines block until all required network interaction is complete, then return the completion status directly. On asynchronous connections, asynchronous routines return CS_PENDING immediately, and the application must determine the completion status by polling or via a . See also , , .

A connection structure (CS_CONNECTION) is a hidden Client-Library control structure that defines a client/server connection within a context. See also .

A context structure (CS_CONTEXT) is a CS-Library hidden structure that defines an application "context," or operating environment, within a Client-Library or Open Server application. The routines cs_ctx_alloc and cs_ctx_drop allocate and drop a context structure.

The act of converting a data value from one representation to another. Conversion can yield a new value with a different datatype or, for character-to-character conversions, a new value with a different format or in a different . See also .

A network-based authentication, wherein users prove their identity to the network security system before the connection attempt is made. Client-Library then obtains a credential token from the security mechanism and sends it to the server in lieu of a password.

In a multithreaded application, critical sections are sections of code that cannot execute simultaneously in multiple threads. Typically, a critical section is code that accesses a resource shared by multiple threads. Critical sections that access the same shared resource are said to be "related." See also , .

Included with both the Open Client and Open Server products, CS-Library is a collection of utility routines that are useful to both Client-Library and Server-Library applications. See also .

An application routine that is called each time CS-Library generates an error message to describe a error or exceptional condition. A CS-Library error handler is required in a application and recommended in a application. See also .

With respect to cursors, the current row is the row to that a cursor points. A fetch against a cursor retrieves the current row. See also .

A cursor is a symbolic name that is associated with a select statement. The cursor associates a "row pointer" with the set of rows matching the select conditions.

In Transact-SQL, a language cursor is a cursor declared with a declare cursor language command and scrolled with fetch language commands.

In Client-Library, a Client-Library cursor is a server object created with ct_cursor(CS_CURSOR_DECLARE). An application scrolls a Client-Library cursor with ct_fetch.

In Embedded SQL, a cursor is a data selector that passes multiple rows of data to the host program, one row at a time.

A set of related data tables and other database objects that are organized to serve a specific purpose.

A defining attribute that describes the values and operations that are legal for a variable.

Part of Open Client, DB-Library is a self-contained collection of routines for use in writing client applications. DB-Library provides source-code compatibility for older Open Client applications that are written in DB-Library.

1. In Adaptive Server, a situation that arises when two users, each having a lock on one piece of data, attempt to acquire a lock on the other's piece of data. Adaptive Server detects deadlocks and resolves them by killing one user's process.

2. In a multithreaded application, a situation where two threads, each having control of a serialization primitive, attempt to lock the serialization primitive held by the other. Deadlock can freeze a multithreaded application.

1. In an Open Client or Open Server application, the value, option, or behavior that Open Client/Server products use when none is specified.

2. In Transact-SQL, the value inserted for a column when an insert statement does not specify a value.

The database that a user is in by default when he or she logs into a database server.

1. The language that Open Client/Server products use when an application does no localization. The default language is determined by the "default" entry in the locales file.

2. The language that Adaptive Server and SQL Server use for messages and prompts when a user has not chosen a language.

An asynchronous mode of operation for Client-Library connections where an application must poll for the completion status of each call to an asynchronous routine. Compare to .

The area that a database management system (DBMS) uses to store information about dynamic parameters in a dynamic SQL statement.

A dictionary that associates unique names with stored information about network entities such as servers, printers, or users. Directory access requires a . See also .

A directory driver converts directory entries from their native storage format into the Server Directory Object format.

A directory entry contains stored information associated with a given .

A specification for the set of attributes (data) stored in a .

In a Client-Library application, a hidden structure (datatype CS_DS_OBJECT) that contains a copy of a that was read via a call to the ct_ds_lookup routine.

Sometimes called a naming service, the directory service manages creation, modification, and retrieval of directory entries.

System software that provides access to a for applications. For some platforms such as Windows NT, a directory service provider is built into the operating system. On other platforms, the system can be configured to use a third-party provider such as Banyan, Novell, or DCE.

In directories that have an inverted-tree structure, a DIT base is the name of an interior node. The DIT base name is combined with partially qualified names to create a fully qualified name. See also , .

Dynamic SQL allows an Embedded SQL or Client-Library application to associate a name with a prepared SQL statement. Once prepared, the SQL statement can be executed repeatedly by name and can contain variables whose values are determined at execution time. In Adaptive Server, prepared dynamic SQL statements are dropped automatically when a user disconnects. Compare to .

A message that an Open Client/Server product issues when it detects an error condition.

An occurrence that prompts a Server-Library application to take certain actions. Client commands and certain commands within Open Server application code can trigger events. When an event occurs, Server-Library calls either the appropriate event-handling routine in the application code or the appropriate default event handler. See also , .

The programming style for Open Server applications. The application provides event handlers for each class of event, and the Open Server thread scheduler "dispatches" events by calling the application's event handlers. See also , , .

In Open Server, a routine that processes an event. An Open Server application can use the default handlers Open Server provides or can install custom event handlers. See also , .

A cursor declared with a stored procedure.

An exposed structure is a structure whose internals are exposed to Open Client/Server programmers. Open Client/Server programmers can declare, manipulate, and deallocate exposed structures directly. The CS_DATAFMT structure is an example of an exposed structure.

In Embedded SQL, an extended transaction is a transaction composed of multiple Embedded SQL statements.

FIPS is an acronym for Federal Information Processing Standards. If FIPS flagging is enabled, Adaptive Server or the Embedded SQL precompiler issues warnings when a statement using a non-standard extension to SQL is encountered.

An asynchronous mode of operation for Client-Library connections where the application is automatically notified when each call to an completes. See also , , .

A name that uniquely and unambiguously identifies a . An entry's fully qualified name provides all the information that a requires to find the entry.

A gateway is an application that acts as an intermediary for clients and servers that cannot communicate directly. Acting as both client and server, a gateway application passes requests from a client to a server and returns results from the server to the client.

An OID functions as a symbolic global name that means the same to all applications in a distributed environment. See .

A hidden structure is a structure whose internals are hidden from Open Client/Server programmers. Open Client/Server programmers must use Open Client/Server routines to allocate, manipulate, and deallocate hidden structures. The CS_CONTEXT structure is an example of a hidden structure.

The programming language in which an application is written.

In Embedded SQL, the host program is the application program that contains the Embedded SQL code.

In Embedded SQL, a variable that enables data transfer between Adaptive Server and the application program. See also , , , , .

A variable whose value indicates special conditions about another variable's value or about fetched data.

When used with an Embedded SQL host variable, an indicator variable indicates when a database value is null.

In Client-Library applications, a command is initiated if the type of command has been defined by ct_command, ct_cursor, or ct_dynamic, but the command has not yet been sent to the server with ct_send. See also .

In Client-Library applications, a method of handling errors where the program tests for the occurrence of s, CS-Library errors, or s after each call to a CS-Library or Client-Library routine. Compare to .

A variable that is used to pass information to a routine, a stored procedure, or Adaptive Server.

A file that maps server names to transport addresses. When a client application calls ct_connect or dbopen to connect to a server, Client-Library or DB-Library searches the interfaces file for the server's address. Client-Library can also use a directory service for this purpose instead of the interfaces file. Some platforms do not use the interfaces file. On these platforms, an alternate mechanism directs clients to server addresses.

See .

In Embedded SQL, an isql script file is one of the three files the precompiler can generate. An isql script file contains precompiler-generated stored procedures that are written in Transact-SQL.

A subset of row data that uniquely identifies a row. Key data uniquely describes the in an open cursor.

The name and path to an operating system file.

A word or phrase that is reserved for exclusive use in Transact-SQL or Embedded SQL. Also called a "reserved word."

In an application, the internal Server-Library system thread that waits for client connection attempts and creates new threads to handle each client connection. A call to srv_init starts the listener.

In Embedded SQL, a listing file is one of the three files the precompiler can generate. A listing file contains the input file's source statements and informational, warning, and error messages.

A character string that represents a language and character set pair. Locale names are listed in the . Sybase predefines some locale names and the can define additional locale names and add them to the locales file.

A locale structure (CS_LOCALE) is a CS-Library hidden structure that defines custom localization values for a Client-Library or Open Server application. An application can use a CS_LOCALE structure to define the language, character set, datepart ordering, and sort order it will use. The CS-Library routines cs_loc_alloc and cs_loc_drop allocate and drop a locale structure.

A file that maps locale names to language and character set pairs. Open Client/Server products search the locales file when loading localization information.

Localization is the process of setting up an application to run in a particular native language environment. An application that is localized typically generates messages in a local language and character set and uses local datetime formats.

In a Client-Library application, a logical command is defined as any command defined via ct_command, ct_dynamic, or ct_cursor, with the following exceptions:

• Each Transact-SQL select statement inside a stored procedure is a logical command. Other Transact-SQL statements inside stored procedures do not count as logical commands.

• Each Transact-SQL statement executed by a dynamic SQL command is a distinct logical command.

• Each Transact-SQL statement in a language command is a logical command.

A security service that confirms that users are who they say they are by use of user names and passwords.

The name a user uses to log in to a SQL Server. An Adaptive Server login name is valid if Adaptive Server has an entry for that user in the system table syslogins.

A number that uniquely identifies an error message.

In Open Server, a linked list of message pointers through which threads communicate. Threads can write messages into and read messages from the queue.

A character set that includes characters encoded using more than one byte. EUC JIS and Shift-JIS are examples of multibyte character sets.

A property of program code. Multithreaded code can execute concurrently on two or more threads and, therefore, must be . See also .

A mutual exclusion semaphore. A mutex is a provided by Server-Library or an operating system thread interface. A mutex provides a method for multithreaded applications to serialize access to a resource shared by two or more threads. See also , .

See .

A whose existence and scheduling are managed by the host operating system. See also , .

The server can change the value of certain login properties, such as TDS version support properties, during the login process. These are negotiated properties.

1. With regard to data values, having no explicitly assigned value. NULL is not equivalent to zero nor to blank. A value of NULL is not considered to be greater than, less than, or equivalent to any other value, including another NULL value.

2. With regard to C language pointers, the special NULL address value that refers to no memory address.

An object identifier, or OID, is a string of decimal digits that uniquely names an object in a multi-vendor, multi-platform environment. OIDs provide a means to identify an item that might have different names in different environments. For example, the same character set can be named differently by different operating systems. See .

Object identifiers are encoded according to the Basic Encoding Rules (BER) defined by ISO 8825. All Sybase-defined OIDs begin with this prefix:

1.3.6.1.4.1.897

See .

A character string that contains an . Client-Library and Server-Library applications use OID strings to represent object identifiers. The cspublic.h header file defines Sybase-specific OID strings.

A Sybase product that provides tools and interfaces for creating custom servers. See also .

A custom server constructed with . See also , .

A path of execution through an and library code and the path's associated stack space, state information, and event handlers. An Open Server thread is a thread whose existence and scheduling is managed by . See also , , .

In a Client-Library application, options control how Adaptive Server processes commands. Applications set, retrieve, or clear options by calling the ct_options Client-Library routine after a connection to a server has been opened. See also , .

In Embedded SQL, a variable that passes data from a stored procedure to an application program.

1. A variable that is used to pass data to and retrieve data from a routine.

2. An argument to a stored procedure.

A mode in which a gateway relays Tabular Data Stream (TDS) packets between a client and a remote data source without unpacking the packets' contents.

Placeholders, indicated with a question mark (?) in the statement, act like variables in the prepared statement.

Properties are named values stored in a hidden structures. Context, connection, thread, and command structures have properties. A structure's properties determine how CS-Library, Client-Library, or Server-Library responds to calls that pass a pointer to the structure as a parameter. See also , .

1. A data retrieval request; usually a select statement.

2. Any SQL statement that manipulates data.

In an Open Server application, an executable entity on the server that can be remotely called by clients. A registered procedure can be a C function in the Open Server application code, an internal Server-Library routine made available as a system registered procedure, or a "bodiless" registered procedure created by a client's call to the sp_regcreate system registered procedure. See also , , .

An Open Server feature that allows a client to monitor the execution of a given . A client requests to "watch" a registered procedure on the Open Server, and thereafter, the Open Server notifies the client when the procedure executes. Registered procedure notifications allow synchronization of clients in a distributed application. See also .

1. One of two ways in which a client application can execute an Adaptive Server stored procedure. (The other is with a Transact-SQL execute statement.) A Client-Library application initiates a remote procedure call command by calling ct_command. A DB-Library application initiates a remote procedure call command by calling dbrpcinit.

2. A type of request that a client can make of an Open Server application. In response, Open Server either executes the corresponding registered procedure or calls the Open Server application's RPC event handler.

3. In Transact-SQL, a stored procedure that is executed on a different server from the server to which the user is connected.

An application uses request capabilities to determine what kinds of requests a server connection supports.

See .

An application uses response capabilities to prevent the server from sending a type of response that the application cannot process.

An umbrella term for all the types of data that a server can return to an application.

Results are returned to an application in the form of result sets. A result set contains only a single type of result data. Regular row and cursor-row result sets contain multiple rows of data, but other types of result sets contain at most a single row of data

In Embedded SQL, a variable that receives the results of a select or fetch statement.

External software that provides security services for a connection.

The list of columns selected by a Transact-SQL select statement.

A numeric identifier for a column in the results of a Transact-SQL select statement. The first column in the select list has id 1, the second has id 2, and so forth. For example, in the query below, the select-list id of the title column is 1 and the select-list id of the Units Sold column is 3:

select title, price, "Units Sold" = total_sales from titles

See also .

A logical object and associated routines that allow serialization of access to shared resources. A is an example of a serialization primitive. See also , .

In client/server systems, the server is the part of the system that processes client requests and returns results to clients. A server can be a or an .

A generalized description of the logical content of directory entries that describe Sybase servers.

A collection of routines for use in writing an .

An error or informational message sent by a server to the client. The server may send server messages to the client to describe errors or unusual conditions that occur when the server is processing a command sent from the client. See also , , .

In a Client-Library application, a function installed to receive each sent by the server. See also .

A platform specific method used by Client-Library to allow non-blocking network reads and writes. Internally, Client-Library installs its own internal system interrupt handler and interacts with the network using non-blocking system calls. Compare .

Used to determine the order in which character data is sorted. Also called .

1. In an Embedded SQL application, a SQLCA structure provides a communication path between Adaptive Server and the application program. After executing each SQL statement, the precompiler-generated source code stores return codes in the SQLCA.

2. In a Client-Library application, a SQLCA structure can be used by an application to retrieve Client-Library and server error and informational messages.

1. In an Embedded SQL application, a SQLCODE structure provides a communication path between Adaptive Server and the application program. After executing each SQL statement, the precompiler-generated source code stores return codes in the SQLCODE. A SQLCODE can exist independently or as a variable within a SQLCA structure.

2. In a Client-Library application, a SQLCODE structure can be used by an application to retrieve Client-Library and server error and informational message codes.

A server in Sybase's client/server architecture. SQL Server manages multiple databases and multiple users, keeps track of the actual location of data on disks, maintains mapping of logical data description to physical data storage, and maintains data and procedure caches in memory.

Beginning with version 11.5, SQL Server's name was changed to Adaptive Server Enterprise.

In Transact-SQL or Embedded SQL, an instruction that begins with a keyword. The keyword names the basic operation or command to be performed.

In Embedded SQL, a variable that receives the return status value of a stored procedure, thereby indicating the procedure's success or failure.

In Adaptive Server, a collection of SQL statements and optional control-of-flow statements stored under a name. Adaptive Server-supplied stored procedures are called .

A logical object and associated routines that allow synchronization of dependent actions performed by multiple threads. Synchronization primitives for native threads are provided by the host operating system (for example, a condition variable or barrier). Synchronization primitives for Open Server threads are provided by Server-Library (for example, a ). See also , .

Occurring at a predictable point in time determined wholly by the logic of main-line program code. Compare to .

The user in charge of server system administration, including creating user accounts, assigning permissions, and creating new databases. In Adaptive Server, the System Administrator's login name is "sa".

In Embedded SQL, a system descriptor is an area of memory that holds a description of variables used in Dynamic SQL statements.

An internal that Open Server supplies for managing registered procedure notifications and monitoring the server status. See also .

Stored procedures that Adaptive Server supplies for use in system administration. These procedures are provided as shortcuts for retrieving information from system tables or as mechanisms for accomplishing database administration and other tasks that involve updating system tables.

In Embedded SQL, a target file is one of the three files the precompiler can generate. A target file is similar to the original input file, except that all SQL statements are converted to Client-Library function calls.

(Tabular Data Stream) An application-level protocol that Sybase clients and servers use to communicate. It allows the transfer of requests and results between clients and servers. See also .

A pointer, stored in database tables, in leiu of large text and image values.

A timestamp that is associated with each text or image column, to prevent competing applications from overwriting one another's modifications to the database.

A path of execution through a program. See also , , , .

A platform specific method used by Client-Library to allow non-blocking network reads and writes. Internally, Client-Library creates worker threads that interact with the network. The internal worker thread may block for reads or writes, but the user-application thread does not. Compare to .

A property of a routine or collection of routines that allows them to be safely executed by different threads in a multithreaded application. See also , , .

The act of managing the concurrent execution of multiple threads. A thread scheduler uses a well-defined algorithm to periodically suspend one thread, save its state, and resume (or begin) execution of another thread. See also , .

The use of serialization primitives in multithreaded code to ensure that the execution of related critical sections by different threads is mutually exclusive. Serialization consists of using serialization primitives to "protect" critical sections from simultaneous execution of related critical sections in different threads. In other words, serialization guarantees that once a critical section begins execution, its execution is not interleaved with the execution of a related critical section in a different thread. Serialization is commonly used to make code that accesses shared resources . See also , .

The use of synchronization primitives to guarantee a specific order of execution of code executed by two or more threads. Synchronization ensures that dependent actions executed by separate threads are performed in the correct order. See also , , .

Not . Thread-unsafe describes a property of program code that prohibits its execution by multiple threads. If thread-unsafe code executes simultaneously from multiple threads, it yields unpredictable behavior.

Transact-SQL is an enhanced version of the SQL database language. Applications can use Transact-SQL to communicate with Adaptive Server.

One or more server commands that are treated as a single unit. Commands within a transaction are committed as a group; that is, either all of them are committed or all of them are rolled back.

The manner in which Adaptive Server manages transactions. Adaptive Server supports two transaction modes: Transact-SQL mode (also called unchained transactions) and ANSI mode (also called chained transactions).

A measure of work done per unit of time. For example, the throughput of a operation might be measured as the number of rows transferred per second.

If an application intends to update the retrieved cursor rows using ct_cursor update commands, the cursor is updatable.

See .