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.
Adaptive Server Enterprise was called “SQL Server” in versions prior to 11.5.
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 synchronous. Client-Library has two asynchronous modes of operation, deferred-asynchronous and fully asynchronous.
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 Adaptive Server by means of a single Client-Library command or Embedded SQL statement.
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 through the bulk copy interface. Client-Library and Server-Library programmers can use Bulk-Library 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 Bulk-Library, bulk copy.
A collection of routines that allow Client-Library and Server-Library applications to access the Adaptive Server bulk copy interface. See also bulk copy.
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 callback functions to be called when Client-Library or CS-Library detects an error or when the server has sent a server message. See also client message callback, server message callback, CS-Library error handler, inline error handling.
The set of features that are supported by the version of the TDS 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 options, properties.
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 character set conversion, client character set.
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 character set. 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 character set used by the client application. The client character set can differ from the character set used by the server. See also character set conversion.
Part of Open Client, 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 CS-Library, Bulk-Library.
An error or informational message generated by Client-Library to inform the application of an error or exceptional condition. See also client message callback, inline error handling, callback error handling.
An application routine that is called each time Client-Library generates a client message to describe an error or unusual condition. See also callback error handling.
In Client-Library, 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 hidden Client-Library control structure that Client-Library applications use to send commands and process results.
A name that is unique only among entries that have the same parent node. See fully qualified name.
In Client-Library applications, a type of application callback routine. On fully asynchronous connections, Client-Library automatically invokes the application’s completion callback to communicate the completion status of each call to an asynchronous routine.
In Client-Library applications, the final return status of a call to an asynchronous routine. 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 through a completion callback. See also synchronous, deferred-asynchronous, fully asynchronous.
A hidden Client-Library control structure that defines a client/server connection within a context. See also command structure.
A CS-Library hidden structure that defines an application “context,” or operating environment, within a Client-Library or Open Server application. The CS-Library 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 character set. See also character set conversion.
A network-based authentication, in which 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, 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 thread serialization, thread-safe.
Included with both the Open Client and Open Server products, a collection of utility routines that are useful to both Client-Library and Server-Library applications. See also context structure.
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 Server-Library application and recommended in a Client-Library application. See also callback error handling.
A row to which a cursor points. A fetch against a cursor retrieves the current row. See also cursor.
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.
See also scrollable cursor.
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 and Open 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 and Open 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 uses 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 fully asynchronous.
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 directory service provider. See also interfaces file.
Converts directory entries from their native storage format into the Server Directory Object format.
A specification for the set of attributes (data) stored in a directory entry.
In a Client-Library application, a hidden structure (datatype CS_DS_OBJECT) that contains a copy of a directory entry that was read through a call to the ct_ds_lookup routine.
Sometimes called a naming service, manages creation, modification, and retrieval of directory entries.
System software that provides access to a directory for applications. For some platforms such as Windows, 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 DCE.
In directories that have an inverted-tree structure, the name of an interior node. The DIT base name is combined with partially qualified names to create a fully qualified name. See also directory, fully qualified name.
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 stored procedure.
A message that an Open Client and Open 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 event handler, event-driven programming.
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 event, event handler, Open Server thread.
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 event, event-driven programming.
A structure whose internals are exposed to Open Client and Open Server programmers. Open Client and Open Server programmers can declare, manipulate, and deallocate exposed structures directly. The CS_DATAFMT structure is an example of an exposed structure.
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 asynchronous routine completes. See also deferred-asynchronous, signal-driven I/O, thread-driven I/O.
A name that uniquely and unambiguously identifies a directory entry. An entry’s fully qualified name provides all the information that a directory service provider requires to find the entry.
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 object identifier.
A structure whose internals are hidden from Open Client and Open Server programmers. Open Client and Open Server programmers must use Open Client and Open Server routines to allocate, manipulate, and deallocate hidden structures. The CS_CONTEXT structure is an example of a hidden structure.
In Embedded SQL, a variable that enables data transfer between Adaptive Server and the application program. See also indicator variable, input variable, output variable, result variable, status variable.
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 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 command.
In Client-Library applications, a method of handling errors where the program tests for the occurrence of client messages, CS-Library errors, or server messages after each call to a CS-Library or Client-Library routine. Compare to callback error handling.
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.
In Embedded SQL, 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 current row in an open cursor.
A word or phrase that is reserved for exclusive use in Transact-SQL or Embedded SQL. Also called a “reserved word.”
In an Open Server 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, 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 locales file. Sybase predefines some locale names and the System Administrator can define additional locale names and add them to the locales file.
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 and Open Server products search the locales file when loading localization information.
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, defined as any command defined through 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 an Adaptive Server. An Adaptive Server login name is valid if Adaptive Server has an entry for that user in the system table syslogins.
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 thread-safe. See also thread.
A mutual exclusion semaphore. A mutex is a serialization primitive 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 native thread, Open Server thread.
A thread whose existence and scheduling are managed by the host operating system. See also thread scheduling, Open Server thread.
Certain login properties that the server can change during the login process, such as TDS version support 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.
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 global name.
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
A character string that contains an object identifier. 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 Server-Library.
A custom server constructed with Open Server. See also Open Server thread, event-driven programming.
A path of execution through an Open Server application 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 Server-Library. See also thread, thread scheduling, native thread.
Software that controls 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 capabilities, properties.
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.
An indicator identified by a question mark (?), that acts like a variable in a prepared statement.
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 capabilities, options.
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 registered procedure notifications, system registered procedure, remote procedure call.
An Open Server feature that allows a client to monitor the execution of a given registered procedure. 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 system registered procedure.
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.
Used by an application to determine what kinds of requests a server connection supports.
Used by an application to prevent the server from sending a type of response that the application cannot process.
The form in which results are returned to the application. 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.
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 select list.
A logical object and associated routines that allow serialization of access to shared resources. A mutex is an example of a serialization primitive. See also native thread, Open Server thread.
In client/server systems, the part of the system that processes client requests and returns results to clients. A server can be an Adaptive Server or an Open Server application.
A generalized description of the logical content of directory entries that describe Sybase servers.
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 server message callback, callback error handling, inline error handling.
In a Client-Library application, a callback function installed to receive each server message sent by the server. See also callback error handling.
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 thread-driven I/O.
Used to determine the order in which character data is sorted. Also called collating sequence.
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.
Allows a current cursor position to be set anywhere in a result set. See also cursor.
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 system stored procedures.
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 message queue). See also native thread, Open Server thread.
Occurring at a predictable point in time determined wholly by the logic of main-line program code. Compare to asynchronous.
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, an area of memory that holds a description of variables used in Dynamic SQL statements.
An internal registered procedure that Open Server supplies for managing registered procedure notifications and monitoring the server status. See also Open Server.
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, 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 capabilities.
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 thread scheduling, multithreaded, native thread, Open Server thread.
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 signal-driven I/O.
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 thread serialization, thread synchronization, thread-unsafe.
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 native thread, Open Server thread.
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 thread-safe. See also critical section, serialization primitive.
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 synchronization primitive, native thread, Open Server thread.
Not thread-safe. 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.
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 bulk copy operation might be measured as the number of rows transferred per second.
