| cache size: and page size | Table and page sizes |
| cache size: initial, min and max size | Limiting the memory used by the cache |
| cache size: Java applications on UNIX | Dynamic cache sizing (UNIX) |
| cache size: monitoring | Monitoring cache size |
| cache size: UNIX | Dynamic cache sizing (UNIX) |
| cache size: Windows 95/98 | Dynamic cache sizing (Windows NT/2000/XP, Windows 95/98/Me) |
| cache size: Windows NT | Dynamic cache sizing (Windows NT/2000/XP, Windows 95/98/Me) |
| cache: about | Using the cache to improve performance |
| cache: access plans | Access plan caching |
| cache: dynamic sizing | Using the cache to improve performance |
| cache: encrypted databases require larger cache | Increase the cache size |
| cache: initial, min and max size | Limiting the memory used by the cache |
| cache: Java applications on UNIX | Dynamic cache sizing (UNIX) |
| cache: monitoring size | Monitoring cache size |
| cache: performance | Increase the cache size |
| cache: read-hit ratio | Graphical plans |
| cache: UNIX | Dynamic cache sizing (UNIX) |
| cache: Windows 95/98 | Dynamic cache sizing (Windows NT/2000/XP, Windows 95/98/Me) |
| cache: Windows NT | Dynamic cache sizing (Windows NT/2000/XP, Windows 95/98/Me) |
| CacheHits: statistic in access plans | Reading access plans |
| CacheRead: statistic in access plans | Reading access plans |
| CacheReadIndLeaf: statistic in access plans | Reading access plans |
| CacheReadTable: statistic in access plans | Reading access plans |
| caching: access plans | Access plan caching |
| caching: subqueries | Subquery and function caching |
| caching: user-defined functions | Subquery and function caching |
| call stack: debugger | Working with variables |
| CALL statement: about | Procedure and trigger overview |
| CALL statement: examples | Calling procedures |
| CALL statement: parameters | Passing parameters to procedures |
| CALL statement: syntax | Control statements |
| calling external libraries from procedures | Calling external libraries from procedures |
| calling procedures | Calling procedures |
| calling user-defined functions | Calling user-defined functions |
| cancel: external functions | External function prototypes |
| canceling request: remote data access | Managing remote data access connections |
| candidate indexes: about | Index Consultant overview |
| candidate indexes: Index Consultant | Index Consultant overview |
| capturing workloads: Index Consultant | Index Consultant overview Understanding workloads |
| cardinality: item in access plans | Reading access plans |
| cardinality: relationships and | Relationships |
| Cartesian products | Cross joins |
| CASCADE action: about | Referential integrity actions |
| case sensitivity: creating ASE-compatible databases | Creating a Transact-SQL-compatible database |
| case sensitivity: data | Case sensitivity |
| case sensitivity: databases | Case sensitivity |
| case sensitivity: domains | Case sensitivity Case sensitivity |
| case sensitivity: identifiers | SQL queries Case sensitivity |
| case sensitivity: passwords | Case sensitivity |
| case sensitivity: remote access | Case sensitivity |
| case sensitivity: sort order | The ORDER BY clause: sorting query results |
| case sensitivity: Transact-SQL compatibility | Case sensitivity |
| case sensitivity: user IDs | Case sensitivity |
| CASE statement: syntax | Control statements |
| catalog: Adaptive Server Enterprise compatibility | System tables |
| cdata directive: using | Using FOR XML EXPLICIT |
| changing data: about | Adding, Changing, and Deleting Data |
| changing data: permissions | Permissions for data modification |
| changing data: UPDATE statement | Changing data using UPDATE |
| changing data: updating data using more than one table | Changing data using UPDATE |
| changing isolation levels within transactions | Changing isolation levels within a transaction |
| changing many-to-many relationships into entities | Changing many-to-many relationships into entities |
| changing the isolation level | Setting the isolation level |
| character data: searching for | Character strings and quotation marks |
| character strings and quotation marks | Character strings and quotation marks |
| character strings in query results | Character strings in query results |
| character strings: about | Character strings and quotation marks |
| character strings: quotes | Character strings and quotation marks |
| character strings: select list using | Computing values in the SELECT list |
| CHECK conditions: Transact-SQL | Defaults and rules |
| check constraints: choosing | Choosing constraints |
| CHECK constraints: columns | Using CHECK constraints on columns |
| CHECK constraints: deleting | Modifying and deleting CHECK constraints |
| CHECK constraints: domains | Inheriting column CHECK constraints from domains |
| CHECK constraints: modifying | Modifying and deleting CHECK constraints |
| CHECK constraints: tables | Using CHECK constraints on tables |
| check constraints: using in domains | Creating domains (SQL) |
| check if you need to change the command delimiter: procedures | Check if you need to change the command delimiter |
| check your file, table, and index fragmentation | Examine file, table, and index fragmentation |
| checking referential integrity at commit | Locking during inserts |
| choosing column names | Choosing column names |
| choosing constraints | Choosing constraints |
| choosing data types for columns | Choosing data types for columns |
| choosing isolation levels | Choosing isolation levels |
| classes: remote servers | Server Classes for Remote Data Access |
| clauses: about | Queries are made up of clauses |
| clauses: COMPUTE | Writing compatible queries |
| clauses: FOR BROWSE | Writing compatible queries |
| clauses: FOR READ ONLY | Writing compatible queries |
| clauses: FOR UPDATE | Writing compatible queries |
| clauses: GROUP BY ALL | Writing compatible queries |
| clauses: INTO | Returning results as procedure parameters |
| clauses: ON EXCEPTION RESUME | Transact-SQL-like error handling in the Watcom-SQL dialect Error handling with ON EXCEPTION RESUME Using exception handlers in procedures and triggers |
| clearing procedure profiling: SQL | Disabling procedure profiling |
| clearing procedure profiling: Sybase Central | Disabling procedure profiling |
| client side loading | Performance considerations of moving data |
| CLOSE statement: procedures | Cursor management overview |
| clustered indexes: Index Consultant recommendations | Understanding the recommendations Assessing the recommendations |
| clustered indexes: using | Using clustered indexes |
| colons separate join strategies | Text plans |
| column attributes: AUTOINCREMENT | Primary key generation |
| column attributes: generating default values | Primary key generation |
| column attributes: NEWID | Primary key generation |
| column CHECK constraints from domains | Inheriting column CHECK constraints from domains |
| column statistics: about | Optimizer estimates |
| column statistics: updating | Updating column statistics |
| columns: allowing NULL values | Choosing data types for columns |
| columns: altering | Altering tables (Sybase Central) Altering tables (SQL) |
| columns: assigning data types and domains | Creating domains (Sybase Central) |
| columns: constraints | Choosing constraints |
| columns: data types | Choosing data types for columns |
| columns: defaults | Using column defaults |
| columns: GROUP BY clause | The GROUP BY clause: organizing query results into groups |
| columns: IDENTITY | The special IDENTITY column |
| columns: naming | Choosing column names |
| columns: properties | Designing the database table properties |
| columns: select list | Selecting specific columns from a table |
| columns: select statements | Selecting specific columns from a table |
| columns: timestamp | The special Transact-SQL timestamp column and data type |
| command delimiter: setting | Check if you need to change the command delimiter |
| command files: building | Running SQL command files |
| command files: overview | Running SQL command files |
| command files: SQL Statements pane | Running SQL command files |
| commands: loading in Interactive SQL | Saving, loading, and running command files |
| commands: saving in Interactive SQL | Saving, loading, and running command files |
| commas: in star joins | Duplicate correlation names in joins (star joins) |
| commas: table expression lists | Commas |
| commas: when joining table expressions | Key joins of table expressions |
| COMMIT statement: compound statements | Atomic compound statements |
| COMMIT statement: procedures and triggers | Transactions and savepoints in procedures and triggers |
| COMMIT statement: verify referential integrity | Locking during inserts |
| COMMMIT statement: remote data access | Remote transaction management overview |
| common estimates used in the plan | Reading access plans |
| common statistics used in the plan | Reading access plans |
| common table expressions: about | Common Table Expressions |
| common table expressions: common applications | Typical applications of common table expressions |
| common table expressions: datatypes in recursive | Datatype declarations in recursive common table expressions |
| common table expressions: exploring hierarchical data structures | Selecting hierarchical data |
| common table expressions: least distance problems | Least distance problem |
| common table expressions: multiple aggregation levels | Typical applications of common table expressions |
| common table expressions: parts explosion problems | Parts explosion problems |
| common table expressions: restrictions on recursive | Restrictions on recursive common table expressions |
| common table expressions: storing constant sets | Typical applications of common table expressions |
| common table expressions: where permitted | Where common table expressions are permitted |
| comparison operators: NULL values | Testing a column for NULL |
| comparison operators: subqueries | Comparison operators |
| comparison operators: symbols | Using comparison operators in the WHERE clause |
| comparison test: subqueries | Subquery comparison test |
| comparisons: NULL values | Testing a column for NULL |
| comparisons: trailing blanks | Using comparison operators in the WHERE clause |
| compatibility of joins | Compatibility of joins |
| compatibility: Adaptive Server Enterprise | An overview of Transact-SQL support |
| compatibility: case sensitivity | Case sensitivity |
| compatibility: GROUP BY clause | Standards and compatibility |
| compatibility: import/export with Adaptive Server Enterprise | Adaptive Server Enterprise compatibility |
| compatibility: non-ANSI joins | Non-ANSI joins |
| compatibility: outputting nulls | Outputting NULLs |
| compatibility: servers and databases | Servers and databases |
| compatibility: setting options for Transact-SQL compatibility | Setting options for Transact-SQL compatibility |
| complete passthrough of the statement: remote data access | Complete passthrough of the statement |
| completing transactions | Using transactions |
| compliance with SQL standards | Designing Your Database |
| composite indexes: about | Composite indexes |
| composite indexes: effect of column order | Composite indexes |
| composite indexes: hash values | Hash B-tree indexes |
| compound statements: atomic | Atomic compound statements |
| compound statements: declarations | Declarations in compound statements |
| compound statements: using | Using compound statements |
| compressed B-tree indexes: about | Compressed B-tree indexes |
| compression: performance | Try using Adaptive Server Anywhere's compression features |
| COMPUTE clause: CREATE TABLE | Working with computed columns |
| COMPUTE clause: unsupported | Writing compatible queries |
| computed columns: creating | Working with computed columns |
| computed columns: indexes | Creating indexes |
| computed columns: INSERT statements | Inserting and updating computed columns |
| computed columns: limitations | When computed columns are recalculated |
| computed columns: making queries using functions sargable | Predicate analysis |
| computed columns: recalculation | When computed columns are recalculated |
| computed columns: triggers | Inserting and updating computed columns |
| computed columns: UPDATE statements | Inserting and updating computed columns |
| computing values in the SELECT list | Computing values in the SELECT list |
| concatenating strings: NULL | Properties of NULL |
| conceptual data modeling: about | Designing Your Database |
| conceptual database models: definition of | Database design concepts |
| concurrency | Introduction to concurrency |
| concurrency: about | Typical types of inconsistency Particular concurrency issues |
| concurrency: and data definition statements | Data definition statements and concurrency |
| concurrency: benefits of | Introduction to concurrency |
| concurrency: consistency | Typical types of inconsistency |
| concurrency: how locking works | How locking works |
| concurrency: improving | Improving concurrency at isolation levels 2 and 3 |
| concurrency: improving and indexes | Special optimizations |
| concurrency: improving using indexes | Reducing the impact of locking |
| concurrency: inconsistencies | Typical types of inconsistency |
| concurrency: ISO SQL/92 standard | Typical types of inconsistency |
| concurrency: performance | Introduction to concurrency |
| concurrency: primary keys | Particular concurrency issues |
| concurrency: replication | Replication and concurrency |
| concurrency: types of locks | Types of locks |
| concurrent transactions: blocking | Transaction blocking Non-repeatable read tutorial |
| conditions: connecting with logical operators | Connecting conditions with logical operators |
| configuration notes for JDBC classes | Configuration notes for JDBC classes |
| configuring databases for Transact-SQL compatibility | Configuring databases for Transact-SQL compatibility |
| configuring the Sybase Central Performance Monitor | Configuring the Sybase Central Performance Monitor |
| configuring: the Sybase Central Performance Monitor | Configuring the Sybase Central Performance Monitor |
| conflicts between locks | Types of locks |
| conflicts: cyclical blocking | Deadlock |
| conflicts: locking | Transaction blocking |
| conflicts: transaction blocking | Transaction blocking Non-repeatable read tutorial |
| conformance with SQL standards | Designing Your Database |
| connecting conditions with logical operators | Connecting conditions with logical operators |
| connecting: starting a database without connecting | Starting a database without connecting |
| connections: debugger | Working with connections |
| connections: debugging | Lesson 1: Connect to a database and start the debugger |
| connections: remote | Remote transaction management overview |
| CONNECTION_PROPERTY function: about | Obtaining database statistics from a client application |
| connectivity problems: remote data access | Connectivity problems |
| consistency: about | Introduction to transactions |
| consistency: assuring using locks | How locking works |
| consistency: correctness and scheduling | Serializable schedules |
| consistency: dirty reads | Typical types of inconsistency Locking during queries |
| consistency: dirty reads tutorial | Dirty read tutorial |
| consistency: during transactions | Typical types of inconsistency |
| consistency: effects of unserializable schedules | Serializable schedules |
| consistency: example of non-repeatable read | Non-repeatable read tutorial |
| consistency: ISO SQL/92 standard | Typical types of inconsistency |
| consistency: isolation levels | Isolation levels and consistency |
| consistency: phantom rows | Typical types of inconsistency Phantom row tutorial Locking during queries Two-phase locking |
| consistency: practical locking implications | Practical locking implications tutorial |
| consistency: repeatable reads | Typical types of inconsistency Non-repeatable read tutorial Locking during queries |
| consistency: two-phase locking | Two-phase locking |
| consistency: versus isolation levels | Typical types of inconsistency Phantom row tutorial Practical locking implications tutorial Two-phase locking |
| consistency: versus typical transactions | Typical transactions at various isolation levels |
| consolidated databases: setting | Specifying a consolidated database |
| constant expression defaults | Constant expression defaults |
| constraints | Working with table and column constraints in Sybase Central |
| constraints: CHECK constraints | Inheriting column CHECK constraints from domains |
| constraints: columns and tables | Choosing constraints |
| constraints: introduction | Data integrity tools |
| constraints: unique constraints | Working with table and column constraints in Sybase Central |
| contiguous storage of rows | Disk allocation for inserted rows |
| control statements: list | Control statements |
| conventions: documentation | SQL Anywhere Studio documentation |
| conversion errors during import | Conversion errors during import |
| conversion of outer joins to inner joins | Conversion of outer joins to inner joins |
| converting subqueries in the WHERE clause to joins | Converting subqueries in the WHERE clause to joins |
| copying database objects in Sybase Central | Copying database objects in Sybase Central |
| copying databases: replicating data and concurrency | Replication and concurrency |
| copying: data with INSERT | Adding new rows with SELECT |
| copying: database objects in Sybase Central | Copying database objects in Sybase Central |
| copying: procedures | Copying procedures in Sybase Central |
| copying: tables | Copying tables or columns within/between databases |
| copying: views | Using views |
| correlated subqueries: about | Existence test Correlated subqueries |
| correlated subqueries: outer references | Outer references |
| correlation names: about | Key joins when there are multiple foreign key relationships |
| correlation names: in self-joins | Self-joins |
| correlation names: in star joins | Duplicate correlation names in joins (star joins) |
| correlation names: table names | The FROM clause: specifying tables |
| cost model: about | How the optimizer works |
| cost model: Index Consultant use of | Understanding the analysis |
| cost-based optimization | The role of the optimizer |
| costs: Index Consultant recommendations | Understanding the recommendations Understanding the recommendations |
| COUNT function: about | Using COUNT(*) |
| COUNT function: NULL | Aggregate functions and NULL |
| CREATE DATABASE statement: Adaptive Server Enterprise | Servers and databases |
| CREATE DATABASE statement: using | Creating databases (SQL) Erasing a database |
| create database wizard: creating Transact-SQL compatible databases | Creating a Transact-SQL-compatible database |
| create database wizard: using | Creating databases (Sybase Central) |
| CREATE DEFAULT statement: unsupported | Defaults and rules |
| CREATE DOMAIN statement: Transact-SQL compatibility | Defaults and rules |
| CREATE DOMAIN statement: using | Using domains |
| CREATE EXISTING TABLE statement: using | Creating proxy tables with the CREATE EXISTING TABLE statement |
| CREATE FUNCTION statement: about | Creating user-defined functions |
| CREATE INDEX statement: and concurrency | Data definition statements and concurrency |
| CREATE PROCEDURE statement: examples | Creating procedures |
| CREATE PROCEDURE statement: parameters | Declaring parameters for procedures |
| CREATE RULE statement: unsupported | Defaults and rules |
| CREATE SERVER statement: JDBC and Adaptive Server Enterprise | Data type conversions: JDBC and Adaptive Server Enterprise |
| CREATE SERVER statement: ODBC and Adaptive Server Enterprise | Data type conversions: ODBC and Adaptive Server Enterprise |
| CREATE SERVER statement: remote servers | USING parameter value in the CREATE SERVER statement |
| CREATE TABLE statement: about | Creating tables |
| CREATE TABLE statement: and concurrency | Data definition statements and concurrency |
| CREATE TABLE statement: foreign keys | Managing foreign keys (SQL) |
| CREATE TABLE statement: primary keys | Managing primary keys (SQL) |
| CREATE TABLE statement: proxy tables | Creating a proxy table with the CREATE TABLE statement |
| CREATE TABLE statement: Transact-SQL | Creating compatible tables |
| CREATE TRIGGER statement: about | Creating triggers |
| CREATE VIEW statement: WITH CHECK OPTION clause | Using the WITH CHECK OPTION clause |
| creating a database | Creating a database |
| creating a proxy table with the CREATE TABLE statement | Creating a proxy table with the CREATE TABLE statement |
| creating a Transact-SQL-compatible database | Creating a Transact-SQL-compatible database |
| creating compatible tables | Creating compatible tables |
| creating databases: Sybase Central | Creating databases (Sybase Central) |
| creating external logins | Creating external logins |
| creating proxy tables in SQL | Creating proxy tables with the CREATE EXISTING TABLE statement |
| creating proxy tables in Sybase Central | Creating proxy tables (Sybase Central) |
| creating remote procedures | Creating remote procedures |
| creating remote servers | Creating remote servers |
| creating: column defaults | Creating column defaults |
| creating: data types | Creating domains (Sybase Central) Creating domains (SQL) |
| creating: database for Windows CE | Creating databases (Sybase Central) |
| creating: database from SQL | Creating databases (SQL) Erasing a database |
| creating: database from the command line | Creating databases (command line) |
| creating: domains | Creating domains (Sybase Central) Creating domains (SQL) |
| creating: indexes | Creating indexes |
| creating: procedures | Creating procedures |
| creating: procedures and functions with external calls | Creating procedures and functions with external calls |
| creating: remote procedures | Creating procedures |
| creating: tables | Creating tables |
| creating: triggers | Creating triggers |
| creating: user-defined functions | Creating user-defined functions |
| creating: views | Creating views |
| cross joins | Cross joins |
| cross products | Cross joins |
| current date and time defaults | Current date and time defaults |
| cursor instability | Cursor instability |
| cursor management: overview | Cursor management overview |
| cursors: and LOOP statement | Using cursors on SELECT statements in procedures |
| cursors: in procedures | Using cursors on SELECT statements in procedures |
| cursors: instability | Cursor instability |
| cursors: on SELECT statements | Using cursors on SELECT statements in procedures |
| cursors: procedures and triggers | Using cursors in procedures and triggers |
| cursors: stability | Cursor instability |
| cursors: updating in joins | Using joins in delete, update, and insert statements |
| customizing graphical plans | Graphical plans |
| cyclical blocking conflict | Deadlock |