Changes between Version 17 and Version 18 of FDORfc20

Timestamp:

06/12/08 16:14:34 (17 years ago)

Author:

thomasknoell

Comment:

--

FDORfc20

@@ -10 +10 @@
 ||Submission Date|| April 30, 2008 ||
 ||Last Modified|| Jack Lee [[Timestamp]]||
-||Author||Greg Boone||
+||Author||Thomas Knoell||
 ||RFC Status||Draft|| 
 ||Implementation Status||Pending||
@@ -47 +47 @@
 
 
-== !DataStore Capability Support ==
-
-Unmanaged
-
-The change to support both provider and datastore level capabilities is done by adding an overloaded function to each of the top-level FdoIConnection capability functions. The overloaded function will have a ''datastoreLevel'' parameter to specify whether the capabilities are for the provider or for the currently connected datastore. Since the existing function will not be removed, there will be two ways to retrieve the provider capabilites.
-
-This could be an enum rather than a boolean, although I can’t think of any options that we could add to the enum in the future past these two.
-
-
-Managed
-
-The existing managed API to retrieve the capabilities is defined as a property. The change to support both provider and datastore level capabilities is done by adding a new function to each of the top-level IConnection capability functions. The new functions will have a ''datastoreLevel'' parameter to specify whether the capabilities are for the provider or for the currently connected datastore. Since the existing property will not be removed, there will be two ways to retrieve the provider capabilites.
-
-
-The table below specifies the changes to the above functions.
-
-'''New FdoIConnection/IConnection Functions'''
-
-Unmanaged
-{{{
-virtual FdoICommandCapabilities *       GetCommandCapabilities (bool datastoreLevel) = 0
-virtual FdoIConnectionCapabilities *    GetConnectionCapabilities (bool datastoreLevel) = 0
-virtual FdoIExpressionCapabilities *    GetExpressionCapabilities (bool datastoreLevel) = 0
-virtual FdoIFilterCapabilities *        GetFilterCapabilities (bool datastoreLevel) = 0
-virtual FdoIGeometryCapabilities *      GetGeometryCapabilities (bool datastoreLevel) = 0
-virtual FdoIRasterCapabilities *        GetRasterCapabilities (bool datastoreLevel) = 0
-virtual FdoISchemaCapabilities *        GetSchemaCapabilities (bool datastoreLevel) = 0
-virtual FdoITopologyCapabilities *      GetTopologyCapabilities (bool datastoreLevel) = 0
-}}}
-
-Managed
-{{{
-NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::ICommandCapabilities* GetCommandCapabilities(System::Boolean datastoreLevel);
-NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::IConnectionCapabilities* GetConnectionCapabilities(System::Boolean datastoreLevel);
-NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::IExpressionCapabilities* GetExpressionCapabilities(System::Boolean datastoreLevel);
-NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::IFilterCapabilities* GetFilterCapabilities(System::Boolean datastoreLevel);
-NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::IGeometryCapabilities* GetGeometryCapabilities(System::Boolean datastoreLevel);
-NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::IRasterCapabilities* GetRasterCapabilities(System::Boolean datastoreLevel);
-NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::ISchemaCapabilities* GetSchemaCapabilities(System::Boolean datastoreLevel);
-NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::ITopologyCapabilities* GetTopologyCapabilities(System::Boolean datastoreLevel);
-}}}
-
-If datastore level capabilities are chosen, then the results will reflect any limitations that the datastore has around those capabilities. Command capabilities will return a smaller list of supported commands for example if the datastore is read-only. In this case, commands such as Update will not be returned.
-
-Datastore level capabilities would only be available after connecting to a datastore. Requesting datastore level capabilities before a successful connection will result in an exception.
-
-Some capabilities such as thread capability would not be different between provider level and datastore level.
-
-'''Impact of !DataStore Level Capabilities on the Above Capability Sets'''
-
-''Command Capabilities''
-
-    * The set of supported commands for a datastore could be less than for the general provider. A provider may support long transaction commands, but a particular datastore may not support them.
-
-''Connection Capabilities''
-
-    * Of the connection capabilities, locking and long transactions are ones that typically could be different.
-
-''Expression Capabilities''
-
-    * The expression types supported typically would not change, although the list of supported functions could be different, e.g. ODBC sources could have different sets of supported functions.
-
-''Filter Capabilities''
-
-    * As with expressions, these typically would not change, although there could be cases where spatial filters could be more limited.
-
-''Geometry Capabilities''
-
-    * At this time, this capability would not change for a datastore. However, in the future, different ODBC source could have different capabilities here (currently only point geometry is supported for all ODBC sources), or more advanced geometries may be available with future versions of the Oracle server where the Oracle provider can connect to different Oracle versions.
-
-''Raster Capabilities''
-
-    * Different sources could support different data models.
-
-''Schema Capabilities''
-
-    * At the datastore level, different sources could have different limitations, e.g. different versions of Oracle server or SQL Server, or different ODBC sources.
-
-== Issues ==
-
-How much datastore specific limitations can the ODBC provider determine through the ODBC API? Is it capable enough to support the additional schema capabilities specified in this document? Not all odbc providers support all the ODBC capabilities to determine schema information.
+== Proposals ==
+
+This section outlines the proposed changes to the FDO capability interfaces related to the three objectives to be addressed.
+
+
+=== FDO Capability Interface Simplification ===
+
+Currently, there is a FDO interface for each capability FDO supports. Any change to the capability set requires a new interface to be added to FDO to retrieve the value. As a result, FDO is no longer binary compatible once this is done and requires a re-build of FDO and any provider wanting to use the updated FDO version.
+
+The aim of this requirement is to address this issue. The idea is to have a simplified set of capability interfaces that allows retrieving different capability values where the capability for which the value is to be returned is indicated by an identifier. As a result, adding a new capability would not require the addition of a new interface.
+
+All capability functions can be categorized as outlined next:
+
+    * Boolean: These functions return a flag indicating whether or not a capability is supported. The category includes routines such as !SupportsLocking(), !SupportsCompositeId() or !SupportsAutoIdGeneration().
+    * Enumerates: These functions return an identifier from an enumeration. The category includes routines such as !GetThreadCapability().
+    * Array of enumerated values: These functions return an array of values from an enumeration and the number of elements in that array. The category includes routines such as !GetSpatialContextTypes() or !GetLockTypes().
+    * Collection: These functions return a collection of complex objects. The category includes routines such as !GetFunctions().
+    * Bit-mask values: These functions return a bit-mask value of enumerated values. The category includes routines such as !GetDimensionality().
+    * Capability based numbers: These functions take a capability identifier and return the corresponding capability value. The category includes routines such as !GetMaximumDataValueLength() or !GetNameSizeLimit().
+    * Numbers: These functions return number values of different types. The category includes func-tions such as !GetMaximumDecimalPrecision() or !GetMaximumDecimalScale().
+    * Strings: These functions return strings. The category includes functions such as !GetReservedCharactersForName().
+
+A capability interface class – ''FdoICommand'', ''FdoIConnection'', ''FdoIExpression'', ''FdoIFilter'', ''FdoIGeometry'', ''FdoIRaster'', ''FdoISchema'', ''FdoITopology'' – may have any number of functions of those different categories with the Boolean category containing the most functions.
+
+The simplification of the FDO capability interfaces focuses on those categories as it creates interfaces depending on the expected return type. The number of parameters for those functions is at least one which identifies the capability for which the value is requested. Depending on the category, there may be the need for additional parameters – for example, the function returning an array of enumerated values also has to return the number of entries in that array.
+
+The new capability interfaces will be defined in a new class - FdoICapability - that resides in the directory Fdo\Unmanaged\Inc\Fdo\Connections\Capabilities. The following outlines the class definition:
+
+{{{
+
+#include <Fdo/Connections/Capabilities/CapabilityType.h>
+
+class FdoICapability : public FdoIDisposable
+{
+
+  public:
+
+   FDO_API virtual bool      GetBooleanCapability (FdoInt32 capability, bool      default ) = 0;
+   FDO_API virtual FdoInt32  GetInt32Capability   (FdoInt32 capability, FdoInt32  default ) = 0;
+   FDO_API virtual FdoInt64  GetInt64Capability   (FdoInt32 capability, FdoInt64  default ) = 0;
+   FDO_API virtual FdoString *GetStringCapability (FdoInt32 capability, FdoString *default) = 0;
+   FDO_API virtual FdoInt32  *GetArrayCapability  (FdoInt32 capability, FdoInt32  &length ) = 0;
+   FDO_API virtual OBJ       *GetObjectCapability (FdoInt32 capability                    ) = 0;
+
+}  //  FdoICapability
+
+}}}
+
+With the introduction of the class ''FdoICapability'', all other capability classes – ''FdoICommand'', ''FdoIConnection'', ''FdoIExpression'', ''FdoIFilter'', ''FdoIGeometry'', ''FdoIRaster'', ''FdoISchema'', ''FdoITopology'' – become obsolete. This requires a change to the class FdoIConnection that provides access to the capabilities. That class needs a new interface to get the capabilities:
+
+{{{
+
+FDO_API virtual FdoICapability *GetCapability(bool datastoreLevel = false) = 0;
+
+}}}
+
+A corresponding change will also be made in the FDO managed code base:
+
+{{{
+
+...
+BEGIN_NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES
+...
+public __gc __interface ICapability;
+...
+END_NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES
+
+...
+
+NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::ICapability *GetCapability(System::Boolean datastoreLevel);
+
+...
+
+}}}
+
+Although the new class ''FdoICapability'' will make the other FDO capability classes obsolete, there is no plan to depricate those classes at this point and applications may still use their interfaces although it is expected that the new FDO capability interfaces would be used instead.
+
+The class ''FdoICapability'' has generalized interfaces for all return type categories the current set of capability interfaces return. It is feasable to add capability interfaces for all data types that FDO supports in preparation for additional capabilities that may be added at a later stage using those data types. However, the ones currently listed should cover most, if not all of the cases and hence the addition of interfaces for different FDO types is not planned. 
+
+The implementation of the new interfaces also requires some error handling in case an interface is called with a capability identifier that is invalid in this case (for example, call interface !GetObjectCapability and pass in a capability identifier that returns a boolean value). The initial concept called for the throwing of an exception but this may be difficult to handle for any application. Therefore, the proposed solution allows the caller to provide a default value that is returned in case the requested capability is not found within the function. The exception to this rule are the interfaces to return pointers which will return a NULL pointer if the request is invalid. 
+
+The simplification of the capability interfaces also affects code using it. This is especially the case for the new interfaces that return an array of enumerated values or a collection. Because of the generalization, the interfaces have to return a neutral data rather than a specific type as it is the case with the original interfaces. This requires the caller to cast the returned object to the expected type. The following shows an example of the old and new style request for a capability that returns an array of enumerated values.
+
+{{{
+
+Old Style Call
+
+FdoPtr<FdoISchemaCapabilities> schemaCapabilities =
+                                  connection->GetSchemaCapabilities();
+FdoInt32 listCount;
+FdoDataType *supportedDataTyes =
+       schemaCapabilities->GetSupportedAutoGeneratedTypes(listCount);
+
+
+New Style Call
+
+FdoPtr<FdoICapability> capability =
+                                  connection->GetCapability();
+FdoInt32 listCount;
+FdoDataType *supportedDataTyes =
+            (FdoDataType *)capability->GetArrayCapability(
+                                       FdoCapabilityType_DataTypes,
+                                       listCount);
+
+}}}
+
+The change to the unmanaged code requires a corresponding change to the managed code. The class ''ICapability'' will be added at Fdo\Managed\Src\OSGeo\FDO\Connections\Capabilities (file mgICapability.h). The following outlines this new class:
+
+{{{
+
+public __gc __interface ICommandCapabilities : public System::IDisposable
+{
+
+  public:
+
+    System::Boolean GetBooleanCapability (System::Int32 capability, System::Boolean default);
+    System::Int32   GetInt32Capability   (System::Int32 capability, System::In32    default);
+    System::Int64   GetInt64Capability   (System::Int32 capability, System::Int64   default);
+    System::String  *GetStringCapability (System::Int32 capability, System::String  *default);
+    System::Int32[] GetArrayCapability   (System::Int32 capability);
+    System::Object  GetObjectCapability  (System::Int32 capability);
+
+}
+
+}}}
+
+As part of the proposed change to the FDO capability interface set, a new enumeration will be added. This new enumeration - ''!FdoCapabilityType'' - contains a list of all currently supported capabilities including the ones added as a result of this RFC. The following outlines this enumeration:
+
+{{{
+
+
+enum FdoCapabilityType
+{
+  // Command Capabilities
+
+  FdoCapabilityType_CommandList,
+  FdoCapabilityType_SupportsParameters,
+  FdoCapabilityType_SupportsTimeout,
+  FdoCapabilityType_SupportsSelectExpressions,
+  FdoCapabilityType_SupportsSelectFunctions,
+  FdoCapabilityType_SupportsSelectDistinct(),
+  FdoCapabilityType_SupportsSelectOrdering(),
+  FdoCapabilityType_SupportsSelectGrouping(),
+
+  // Connection Capabilities
+
+  FdoCapabilityType_ThreadCapability,
+  FdoCapabilityType_SpatialContextTypes,
+  FdoCapabilityType_LockTypes,
+  FdoCapabilityType_SupportsLocking,
+  FdoCapabilityType_SupportsTimeout,
+  FdoCapabilityType_SupportsTransactions,
+  FdoCapabilityType_SupportsLongTransactions,
+  FdoCapabilityType_SupportsSQL,
+  FdoCapabilityType_SupportsConfiguration,
+  FdoCapabilityType_SupportsMultipleSpatialContexts,
+  FdoCapabilityType_SupportsCSysWKTFromCSysName,
+  FdoCapabilityType_SupportsWrite,
+  FdoCapabilityType_SupportsMultiUserWrite,
+  FdoCapabilityType_SupportsFlush,
+
+  // Expression Capabilities
+
+  FdoCapabilityType_ExpressionTypes,
+
+
+  // Filter Capabilities
+
+  FdoCapabilityType_ConditionTypes,
+  FdoCapabilityType_SpatialOperations,
+  FdoCapabilityType_DistanceOperations,
+  FdoCapabilityType_SupportsGeodesicDistance,
+  FdoCapabilityType_SupportsNonLiteralGeometricOperations,
+
+  // Geometry Capabilities
+
+  FdoCapabilityType_GeometryTypes,
+  FdoCapabilityType_GeometryComponentTypes,
+  FdoCapabilityType_Dimensionalities,
+
+// Raster Capabilities
+
+  FdoCapabilityType_SupportsRaster,
+  FdoCapabilityType_SupportsStitching,
+  FdoCapabilityType_SupportsSubsampling,
+  FdoCapabilityType_SupportsDataModel,
+
+  // Schema Capabilities
+
+  FdoCapabilityType_ClassTypes,
+  FdoCapabilityType_DataTypes,
+  FdoCapabilityType_SupportedAutoGeneratedTypes,
+  FdoCapabilityType_SupportedIdentityPropertyTypes,
+  FdoCapabilityType_MaximumDataValueLength_String,
+  FdoCapabilityType_MaximumDataValueLength_BLOB,
+  FdoCapabilityType_MaximumDataValueLength_CLOB,
+  FdoCapabilityType_MaximumDataValueLength_Decimal,
+  FdoCapabilityType_MaximumDataValueLength_Boolean,
+  FdoCapabilityType_MaximumDataValueLength_Byte,
+  FdoCapabilityType_MaximumDataValueLength_DateTime,
+  FdoCapabilityType_MaximumDataValueLength_Double,
+  FdoCapabilityType_MaximumDataValueLength_Int16,
+  FdoCapabilityType_MaximumDataValueLength_Int32,
+  FdoCapabilityType_MaximumDataValueLength_Int64,
+  FdoCapabilityType_MaximumDataValueLength_Single,
+  FdoCapabilityType_MaximumDecimalPrecision,
+  FdoCapabilityType_MaximumDecimalScale,
+  FdoCapabilityType_NameSizeLimit_Datastore,
+  FdoCapabilityType_NameSizeLimit_Schema,
+  FdoCapabilityType_NameSizeLimit_Class,
+  FdoCapabilityType_NameSizeLimit_Property,
+  FdoCapabilityType_NameSizeLimit_Description,
+  FdoCapabilityType_ReservedCharactersForName,
+  FdoCapabilityType_SupportsAssociationProperties,
+  FdoCapabilityType_SupportsAutoIdGeneration,
+  FdoCapabilityType_SupportsCalculatedProperties,
+  FdoCapabilityType_SupportsCompositeId,
+  FdoCapabilityType_SupportsCompositeUniqueValueConstraints,
+  FdoCapabilityType_SupportsDataStoreScopeUniqueIdGeneration,
+  FdoCapabilityType_SupportsDefaultValue,
+  FdoCapabilityType_SupportsExclusiveValueRangeConstraints,
+  FdoCapabilityType_SupportsInclusiveValueRangeConstraints,
+  FdoCapabilityType_SupportsInheritance,
+  FdoCapabilityType_SupportsMultipleSchemas,
+  FdoCapabilityType_SupportsNetworkModel,
+  FdoCapabilityType_SupportsNullValueConstraints,
+  FdoCapabilityType_SupportsObjectProperties,
+  FdoCapabilityType_SupportsSchemaModification,
+  FdoCapabilityType_SupportsSchemaOverrides,
+  FdoCapabilityType_SupportsUniqueValueConstraints,
+  FdoCapabilityType_SupportsValueConstraintsList,
+  FdoCapabilityType_SupportsWritableIdentityProperties,
+
+  // Topology Capabilities
+
+  FdoCapabilityType_SupportsTopology,
+  FdoCapabilityType_SupportsTopologicalHierarchy,
+  FdoCapabilityType_BreaksCurveCrossingsAutomatically,
+  FdoCapabilityType_ActivatesTopologyByArea,
+  FdoCapabilityType_ConstrainsFeatureMovements,
+
+}  //  enum FdoCapabilityType
+
+}}}
+
+The new enumeration will reside in the directory Fdo\Unmanaged\Inc\Fdo\Connections\Capabilities. A corresponding definition - ''!CapabilityType'' - will be added to the managed code (Fdo\Managed\Src\OSGeo\FDO\Connections\Capabilities):
+
+{{{
+
+public __value enum CapabilityType
+{
+  // Command Capabilities
+
+  CapabilityType_CommandList,
+  CapabilityType_SupportsParameters,
+  CapabilityType_SupportsTimeout,
+  CapabilityType_SupportsSelectExpressions,
+  CapabilityType_SupportsSelectFunctions,
+  CapabilityType_SupportsSelectDistinct(),
+  CapabilityType_SupportsSelectOrdering(),
+  CapabilityType_SupportsSelectGrouping(),
+
+  // Connection Capabilities
+
+  CapabilityType_ThreadCapability,
+  CapabilityType_SpatialContextTypes,
+  CapabilityType_LockTypes,
+  CapabilityType_SupportsLocking,
+  CapabilityType_SupportsTimeout,
+  CapabilityType_SupportsTransactions,
+  CapabilityType_SupportsLongTransactions,
+  CapabilityType_SupportsSQL,
+  CapabilityType_SupportsConfiguration,
+  CapabilityType_SupportsMultipleSpatialContexts,
+  CapabilityType_SupportsCSysWKTFromCSysName,
+  CapabilityType_SupportsWrite,
+  CapabilityType_SupportsMultiUserWrite,
+  CapabilityType_SupportsFlush,
+
+  // Expression Capabilities
+
+  CapabilityType_ExpressionTypes,
+
+
+  // Filter Capabilities
+
+  CapabilityType_ConditionTypes,
+  CapabilityType_SpatialOperations,
+  CapabilityType_DistanceOperations,
+  CapabilityType_SupportsGeodesicDistance,
+  CapabilityType_SupportsNonLiteralGeometricOperations,
+
+  // Geometry Capabilities
+
+  CapabilityType_GeometryTypes,
+  CapabilityType_GeometryComponentTypes,
+  CapabilityType_Dimensionalities,
+
+// Raster Capabilities
+
+  CapabilityType_SupportsRaster,
+  CapabilityType_SupportsStitching,
+  CapabilityType_SupportsSubsampling,
+  CapabilityType_SupportsDataModel,
+
+  // Schema Capabilities
+
+  CapabilityType_ClassTypes,
+  CapabilityType_DataTypes,
+  CapabilityType_SupportedAutoGeneratedTypes,
+  CapabilityType_SupportedIdentityPropertyTypes,
+  CapabilityType_MaximumDataValueLength_String,
+  CapabilityType_MaximumDataValueLength_BLOB,
+  CapabilityType_MaximumDataValueLength_CLOB,
+  CapabilityType_MaximumDataValueLength_Decimal,
+  CapabilityType_MaximumDataValueLength_Boolean,
+  CapabilityType_MaximumDataValueLength_Byte,
+  CapabilityType_MaximumDataValueLength_DateTime,
+  CapabilityType_MaximumDataValueLength_Double,
+  CapabilityType_MaximumDataValueLength_Int16,
+  CapabilityType_MaximumDataValueLength_Int32,
+  CapabilityType_MaximumDataValueLength_Int64,
+  CapabilityType_MaximumDataValueLength_Single,
+  CapabilityType_MaximumDecimalPrecision,
+  CapabilityType_MaximumDecimalScale,
+  CapabilityType_NameSizeLimit_Datastore,
+  CapabilityType_NameSizeLimit_Schema,
+  CapabilityType_NameSizeLimit_Class,
+  CapabilityType_NameSizeLimit_Property,
+  CapabilityType_NameSizeLimit_Description,
+  CapabilityType_ReservedCharactersForName,
+  CapabilityType_SupportsAssociationProperties,
+  CapabilityType_SupportsAutoIdGeneration,
+  CapabilityType_SupportsCalculatedProperties,
+  CapabilityType_SupportsCompositeId,
+  CapabilityType_SupportsCompositeUniqueValueConstraints,
+  CapabilityType_SupportsDataStoreScopeUniqueIdGeneration,
+  CapabilityType_SupportsDefaultValue,
+  CapabilityType_SupportsExclusiveValueRangeConstraints,
+  CapabilityType_SupportsInclusiveValueRangeConstraints,
+  CapabilityType_SupportsInheritance,
+  CapabilityType_SupportsMultipleGeometries,
+  CapabilityType_SupportsMultipleSchemas,
+  CapabilityType_SupportsNetworkModel,
+  CapabilityType_SupportsNullValueConstraints,
+  CapabilityType_SupportsObjectProperties,
+  CapabilityType_SupportsSchemaModification,
+  CapabilityType_SupportsSchemaOverrides,
+  CapabilityType_SupportsUniqueValueConstraints,
+  CapabilityType_SupportsValueConstraintsList,
+  CapabilityType_SupportsWritableIdentityProperties,
+
+  // Topology Capabilities
+
+  CapabilityType_SupportsTopology,
+  CapabilityType_SupportsTopologicalHierarchy,
+  CapabilityType_BreaksCurveCrossingsAutomatically,
+  CapabilityType_ActivatesTopologyByArea,
+  CapabilityType_ConstrainsFeatureMovements,
+
+}  //  CapabilityType
+
+}}}
+
+Like the command enumeration, the capability enumeration can be extended by the providers to add their own capabilities if this is required.
+
+
+=== Data Store Level Capability Support ===
+
+To support both, provider and data store level capabilities, the parameter list of the functions defined for the FdoIConnection interface that provide access to the capabilities will be changed. All functions will get an optional boolean parameter that defines the capability level to be requested. The following shows the proposed changes: 
+
+{{{
+
+FDO_API virtual FdoICommandCapabilities    *GetCommandCapabilities    (bool datastoreLevel = false) = 0;
+FDO_API virtual FdoIConnectionCapabilities *GetConnectionCapabilities (bool datastoreLevel = false) = 0;
+FDO_API virtual FdoIExpressionCapabilities *GetExpressionCapabilities (bool datastoreLevel = false) = 0;
+FDO_API virtual FdoIFilterCapabilities     *GetFilterCapabilities     (bool datastoreLevel = false) = 0;
+FDO_API virtual FdoIGeometryCapabilities   *GetGeometryCapabilities   (bool datastoreLevel = false) = 0;
+FDO_API virtual FdoIRasterCapabilities     *GetRasterCapabilities     (bool datastoreLevel = false) = 0;
+FDO_API virtual FdoISchemaCapabilities     *GetSchemaCapabilities     (bool datastoreLevel = false) = 0;
+FDO_API virtual FdoITopologyCapabilities   *GetTopologyCapabilities   (bool datastoreLevel = false) = 0;
+FDO_API virtual FdoICapability             *GetCapability             (bool datastoreLevel = false) = 0;
+
+}}}
+
+By default the optional parameter is set to FALSE, hence not changing the current behavior. Data store level capabilities are available only after a fully connection to a data store has been established. If requested before, an exception will be issued.
+
+The changes to the unmanaged code requires a corresponding change to the managed code. There, new interfaces will be defined to reflect the parameter change in the unmanaged code. The following outlines the necessary changes:
+
+{{{
+
+NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::ICommandCapabilities    *GetCommandCapabilities    (System::Boolean datastoreLevel);
+NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::IConnectionCapabilities *GetConnectionCapabilities (System::Boolean datastoreLevel);
+NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::IExpressionCapabilities *GetExpressionCapabilities (System::Boolean datastoreLevel);
+NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::IFilterCapabilities     *GetFilterCapabilities     (System::Boolean datastoreLevel);
+NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::IGeometryCapabilities   *GetGeometryCapabilities   (System::Boolean datastoreLevel);
+NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::IRasterCapabilities     *GetRasterCapabilities     (System::Boolean datastoreLevel);
+NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::ISchemaCapabilities     *GetSchemaCapabilities     (System::Boolean datastoreLevel);
+NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::ITopologyCapabilities   *GetTopologyCapabilities   (System::Boolean datastoreLevel);
+NAMESPACE_OSGEO_FDO_CONNECTIONS_CAPABILITIES::ICapability             *GetCapability             (System::Boolean datastoreLevel);
+
+}}}
+
+If data store level capabilities are chosen, then the results will reflect any limitations that the data store has around those capabilities. For example, the command capabilities will return a smaller list of supported commands if the datastore is read-only. In this case, commands such as Update will not be returned. Other capabilities, like the threat related capabilities, will remain unchanged from the provider level values. 
+
+It is anticipated that the most impact of the data store level capabilities will be with the ODBC provider. At the same time, the ODBC provider also represents the biggest unknown as it is not yet known how much data store specific limitations the ODBC provider can determine through the ODBC API.
+
+
+=== Eliminate Provider Specific Processing in Applications ===
+
+As outlined in the motivation section of this RFC, applications like Autodesk Map 3D, !MapGuide and Bulk Copy implement provider specific processing because the required information is currently not available via FDO capabilities. It is one of the objectives of this RFC to change this. The following describes the use cases that have been identified within this context and how they will be addressed.
+
+
+==== Arc Support ====
+
+When checking in objects in Map, any arc segments that may be defined with the object’s geometry property will be tessellated if the target provider cannot store arc segments. In general, this decision is made by determining whether or not the arc geometry type is listed as a supported type in the geometry capabilities.
+
+The exception to this rule is the Oracle provider. By default, Oracle will support the storage of arc segments unless the current coordinate system is a Lat/Long system in which case arc segments need to be tessellated. The provider specific processing in Map can be eliminated if a capability indicating whether or not arc segments can be stored is added. Such a new capability will be added to the set of geometry capabilities. The function signature is outlined next:
+
+'''''bool !SupportsArcSegmentStorage (!FdoString *wktCoordinateSystemName);'''''
+
+
+==== Calculated Property Support ====
+
+Currently, Autodesk Map 3D allows users to define calculated properties even if the underlying provider does not support this feature. If used, Map will issue an exception in such a case. The new capability will indicate whether or not a provider supports calculated properties and hence make the corresponding functionality available only if the provider does. 
+
+The new capability will be addressed with the new capability interface. The capability identifier will be ''!CapabilityType_SupportsCalculatedProperties''.
+
+
+==== Writable Identity Property Support ====
+
+Bulk Copy has a provider dependent implementation to determine whether or not a provider supports writing to identity properties. To eliminate this specific handling a new capability - ''!CapabilityType_SupportsWritableIdentityProperties'' - will be added. The new capability is addressed via the new capability interfaces.
+
+
+==== Multiple Geometry Support ====
+
+There are two parts to this item:
+
+    * A new capability - ''!CapabilityType_SupportsMultipleGeometries'' - will be added with which a provider can indicate whether or not it allows the user to defined multiple geometry types for a geometry property. For example, SHP does not allow to store point and line shapes in the same data store; It can only either one of them.
+    * Another change affects the Schema Editor in Autodesk Map 3D. The Schema Editor currently allows the user to pick geometric types in any combination to be assigned with the class geometry property. The geometric types are point, line and polygone and are not fine-grained enough to reflect the different shapes a provider can support. FDO already contains such a fine-grained definition of shape types - the geometry types. The geometry types include ''!FdoGeometryType_Point'', ''!FdoGeometryType_LineString'', ''!FdoGeometryType_Polygon'', ''!FdoGeometryType_MultiPoint'', ''!FdoGeometryType_MultiLineString'', ''!FdoGeometryType_MultiPolygon'', ''!FdoGeometryType_MultiGeometry'', ''!FdoGeometryType_CurveString'', ''!FdoGeometryType_CurvePolygon'', ''!FdoGeometryType_MultiCurveString'' and ''!FdoGeometryType_MultiCurvePolygon''. The Schema Editor will be modified to offer those types rather than the current geometric types for the user to pick from. In addition the Schema Editor will use the new capability introduced with this use case to control the selection process.
+
+
+=== Optimization ===
+
+One use case was submitted that requested new capabilities to better control the building of a FDO filter. In this specific use case, the filter was build with multile use of the ''!FdoFilter::Combine()'' interface to combine different parts of a filter via the ''OR'' operation. The provided information described that the execution of a select command will fail on some providers if the number of those sub filters excceeds a certain limit. The request was for a new capability that would indicate how many sub-filters can be combined within a provider.
+
+Investigation into this use case, however, showed that there is an issue with the process that transforms a filter to a SQL statement. If a node in the tree is reached that combines two sub-filters then the process does not look at the sub-filters to determine if it is required to nest them but rather goes ahead and nests them anyway. This way, the resulting SQL statement contains a deep nesting of sub filters. The following demonstrates this on a small scale:
+
+{{{
+
+Filter:
+
+  a = 1 or a = 2 or a = 3 or a = 4
+
+Generated SQL statement:
+
+  ((((a = 1) or (a = 2)) or (a = 3)) or (a = 4))
+
+}}}
+
+Because of the highly nested SQL statement, some providers like ODBC and SQL Server may not be able to handle the complexity and issue an exception.
+
+The nesting in general is valid but not always - like in the above example - necessary. This will be addressed as part of this RFC and optimized. The process will be modified to nest sub filters if this is not required. For the above example, this will result in the following SQL statement:
+
+{{{
+
+Filter:
+
+  a = 1 or a = 2 or a = 3 or a = 4
+
+Generated SQL statement:
+
+  (a = 1) or (a = 2) or (a = 3) or (a = 4)
+
+}}}
+
+Once the nesting is eliminated the originally reported issue no longer appears. As a result there is no need for additional capabilities.
+
 
 == Test Plan ==
 
-Existing unit tests will be enhanced to test all changes.
+Existing unit tests will be enhanced and new unit tests added to test all changes.
 
 == Funding/Resources ==
 
 Autodesk to provide resource / funding to implement the feature for the affected providers.
-
-