Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_Identifier
_simba_int< Bits, Signed >Template to declare a simba_int type of Bits bits that is Signed or not. Supports 8, 16, 32, and 64 bits. Example: typename _simba_int<8,false>::type is an unsigned 8 bit integer. typename _simba_int<64,true>::type is an signed 64 bit integer
_simba_int< 16, false >
_simba_int< 16, true >
_simba_int< 32, false >
_simba_int< 32, true >
_simba_int< 64, false >
_simba_int< 64, true >
_simba_int< 8, false >
_simba_int< 8, true >
AbstractColumnSegmentBased column segment abstract class
AEAddA class that models the binary '+' value expression operator
AEAggregateA class that models the GROUP BY list and the aggregate functions
AEAggrFunctionA class that models the Set Functions in SQL-92 (aka Aggregate Functions)
AEAlterTableModels the <alter table statement> statement in section 11.10 of the SQL-92 spec
AEAndThis class models <boolean term> AND <boolean factor> in the SQL-92 spec
AEBinaryBooleanExprAn abstract base class for all binary boolean operations such as AND and OR
AEBinaryExprT< BaseNodeT, LOperandT, ROperandT, LOperandPtrT, ROperandPtrT >A template class that models an operation that takes two operands
AEBinaryRelationalExprAn abstract base class for all relational operations that take two relational operands
AEBinaryValueExprAn abstract base class for all binary operations
AEBooleanExprThe base class for all the bool expressions such as AND, OR, IN, and etc
AEBooleanTrueThis class acts as a 'dummy' AEBooleanExpr to be used where one is needed
AECloneValidatorA class that validate and update if necessary a clone AE tree
AEColumnA class that models a direct reference to a named relational expression which can be a table, view or sub-query in the FROM clause of a <query specification> as defined in the SQL-92 spec
AEColumnInfoA container class that encapsulates information for a column
AEComparisonThis class models the <comparison predicate> in the SQL-92:
AECountStarAggrFunctionA class that models the Set Functions in SQL-92 (aka Aggregate Functions)
AECreateIndexA class models the statement that creates an index on one or more columns
AECreateTableModels the <table definition> statement in section 11.3 of the SQL-92 spec
AECreateTableAsSelectModels the
AECreateViewModels the <view definition> statement in section 11.19 of the SQL-92 spec
AECrossJoinA class that models a relational CROSS JOIN operation
AECustomAggregateFnA class that models custom Set Functions in SQL-92 (aka Aggregate Functions)
AECustomScalarFnA class that models a custom Scalar Function
AEDefaultA class that represents a DEFAULT value
AEDistinctA class that models a DISTINCT operation
AEDivideA class that models the binary '/' (division) operator
AEDropIndexThe AECreateIndex class models the statement that drops an index. This statement is not defined in the SQL-92 spec but is a widely used extension
AEDropTableModels the <drop table statement> statement in section 11.18 of the SQL-92 spec
AEDropViewModels the <drop view statement> statement in section 11.20 of the SQL-92 spec
AEDummyTableA class representing a relational table with a single row
AEExceptThis class models the standard difference relational operation: R1 - R2
AEExistsPredicateThis class models the <between predicate> in the SQL-92:
AEGrantModels the <grant statement> statement in section 11.36 of the SQL-92 spec
AEGraphVizLogLog an AETree in the .dot format, which can be viewed in a program like GraphViz
AEInPredicateThis class models the <in predicate> in the SQL-92:
AEInsertModels the <insert statement> statement in section 13.8 of the SQL-92 spec
AEInsertDefaultsModels the <insert statement> statement in section 13.8 of the SQL-92 spec with the DEFAULT VALUES query expression
AEInsertionTableAn node which holds data for insertion and converts it to the target metadata when necessary
AEIntersectThis class models the standard intersect relational operation: R1 R2
AEIntervalLiteralA class that models interval literal expressions
AEJoinThis class models the derived join relational operation: Join(R1, R2, Cond), where "Cond" is the join condition
AELikePredicateThis class models the <like predicate> in the SQL-92:
AELiteralA class that models Literal expressions. These include:

  • Character String Literals
  • Decimal Numeric Literals
  • Approximate Numeric Literals
  • Timestamp Literals
AEMergeModels the <merge statement> statement in section 14.9 of the SQL-2003 spec
AEModifiedRowsModels the ODBC 4.0 'return' escape clause, which returns the rows Inserted, Updated, or Deleted from a DML sub-statement
AEMultiplyA class that models the binary '*' (multiply) operator
AENamedRelationalExprAn abstract base class for all relational expressions that have a name
AENativeSyntaxA class that models a native syntax
AENegateA class that models the unary '-' value expression operator
AENodeAn abstract base class that defines the basic behaviors that any Algebraic Expression (AE) node exhibits
AENodeIteratorA class that iterates through all the child nodes of an AENode
AENodeListT< BaseNodeT, ItemNodeT >A template class that holds a list of nodes of type ItemNodeT managed by a shared pointer
AENodeVisitorThis class plays the "visitor" role in the Visitor Pattern (see "Design Patterns" by Eric Gamma, et al.) between this class and AENode
AENotThis class models <boolean factor> ::= [NOT] <boolean test> in the SQL-92 spec
AENullA class that represents a NULL value
AENullPredicateThis class models the <null predicate> in the SQL-92:
AEOrThis class models <search condition> OR <boolean term> in the SQL-92 spec
AEParameterA class that models a SQL dynamic parameter
AEProcedureA class that models a stored procedure
AEProcedureCallModels <procedure> statement in section 12.3 of the SQL-92 spec
AEProjectThis class models an extended project relational operation: PI(R), where 'a' is the project list, R is the relation to operate upon
AEProxyColumnA class that models a column reference to any relational expression node
AEQColumnNameA struct for "qualified" column name
AEQTableNameA struct for "qualified" table name
AEQuantifiedComparisonThis class models the <quantified comparison predicate> in the SQL-92:
AEQueryModels the <direct select statement: multiple rows> statement in section 20.2 of the SQL-92 spec
AEQueryOperationThis abstract base class represents the top-most "query operations" such as SORT, LIMIT (in the future) or any other relational operations such as PROJECT
AEQuinaryExprT< BaseNodeT, Operand1T, Operand2T, Operand3T, Operand4T, Operand5T, Operand1PtrT, Operand2PtrT, Operand3PtrT, Operand4PtrT, Operand5PtrT >A template class that models an operation that takes five operands
AERelationalExprAn abstract base class for all relational expressions
AERenameA class that models the renaming of an attribute (column)
AERevokeModels the <revoke statement> statement in section 11.37 of the SQL-92 spec
AERowCountStatementAn abstract base class for any class that represents a DML statement
AEScalarFnA class that models a Scalar Function
AESearchedCaseThis node class represents the Searched Case value expression
AESearchedDeleteModels the <delete statement: searched> statement in section 13.7 of the SQL-92 spec
AESearchedUpdateModels the <update statement: searched> statement in section 13.10 of the SQL-92 spec
AESearchedWhenClauseThis node class represents a Searched When Clause
AESelectThis class models the standard "selection" relational operation: SIGMA_(c)(R), where c is the selection condition and R is the relation to operate on
AESetCatalogModels the <set catalog statement> statement in section 16.2 of the SQL-92 spec
AESetClauseModels the <set clause> statement in section 13.9 of the SQL-92 spec
AESetClauseListA container node class holds a list of set clauses
AESetOperationA base class for all three set operations - UNION, EXCEPT, and INTERSECT
AESetSchemaModels the <set schema statement> statement in section 16.2 of the SQL-92 spec
AESetStatementSet catalog or schema
AESimpleCaseThis node class represents the Simple Case value expression
AESimpleWhenClauseThis node class represents a Simple When Clause
AESortModels the ORDER BY clause of a query (i.e., SELECT statement)
AESqlTypesLookupTableThis is a utility class that manages and retrieves entries in 2D-array lookup tables
AEStatementAn abstract class that all concrete statement classes inherit
AEStatementsA class for managing an array of AEStatement objects
AESubQueryThis class does NOT represent any concrete relational expressions. It is designed to model a sub-query so that after the query optimization (which will manipulate the tree), a reference to a sub-query from an AEColumn object will still be valid
AESubtractA class that models the binary '-' (subtract) operator
AETableA class representing a relational table
AETableConstructorThis class models a <table value constructor>
AETerminalExprT< BaseNodeT >A template class that models an operation that takes no operand
AETernaryExprT< BaseNodeT, Operand1T, Operand2T, Operand3T, Operand1PtrT, Operand2PtrT, Operand3PtrT >A template class that models an operation that takes three operands
AETopA class that models a TOP N operation
AETopNSortA class that models a TOP N Sort operation
AETreeLogThis class along with AETreeLogVisitor form the envisioned AE tree viewer
AETreeLogVisitorAn AE tree "visitor" class for viewing
AETreeWalkerThis class walks through an AE tree in a pre-order traversal fashion
AEUnaryExprT< BaseNodeT, OperandT, OperandPtrT >A template class that models an operation that takes only one operand
AEUnaryRelationalExprAn abstract base class for all relational operations that take one relational operand
AEUnaryValueExprAbstract base class for all unary operations
AEUnionThis class models the standard union relational operation: R1 U R2
AEValueExprAn abstract base class for all value expressions such as +, -, and etc
AEValueListA container node class holds a list of nodes
AEValueSubQueryThis class models a value sub-query
AttributeDataAttributeData is used to store data for attributes
AutoArrayPtr< T >Provides pointer management
AutoDeque< T, Deallocator >Provides pointer management for deque
AutoList< T, Deallocator >Provides pointer management for lists
AutoPtr< T, Deallocator >Provides pointer management
AutoPtr_DefaultDeallocator< T >Default deallocator for AutoPtr, AutoVector, AutoList, and AutoValueMap
AutoSemaphoreUpA class that guarantees the Up() method will be called on the given semaphore upon destruction of an object of this class
AutoValueMap< K, T, C, A, Deallocator >Provides pointer management for maps with dynamic values
AutoVector< T, Deallocator >Provides pointer management for vectors
BadColumnExceptionUsed for reporting invalid column accesses
BadDefaultParamExceptionUsed to indicate that a "default" input parameter value was supplied for a parameter where "default" has no meaning
BadStateExceptionUsed for reporting an operation attempted during an invalid state
BasicFilteredMetadataResultThis sample implementation is a special filtered metadata result which applies generic filtering to the raw result set
BinaryFileBinaryFile class
BlockEncryptionFactoryThis class creates Swap File Encryption based on the default implementation
BoundedSynchronousQueue< QUEUE_DATA >Templatized implementation of a bounded synchronous queue
CallbackExceptionUsed for an exception that's thrown from the ODBC layer down into the DSI
CallStackUtility class that will generate the current callstack
CaseInsensitiveComparatorClass for doing case-insensitive comparisons of simba_wstring in a map
CharToCharIdentEncCvtFunctor< CODE_UNIT_SIZE >Declaration of the functor class template that converters SQL characters and wide-characters types to C characters and wide-characters types when the encoding is identical between the source and the target
CharToFromWCharCvtFunctorDeclaration of the functor class that converters SQL characters and wide-characters types to C characters and wide-characters types when the encoding is different between the source and the target
CloserRAII class to close a relational expression on destruction
ColumnPropertiesThe properties of a column in a RowBlock
ComBrandingInformation
ConditionalCriticalSectionLockA class that supports exception safe use of a CriticalSection, but locks conditionally
ConfigurationReaderDEPRECATED A class that supports reading configuration maps from the registry on Windows, an INI file on *nix, or a property list (.plist) file in an Apple-style framework
ConnectionSettingThis class defines options for connection settings transmitted between the DSI and ODBCFunctionality
ConnectionSettingInfoStructure describing the connection settings accepted by UpdateConnectionSettings and Connect functions
ConversionResultReturned error or warning structure from the type conversion methods
CppServerAPIConvenience C++ wrapper for the C-API
CriticalSectionA class that wraps platform specific "critical section" implementation
CriticalSectionLockA class that supports exception safe use of a CriticalSection
CToSqlBulkBuilderFuncGenerator< false, CType, SqlType, FunctorMap, WrapperMap, CharIdentEncConverterFunctor, CharDiffEncConverterFunctor >
CToSqlBulkBuilderFuncGenerator< true, CType, SqlType, FunctorMap, WrapperMap, CharIdentEncConverterFunctor, CharDiffEncConverterFunctor >
CToSqlDiffEncodingFunctor
CToSqlFunctor< TDW_C_GUID, TDW_SQL_GUID >
CToSqlFunctor< TDW_C_NUMERIC, TDW_SQL_INTERVAL_SECOND >
CToSqlFunctor< TDW_C_TYPE_TIME, TDW_SQL_TYPE_TIMESTAMP >
CToSqlFunctor< TDW_C_TYPE_TIMESTAMP, TDW_SQL_TYPE_TIME >
CToSqlFunctor< TDW_C_TYPE_TIMESTAMP, TDW_SQL_TYPE_TIMESTAMP >
CToSqlIdentEncodingFunctor< CODE_UNIT_SIZE >
CvtLengthStatic functions that handles the coding of the length parameters used by the conversion functors (all classes specializing the SqlToCFunctor template)
DataLengthColumnClass defining the fields necessary to describe a cell (the column value of a specific row) of the data/length column segment
DataLengthColumnSegmentClass implementing the column segment for a variable row size, or for when fixed size data is not accessible in a contiguous sequence
DataLengthIterThis class allows iteration on an input value/length buffer pairs. The pointer to the next element is computed by adding a fixed offset (one value for the value pointer and another one for the length)
DefaultCToSqlBulkBuilderFuncGenerator< CType, SqlType >Default C to SQL bulk converter builder class. It wraps the default functor into the default wrapper bulk converter
DefaultSqlToCBulkBuilderFuncGenerator< SqlType, SqlCType >
DirectoryUtilClass containing utility functions related to driver directory paths. Retrieves the framework Resources directory and application Documents directory on iOS
DiskSwapDeviceThis class implements the ISwapDevice interface for writing RowBlocks to a disk file
DSIBinaryCollationA concrete ICollation Implementation
DSIBinaryCollatorA collator that supports binary comparison using memcmp()
DSIBinaryHasherClass that implements IHasher. This class takes a randomized seed value
DSIBinaryHasherWithRightTrimmerClass that implements DSIBinaryHasher specifically for string data types. The class uses a right trimmer to get rid of the spaces on the right of the string
DSIBinaryLikeHelper
DSIBinaryLikeMatcherF-Bounded (CRTP) implementation for Unicode collation aware like predicate
DSICollatingSequenceA structure containing data for a collating sequence
DSIColumnThe DSIColumn is a suggested implementation of IColumn
DSIColumnMetadataStruct used for specifying metadata about a column
DSIColumnsViewAn IColumns which wraps another IColumns object to give a view to a subset of its columns
DSIConnectionThis class exposes an interface to interact with the customer DSII for connection details
DSIConnPropertiesDSIConnProperties holds the definition of all the connection properties that DSI supports
DSICToSqlBulkConverterFunctorMap< CType, SqlType >Map a C type and SQL type to the default functor that has to be used to do the C to SQL conversion
DSICToSqlBulkConverterWrapperMap< CType, ConverterFunctor >Map a C type and SQL type to the default bulk converter wrapper template that has to be used to do the C to SQL conversion
DSICustomMetadataColumnThe DSICustomMetadataColumn is a suggested implementation of IColumn that is used for custom columns in a metadata table
DSIDataEngineThis is a sample implementation of IDataEngine
DSIDefaultMetadataFilterFactoryThis class is the default implementation of IMetadataFilterFactory to create the following filters

DSIDriverDSIDriver class
DSIDriverPropertiesDSIDriverProperties holds the definition of all the driver properties that DSI supports
DSIDriverSingletonSingleton class to hold an IDriver
DSIEmptyMetadataSourceExposes an empty metadata source with no rows
DSIEnvironmentBase class for environment details
DSIEnvPropertiesDSIEnvProperties class contains all environment properties supported by DSI and provides service to map from a ODBC environment attribute key to a DSI environment property key
DSIExceptionUsed for DSI exceptions
DSIExceptionUtilitiesProvides utilities for throwing exceptions
DSIExtAbstractAggregationHandlerDefines an abstract class to facilitate the process of passing down of a relational AGGREGATION operation
DSIExtAbstractBooleanExprHandlerAn abstract class that facilitates the process of passing down filter and JOIN operations
DSIExtAbstractProjectionHandlerDefines an abstract class to facilitate the process of passing down of a relational PROJECTION operation. It supports:

  • Complete projection passing down
  • Partial projection passing down that only trying to pass down the sub-expression component if it is a column reference
DSIExtAbstractTopHandlerDefines an abstract class to facilitate the process of passing down of a relational TOP operation
DSIExtAggregateFunctionAn abstract class that represents a custom aggregate function from the DSII
DSIExtBinaryBooleanFunctorBase class for functors for the execution of binary boolean operations on custom data types
DSIExtBinaryFunctorBase class for functors for the execution of binary operations on custom data types
DSIExtBinaryValueFunctorBase class for functors for the execution of binary value operations on custom data types
DSIExtBookmarkSourceAn abstract class representing an iterator for relation bookmarks
DSIExtCatalogSchemasOnlyMetadataSourceDefault implementation for Catalog and Schema metadata source
DSIExtCatalogsOnlyMetadataSourceDefault implementation for catalog metadata
DSIExtCellComparatorFactoryFactory class for creating new ICellComparator*s
DSIExtCoercionHandlerImplements the ICoercionHandler interface
DSIExtCollationTypeTableA lookup table from DSICollationType to strings that are understood by ICU
DSIExtColumnCondition
DSIExtColumnFactoryA concrete IColumnFactory implementation
DSIExtColumnInSetConditionA class which defines a 'value is in this set' condition for a column in a seek. I.E, the SQL 'IN' operator
DSIExtColumnPrefixConditionA class which defines a prefix condition for a column. For example, "c1 LIKE 'prefix%'"
DSIExtColumnRangeConditionA class which defines a range condition for a column in a seek
DSIExtColumnRefDefines a column reference structure
DSIExtColumnsMetadataSourceDefault implementation for column metadata
DSIExtCustomBehaviorProviderA class that provides accessors for handlers and factories for custom engine behavior. In a sense, it acts as a provider of custom behavior for SimbaEngine
DSIExtDataEngineContextA class representing the "context" that a DSIExtSqlDataEngine object relies on for SQL statement preparation
DSIExtExecutorContextA class representing the "context" that a DSIExtQueryExecutor object relies on for SQL statement execution
DSIExtFunctorFactoryImplements the IFunctorFactory interface
DSIExtIndexAn abstract class representing an index on a relation
DSIExtIndexColumnA column contained within an index
DSIExtIndexKeyA class that represents a key for an index
DSIExtIndexMetadataRepresents the metadata for a single index
DSIExtIndexMetadataList
DSIExtInputParameterValueA class that represents an argument value that is read-only
DSIExtKeySegmentA simple immutable class which represents one segment (value) in a SeekCondition
DSIExtMetadataHelperA helper class that allows access to the list of tables and stored procedures in a data source
DSIExtNamedInputParameterValueA class that represents a parameter value that is read-only and is named
DSIExtNativeSyntaxAn abstract class that represents a NativeSyntax from the DSII
DSIExtNoncancelableMemoryContextImplementation of IMemoryContext which can be used when there's no access to the data engine context
DSIExtOperationHandlerFactoryA "factory" class that creates handlers to handle passing-down operations such as filters, joins, aggregations and unions
DSIExtParameterCacheManagerA class used by DSIExtQueryExecutor to allow the cached parameters to be safely cleared if SQLCancel is used asynchronously
DSIExtParameterMetadataThis class exposes an interface for the DSI to interact with parameter metadata
DSIExtParameterValueA class that represents a value for a stored procedure
DSIExtPartiallyFilteredMetadataSourceA partially filtered metadata source for procedure, procedure columns, tables, columns metadata sources
DSIExtPassdownInformationProvides information about which passdown operations are supported
DSIExtProcedureAn abstract class that represents a stored procedure from the DSII
DSIExtQueryExecutorSimba SQLEngine's implementation of IQueryExecutor
DSIExtResultSetAn abstract class that represents a result set from the DSII
DSIExtScalarFunctionAn abstract class that represents a custom scalar function from the DSII
DSIExtSchemasOnlyMetadataSourceDefault implementation for schema metadata
DSIExtSeekConditionA class that represents a key for an index. This class is used to seek into an
DSIExtSimpleAggregationHandlerDefines an abstract class to further simplify the process of passing down an AGGREGATION operation
DSIExtSimpleBooleanExprHandlerDefine an abstract class that simplifies the process of passing down a list of "simple" Boolean expressions as a filters or join conditions
DSIExtSimpleColumnConditionA class which defines a simple condition for a column in a seek. This is a column condition that does not require any other data than its type, such as COLUMN_CONDITION_IS_NOT_NULL, and as opposed to COLUMN_CONDITION_IS_IN_RANGE
DSIExtSimpleResultSetSimple partial implementation of DSIExtResultSet which supports forward-only cursors
DSIExtSortedResultSetThis class decorates the implementation of IResult in order to provide sorting capabilities
DSIExtSqlDataEngineAn abstract class that partially implements and extends the IDataEngine interface
DSIExtStatisticsMetadataSourceDefault implementation for table statistics
DSIExtTablesMetadataSourceDefault implementation for table metadata
DSIExtTypeInfoMetadataSourceDefault implementation for data type information
DSIExtUnaryFunctorBase class for functors for the execution of unary operations on custom data types
DSIExtUnaryValueFunctorBase class for functors for the execution of unary value operations on custom data types
DSIFileLoggerLogger class that logs to a file
DSIHasherFactoryA helper class that creates IHasher objects
DSILikeMatcher< T >A concrete implementation of the ILikeMather interface class. Acts as the base class for the CRTP implementation of the LIKE predicate
DSILogBase class for basic logging functionality
DSILoggerBase class for basic logging functionality
DSIMessageCacheThis class acts as a cache for all warning and error messages loaded through the DSII
DSIMessageManagerThis class manages the DSIXmlMessageReader*s that DSIMessageSource uses
DSIMessageSourceThis class represents an XML reader for a file message source that can be reused provided the XML file follows the standard format
DSIMetadataColumnsDSIMetadataColumns is a collection of metadata columns
DSIMetadataFilterDSIMetadataFilter is an abstract base class for filters
DSIMetadataFilterFactoryDSIMetadataFilterFactory provides a static method to create a vector of DSIMetadataFilters based on the catalog function
DSIMetadataRestrictionGeneratorDSIMetadataRestrictionGenerator provides a method to create restrictions used by metadata source to give a smaller result set
DSIMetadataSourceExposes raw, unfiltered or partially filtered, catalog metadata data as a table
DSIOutputMetadataColumnThe DSIOutputMetadataColumn is a suggested implementation of IColumn that is used for for output columns in a metadata table
DSIOutputMetadataColumnFactoryProvides a static method to create a list of DSIOutputMetadataColumn* based on the catalog function
DSIPatternUtilitiesUtility functions for using LIKE patterns
DSIPropertyUtilitiesDSIPropertyUtilities is a utility class to set properties that enable/disable common functionality such as stored procedure, catalog, and schema support
DSIResultsExposes an iterator over the results of execution to the ODBC Layer
DSIResultSetColumnThe DSIResultSetColumn is a suggested implementation of IColumn that is used for columns in a result set
DSIResultSetColumnsAbstract base class that the customer DSII will sub class and make concrete
DSIRowCountResultAn implementation of IResult which represents row count results
DSISimpleResultSetSimple partial implementation of IResult which facilitates forward-only cursors
DSISimpleRowCountResultSimple row count result that takes a known row count
DSISqlToCBulkConverterFactory< BuilderFuncGenerator >Factory class for creating SQL -> C bulk converters
DSISqlToCBulkConverterFunctorMap< SqlType, SqlCType >
DSISqlToCBulkConverterWrapperMap< SqlType, ConverterFunctor >
DSIStatementThis class is to expose an interface to interact with the customer DSII for statement details
DSIStmtPropertiesHolds the definition of all the statement properties that DSI supports
DSIStmtPropertyLimitKeysHolds DSI statement property keys for properties that describe the legal range of values for a specific property
DSITableTypeOnlyMetadataSourceSimple implementation of TableTypeOnlyMetadataSource
DSITypeUtilitiesProvides utilities for handling data types
DSIUnicodeCollationA concrete ICollation implementation
DSIUnicodeCollatorA collator that supports comparison with ICU
DSIUnicodeHasherClass that implements IHasher. A hasher that supports hashing with ICU
DSIUnicodeLikeHelper
DSIUnicodeLikeMatcherF-Bounded (CRTP) implementation for the Unicode collation aware like predicate
DSIXmlMessageReaderThis class represents a message reader for an XML source which can be reused for customer message sources provided the same format is used
EncodingInfoProvides information about encodings
EncryptedRandomAccessFileContainer class implementing the IFile interface and providing block encryption capabilities to an underlying random access file
equivalent_simba_int< T, Signed >Template to declare a simba_int of size equivalent to T
ErrorExceptionEncapsulates an error
Escaper
ETBinaryExprT< BaseNodeT, LOperandT, ROperandT, LOperandPtrT, ROperandPtrT >A template class that models an operation that takes two operands
ETBinaryLeftRelationalExpr< OperandT, OperandPtrT >An abstract base class for all relational operations that take one relational operand as the left child, and another node as the right child
ETBinaryRelationalExprAn abstract base class for all relational operations that take two relational operands
ETBooleanThis class represents the result of a predicate in SQL, either TRUE, FALSE, or UNKNOWN
ETBooleanExprThis abstract class defines the basic functionalities of any Boolean expression (AKA: Filter)
ETDataRequestUse the information given by the data request object and write the data value of the expression in the same data request object
ETDataRequest
ETExprThis is the abstract base class for all expression execution tree nodes. This includes Boolean, Relational and Value expressions
ETInnerJoinThis class models the derived join relational operation: Join(R1, R2, Cond), where "Cond" is the join condition
ETJoin
ETMaterializerThe interface of an "Materializer" that translate an AE Tree into an Execution Tree (ET)
ETMaterializerUtilsA utility class for the ETMaterializer* classes
ETMoveRequestThis container class encapsulates the arguments needed to move the result set to the "next" row
ETNodeThis is the abstract base class for all execution tree nodes. Its main functionality is to facilitate generic execution tree traversal
ETNodeIteratorA class that iterates through all the child nodes of an ETNode
ETParameterDataStores parameter data so that multiple ETParameter nodes can share it
ETRelationalCacheThis class represents a cache node, which can be added on top of another ETRelationalExpr node
ETRelationalExprThis abstract class defines the basic functionalities of any relational execution tree node
ETSimbaMaterializerSimba's implementation of ETMaterializer
ETTreeLogThis class along with ETreeLogVisitor form the envisioned ETree viewer
ETTreeLogVisitorAn ET tree "visitor" class for viewing
ETUnaryExprT< BaseNodeT, OperandT, OperandPtrT >A template class that models an operation that has only one operand
ETUnaryRelationalExprAn abstract base class for all "physical" relational operations that take one relational expression as the operand
ETWLoggerClass for ETW logging
ExecutedSQLInfoProvide information about the executed SQL command
FileFactoryThis class creates files based on DSII configuration
FileUtilsFile utility class
FilteredMetadataResultThis implementation is a special filtered metadata result which applies generic filtering to the partially filtered metadata
FixedRowSizeColumnSegmentClass implementing the column segment for fixed row sizes
IAggregationHandlerDefines the interface for passing down a relational AGGREGATION operation to the DSII
IBookmarkableDefines an interface for bookmarking
IBookmarkComparatorA comparator for comparing a relation's bookmarks
IBooleanExprHandlerDefines the interface for passing down filter or JOIN operations to the DSII
IBulkConversionListenerListener interface in which conversion results can be posted
IBulkParameterProcessorBulk processor interface for parameter segments
IBulkProcessorBulk processor interface
ICellComparatorA comparator for comparing a custom data type
ICellComparatorFactoryFactory class for creating new ICellComparator*s
ICellmarkA cell is the intersection of a row and a column in a result set
ICoercionHandlerICoercionHandler provides a facility to implement custom coercion rules - either for standard SQL types or for custom data types
ICollationDefines a thread safe abstract factory for the creation of ICollation concrete classes
ICollatorDefines an interface that does collation-aware string comparison
IColumnProvides access to metadata about a column, or an expression that acts like a column
IColumnFactoryDefines an abstract factory for the creation of IColumns
IColumnsExposes a group of IColumn objects
IConnectionThis class exposes an interface to interact with the customer DSII for connection details
IConversionListener
ICredentialFactoryA factory class used to create credentials objects. Each instance should only be used once to produce one set of credentials. The lifetime of the credential factory ends after successfully returning credentials or an error has been thrown
ICredentialsInterface representing credentials in an Integrated Security (Kerberos) environment. There may be more than one user principal stored in an ICredentials object. Methods on this may allow users to specify which principal to use
ICToSqlConverterInterface for all C To SQL Converter classes
IDataEngineThis class exposes an interface for SimbaLib to interact with the customer DSII for DataEngine details
IDistinctHandlerDefines the interface for passing down a relational DISTINCT operation to the DSII
IDMetadataFilterIDMetadataFilter is an implementation for a filter used for Identifier Arguments
IDriverThis class exposes an interface to interact with the customer DSII for driver details
IEnvironmentThis class exposes an interface to interact with the customer DSII for environment details
IEscapeReplacer
IFileThis class provides an interface for file classes
IFunctorFactoryIFunctorFactory provides a facility to create new Functors for the execution of an operation on a custom data type
IHasherClass that provides a hash function over the given value
IIndexMetadataRepresents the metadata for a single index
IIndexMetadataListExposes a group of IIndexMetadata objects
ILikeMatcherDefines an abstract interface for the creation of LIKE predicate matchers. Used in the SQLEngine to implement the SQL LIKE predicate
ILoggerDefine the interface of the logging facility
IMemoryContextThis class defines an interface for the memory requesters that call MemoryManager's ReserveBlocks method. Since this method can make the requester wait until enough memory is available, these requesters will not be able to respond to a SQLCancel unless they let the memory manager know that they are ready to quit, where the memory manager throws an exception, and lets them quit waiting
IMessageSourceInterface used to load OEM and localized messages
IMetadataFilterFactoryThis class exposes an interface for customer DSII to create their own customFilters
INativeSyntaxAn interface that represents a NativeQuery from the DSII
IniFileConfigurationReaderA class that supports reading configuration maps from an INI file. It is both used on Windows and Linux/OSX/Unix
INotifiableSpecifies an interface for objects to be notified of an event
IntervalParserFacadeHelper Class that hides the internal structure of Interval Parser, and exposes the the methods of IntervalParser
InvalidArgumentExceptionThis class represents an exception for when an invalid argument is given to a function or method
InvalidCatalogExceptionUsed for reporting invalid catalogs
InvalidOperationExceptionAn exception thrown when an operation has been "illegally" invoked
InvalidSchemaExceptionUsed for reporting invalid schemas
InvalidTypeConversionExceptionUsed for reporting illegal type conversions
IODBCStringConverterAn interface that supports conversion between simba_wstrings and ODBC SQLCHAR and SQLWCHAR buffers
IParameterManagerThis class exposes an interface for the DSI to interact with ODBC layer in order to provide information about parameters
IParameterMetadataThis class exposes an interface for the DSI to interact with parameter metadata
IParameterSetThis class exposes an interface for customer DSII to interact with ODBC layer for accessing a particular parameter set
IParameterSetIterThis class exposes an interface for customer DSII to interact with ODBC layer to access parameter sets
IParameterSetStatusSetThis class exposes an interface for customer DSII to access parameter set statuses
IParameterSourceThis class exposes an interface for the DSI to interact with a parameter and associated metadata and data
IParseTreeVisitorParseTree Visitor Interface
IProjectionHandlerDefines the interface for passing down a relational PROJECTION operation to the DSII
IQueryExecutorExposes query execution to the ODBC layer
IReplacerInterface for a functor that matches/replaces substrings of a SQL query that have been selected and sanitized by ODBCEscaper
IResidentBlockIteratorDefines an iterator interface that iterates all RowBlock objects held resident by an ISwapAssistant object
IResultExposes query result functionality to the ODBC layer
IResultsExposes an iterator to the results of an execution to the ODBC layer
ISecurityContext
ISortHandlerDefines the interface for passing down a relational SORT operation to the DSII
ISqlGeneratorInterface for a SQL generator, which generates a SQL statement from a parse tree
ISqlToCBulkConverterSQL to C bulk converter interface
ISqlToCBulkConverterFactoryFactory class for creating SQL -> C bulk converters
ISqlToCConverterInterface for all SQL To C Converter classes
ISqlToSqlConverterInterface for all SQL To SQL Converter classes
IStatementThis class exposes an interface to interact with the DSII for statement details
ISwapAssistantDefines the general interface for a class that manages a list of resident RowBlocks (i.e., RowBlocks held in memory)
ITableTemplate
ITaskThis class exposes an interface to interact with generic task objects used initially for implementing ODBC asynchronous ODBC execution
ITemporaryTableExposes methods for writing data to the TemporaryTable, in addition to the IResult functionalities
ITopHandlerDefines the interface for passing down a relational TOP operation to the DSII
ITransactionStateListenerAn ITransactionStateListener allows the object that it is registered with to notify any components using the DSI that a transaction state change has occurred because of a SQL statement
IUnionHandlerDefines the interface for passing down a relational UNION operation to the DSII
IUseableIndexMetadataRepresents the metadata for an index which can be used by the SQLEngine in the execution of a query
IWarningListenerAn interface for posting warnings
IWarningSourceAn interface for classes which can post warnings to an IWarningListener. For example, IEnvironment, IConnection, and IStatement
IWStreamConverterIWStreamConverter is used to stream convert data from one wide string encoding to another
IWStreamConverterFactoryA factory interface that supports construction of new IWStreamConverter instances
IWStringConverterAn interface that supports conversion between simba_wstrings and other data types
JNIArgumentsA class that translates an array of Java strings and make them presentable to SimbaServer
LargeInteger_Hollow LargeInteger struct to store size and alignment
LicenseValidatorUtility class to allow a DSI implementation to verify a license file
LikeMatcherAn object which matches character data against a LIKE pattern. Created via DSIPatternUtilities::CreateLikeMatcher()
LikeNodeStruct that defines the nodes which contain parts of the parsed LIKE pattern
ListenerA base class which allows one to get a callback when a given setting is changed
LongDataCacheThis class allows for storing long data from the underlying relational expression
LongDataCacheInfoPrepared binary cache table information
LongDataCacheTableBuilds on the TemporaryTable, allowing for storing long data when an underlying relational expression doesn't support bookmarking
map
MapUtilitiesProvides some utility functions to deal with std::map
MemoryFileThis class mimics a disk file with an in-memory representation
MemoryFileBlockStructure that represents a file block for a MemoryFile
MemoryManagerThis class is used to manage/track blocks of data and MemoryFileBlock objects
MultiRowsConversionListener
NoDataInputParamExceptionUsed when the input buffer is requested from a parameter whose value is known to be default or has already been pushed down to the IQueryExecutor earlier using PushParamData()
NullColumnsMetadataResultThis sample implementation is a special filtered metadata result which fills in NULLs for columns with derived ID of DSI_NULL_DERIVED_COLUMN_ID
NumberConversionExceptionAbstract number conversion exception
NumberConversionInvalidDataExceptionNumber conversion exception - invalid data exception
NumberConversionOutOfRangeExceptionNumber conversion exception - out of range exception
NumberConverterConverts between strings and numbers
OAMetadataFilterOAMetadataFilter is an implementation for a filter used for Ordinary Arguments
ODBCEscaperScanner for ODBC query strings, Applying a DS-specific match/replace function,
OperationCanceledExceptionUsed for reporting cancellation of operations
ParameterCacheReferenceA class which exposes a reference to the parameter cache, while reference counting
PlatformThe entry point for all platform specific services
PrimaryKeyConstraintRepresents a primary key constraint on a table
PrivilegedActionFunctor struct base class for privileged actions that can be executed as the principal represented by an ICredentials instance
ProductExceptionParent class for exceptions coming out of the Simba::Product namespace
PSFlagParseNodeRepresents a flag parse node
PSIdentifierParseNodePSIdentifierParseNodes represent PSParseNodes that have identifiers associated with them
PSIntervalDataTypeParseNode
PSIntervalLiteralParseNode
PSLiteralParseNodeA parse node for representing literals
PSNodeIteratorA class that iterates through all the child nodes of a PSParseNode
PSNonTerminalParseNodeThis class represents NonTerminal ParseNodes. NonTerminal ParseNodes have 1 or more child nodes
PSNullParseNodeSEP_NullParseNodes act as placeholders for optional nodes
PSParameterParseNodeThis class models a dynamic parameter in a SQL statement. A dynamic parameter is indicated by a "?" mark
PSParseNodeA PSParseNode encapsulates one "chunk" of information parsed from a raw SQL string. ParseNodes are hierarchically organized with parent PSParseNodes "owning" child ParseNodes. ParseNodes are unidirectional from parent to child. ParseNodes cannot share children. The ParseNodes form a tree, not a graph
PSParserThe class wrapping the parsing functionality
PSParseTreeDecoratorA utility class for manipulating an existing parse tree
PSParseTreeFactoryFactory class for building parse tree constructs
PSParseTreeLogRepresents a log file for logging the string representation of a parse tree
PSParseTreeSqlVisitorImplementation of the IParseTreeVisitor interface
PSRootParseNodeWrapper for the root node of the parse tree
PSScalarOrAggrFnParseNodeA parse tree node for representing scalar or custom aggregate functions
PSSql92GeneratorImplementation for a SQL-92 generator, which generates a SQL-92 statement from a parse tree
PSTransactSqlGeneratorImplementation for a Transact-SQL generator, which generates a Transact-SQL statement from a parse tree
PSTreeWalkerThis class walks through an AE tree in a pre-order traversal fashion
PushedParamData
PVMetadataFilterPVMetadataFilter is an implementation for a filter used for Pattern Value Arguments
ReadFromOutputParamExceptionUsed for reporting reading from an output only parameter
RefCountedPtr< T >Class Definition of RefCountedPtr, a smart pointer to reference counted objects. References to reference counted objects are Retain()d and Release()d as RefCountedPtrs are constructed, copied, assigned, and deleted
RegistryConfigurationReaderA class that supports reading configuration maps from the registry on Windows
RightTrimmerInterface of an object to trim whitespace (spaces and tabs) off the right of some string data. Depending on the encoding, the implementation may be able to do this without any conversions or copying
RowBlockBlock of memory containing 1..N rows, where N is the maximum number of whole rows that this block will allow
RowBlockPropertiesThis class represents the properties that holds constant across all blocks held by one SwapManager instance
ScopedOpenRAII class to ensure that a relational expression gets closed after being opened
ScopedOpen
SearchContext< P >Struct for optimizing multiple searches when backtracking takes place
SEInvalidArgumentExceptionThis class represents an exception for when an invalid argument is given to a function or method
SEInvalidOperationExceptionAn exception thrown when an operation has been "illegally" invoked
SEInvalidParseTreeExceptionAn exception when an invalid parse tree is found
SELogicErrorExceptionAn exception thrown when logical errors occurs
SemaphoreSemaphore class
SENCToSqlConversionSupport< CType, SqlType >Generic template defining if a specific C to SQL conversion is supported. The default template indicate that the conversion is not supported. It must be specialized for all supported conversion
SENSqlToCConversionSupport< SqlType, SqlCType >
ServerColumnSegmentColumn segment used on the Server
SESortInfoThe struct holds the information for pass down sort
SESortSpecDefines a sort specification
SESqlEngineExceptionThis is the base exception class from which all exceptions from the SQLEngine should extend
SESqlErrorThis class models SQL errors and warnings
SESqlErrorExceptionAn exception for all SQL errors
SharedPtr< T >Provides safe pointer management
SharedSingletonManagerA static class responsible for initializing & uninitializing singletons
simba_int< Bits >Template to declare a signed simba_int of 8,16,32 or 64 bits
simba_uint< Bits >Template to declare an unsigned simba_int of 8,16,32 or 64 bits
simba_wstringPortable Unicode string
SimbaSettingReaderProvides static methods that can be used to read registry or INI settings
SimbaStringCaseInsensitiveComparatorProvides a custom case insensitive string comparator to be used with maps
SingleRowConversionListener
SingletonT< T >Template class for non thread-safe singleton implementations
SingletonWrapperT< T >Template class for a singleton wrapper class, which 'wraps' another singleton
SmallIntMetadataFilterSmallIntMetadataFilter is an implementation for a filter used for Pattern Value Arguments
SqlCDataEncapsulates application-side data (octet length and buffer pointer) as well as the SqlCTypeMetadata* for SQL C data
SqlCDataPoolA pool for holding SqlCData objects
SqlCDataTypeUtilitiesThis class contains methods that provide information about SQL C types
SqlConverterFactoryFactory class for creating Sql*Converter*s
SqlCTypeMetadataProvides access to type metadata information for SQL C types
SqlCTypeMetadataFactoryConstructs SqlCTypeMetadata*s and fills them in with default values for SQL C types
SqlDataEncapsulates a buffer and SqlTypeMetadata* for SQL typed data
SqlDataFactorySqlDataFactory provides a facility to create a new SqlData* wrapper for a given SqlTypeMetadata*
SqlDataTypeUtilitiesThis class contains methods that provide information about SQL types
SqlFixedLengthType< TYPE >Encapsulates SQL fixed length type buffers
SQLStateA Class which represents ODBC SQLStates
SqlToCBulkBuilderFuncGenerator< false, SqlType, SqlCType, FunctorMap, WrapperMap, CharIdentEncConverterFunctor, CharDiffEncConverterFunctor >
SqlToCBulkBuilderFuncGenerator< true, SqlType, SqlCType, FunctorMap, WrapperMap, CharIdentEncConverterFunctor, CharDiffEncConverterFunctor >
SqlToCBulkConverter< FunctorT >Template defining the SQL to C bulk converter based on a specific functor class
SqlToCFunctor< TDW_SQL_GUID, TDW_C_CHAR >Declaration of the functor class that converters SQL GUID to C characters types
SqlToCFunctor< TDW_SQL_GUID, TDW_C_GUID >Declaration of the functor class that converters SQL GUID to C GUID types
SqlToCFunctor< TDW_SQL_GUID, TDW_C_WCHAR >Declaration of the functor class that converters SQL GUID to C wide-characters types
SqlToCFunctor< TDW_SQL_INTERVAL_SECOND, TDW_C_NUMERIC >Declaration of the functor class that converters SQL interval second to C exact numeric
SqlTranslationWrapper class to a SQL translation shared library
SqlTypeInfoStruct describing a single SQL type
SqlTypeMetadataProvides access to type metadata information for SQL types
SqlTypeMetadataFactoryConstructs SqlTypeMetadata*s and fills them in with default values for SQL types
SqlVarLengthAttachedTypeEncapsulates variable sized, buffer based SQL Types where the buffer is supplied
SqlVarLengthOwnedTypeEncapsulates variable sized, buffer based SQL Types with an internally allocated buffer
StartupInitExceptionThis class is for Licensing exceptions, such as eval expired, or license file not found
StatementMemoryContextUsed to represent a statement-wide memory context. Uses SharedPtr to ensure that there is only 1 context per-statement at a time
StringConvertingPartialRetrievalHelper< GetDataFn >A helper for retrieving char in parts when a conversion is needed due to a mismatch between source and target encodings
StringMetadataFilterThis implementation is an abstract base class for String metadata filters
SupportErrorThis class models Support errors and warnings
SupportExceptionParent class for exceptions coming out of the Simba::Support namespace
SwapDeviceDefines the interface for a class that swaps RowBlocks to an external device
SwapDeviceFactoryThis class creates Swap Devices based on DSII configuration
SwapFileSwapFile class for backing up the SwapManager
SwapManagerThis class manages a number of consecutive RowBlocks held either in memory or on disk
SynchronousQueue< QUEUE_DATA >Templatized implementation of a synchronous queue
TableColumnInitializer< StartCType, EndCType, SqlType, BuilderFuncGenerator >Fill in a column of the converter builder table, row by row
TableColumnInitializer< SqlCType, SqlCType, SqlType, BuilderFuncGenerator >Base case for the TableColumnInitializer template
TableColumnsInitializer< StartSqlType, EndSqlType, BuilderFuncGenerator >Fill in the entire converter builder table, column by column
TableColumnsInitializer< SqlType, SqlType, BuilderFuncGenerator >Base case for the TableColumnsInitializer template
TableConstraintAbstract class representing a constraint on a table
TableSpecificationRepresents the specification of a table, used in table creation
TDWDateStructure for date type, adapted from SQL_DATE_STRUCT in sqltypes.h
TDWDayHourIntervalStructure for day/hour interval type
TDWDayMinuteIntervalStructure for day/minute interval type
TDWDaySecondIntervalStructure for day/second interval type
TDWExactNumericTypeClass representing an exact numeric value with a fixed scale
TDWGuidStructure for guid type, adapted from SQLGUID in sqltypes.h
TDWHourMinuteIntervalStructure for hour/minute interval type
TDWHourSecondIntervalStructure for hour/second interval type
TDWMinuteSecondIntervalStructure for minute/second interval type
TDWSecondIntervalStructure for second interval type
TDWSingleFieldIntervalStructure for single field interval types
TDWTimeStructure for time type
TDWTimestampStructure for timestamp type, adapted from SQL_TIMESTAMP_STRUCT in sqltypes.h
TDWYearMonthIntervalStructure for year/month interval type, adapted from SQL_YEAR_MONTH_STRUCT in sqltypes.h
TemporaryTableThis class represents a table that can have data written to and read from without worry of running out of memory, but will cease to exist when the object is destroyed
TemporaryTableFactoryTemporaryTableFactory provides a static method to create a new ITemporaryTable*
TemporaryTableInfoPrepared temporary table information used to create a temporary table
TextFileTextFile class implementation
ThreadBase class for thread implementations
ThreadInterruptExceptionEncapsulates an error when a thread is interrupted
ThreadPoolThis class exposes an interface to interact with generic task objects to be executed on background threads. This is to be used internally for the ODBC and OLEDB Async features but may also be used externally for concurrent work processing
ThreadSafeSharedObjectThis template class provides a thread-safe implementation of SharedObject interface
TimestampTzConverterClass which converts timestamps with timezones from varying string formats to a TDWTimestamp with UTC timezone
TSRefCountedPtr< T >Class Definition of TSRefCountedPtr, a smart pointer to reference counted objects. References to reference counted objects are Retain()d and Release()d as TSRefCountedPtrs are constructed, copied, assigned, and deleted
TSSingletonT< T >Template class for thread-safe singleton implementations
TypeConversionInfo
TypeConverterUtility class that converts between void* and char*
TypeMetadataAbstract base class that provides access to type metadata information
UniqueConstraintRepresents a uniqueness constraint on a table
UnsafeSharedObjectThis template class provides a thread-unsafe implementation of SharedObject interface
UnsafeSharedObjectT< BaseType >This template class provides a thread-unsafe implementation of SharedObject interface. It is designed to be used to avoid multiple inheritance
UtilityFactoryAccessor for Support handler and utility classes
val_s
VariantVariant class is to be used as a single type to be stored in standard containers for either long, short or string data types
vector
VLMetadataFilterVLMetadataFilter is an implementation for a filter used for Value List Arguments
VoidPtrConverterConverts a 64bit pointer to a particular type
WriteToDefaultParamExceptionUsed for reporting writing to a default parameter
WriteToInputParamExceptionUsed for reporting writing to an input only parameter

Generated on Wed May 17 14:21:14 2017 for SimbaEngine 10.1.3.1011 by simba