home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / dtspump.h < prev    next >
C/C++ Source or Header  |  2000-02-01  |  96KB  |  1,850 lines
  1. //
  2. // DTSPump.h
  3. //    Header file for the OLEDB DTSDataPump Service Provider.
  4. //    Copyright 1997 Microsoft Corporation
  5. //
  6. #ifndef DTSDataPump_H_
  7. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  8. #define DTSDataPump_H_
  9.  
  10. #ifndef DTSDataPumpVersion_Major
  11.     #define DTSDataPumpVersion_Major 1
  12.     #define DTSDataPumpVersion_Minor 0
  13. #endif // DTSDataPumpVersion_Major
  14.  
  15. #ifndef DTSDataPump_VersionOnly
  16.  
  17. // The default Blob size used in this version of the DataPump.
  18. // May be overridden on a per-Transform or per-column basis.
  19. #define DTS_DEFAULT_INMEMORY_BLOB_SIZE (1024 * 1024)
  20.  
  21. // Default number of successful InsertRows which will be Committed if supported by provider.
  22. // Currently set to 0 which means not to do a commit until all rows have been transferred.
  23. #define DTS_DEFAULT_InsertCommitSize    0
  24.  
  25. ///////////////////////////////////////////////////////////////////////////////////////
  26. // CPP and OleAut Enumerations and constants.
  27. ///////////////////////////////////////////////////////////////////////////////////////
  28. #ifndef DTSDataPump_CONSTANTS_
  29. #define DTSDataPump_CONSTANTS_
  30.  
  31. // To avoid the need to cast on bitwise operations (which defeats typesafety anyway),
  32. // define the datatype as DWORD for C/CPP.  OleAut languages don't do typechecking
  33. // and organize by the enum name.
  34. #ifdef DTSDataPump_ODL_
  35.     #define DP_ENUM_BEGIN(tdef, hstring)    [helpcontext(H_##tdef), helpstring(hstring)] enum tdef
  36.         // item = value, ...
  37.     #define DP_ENUM_END(tdef)                tdef, *LP##tdef
  38. #else
  39.     #define DP_ENUM_BEGIN(tdef, hstring)    DWORD tdef, *LP##tdef; enum tag##tdef
  40.         // item = value, ...
  41.     #define DP_ENUM_END(tdef)                
  42. #endif
  43.  
  44. typedef DP_ENUM_BEGIN(DTSDataPumpError, "Error ranges for DTSDataPump execution") {
  45.     DTSDataPump_E_NotImplemented                = 0x2000,
  46.     DTSDataPump_E_RowsetsAlreadySet                = 0x2001,
  47.     DTSDataPump_E_TransformsAlreadySet            = 0x2002,
  48.     DTSDataPump_E_DestRowsetNotSupplied            = 0x2003,
  49.     DTSDataPump_E_RowsetsNotSupplied            = 0x2004,
  50.     DTSDataPump_E_SourceColumnsRequired            = 0x2005,
  51.     DTSDataPump_E_ColCountButNoCols                = 0x2006,
  52.     DTSDataPump_E_MismatchColOrdAndName            = 0x2007,
  53.     DTSDataPump_E_ColumnNameNotFound            = 0x2008,
  54.     DTSDataPump_E_ColumnOutOfRange                = 0x2009,
  55.     DTSDataPump_E_DestColumnAlreadySpecified    = 0x200a,
  56.     DTSDataPump_E_IDataConvertRequired            = 0x200b,
  57.     DTSDataPump_E_NullVariantIUnknown            = 0x200c,
  58.     DTSDataPump_E_NotReentrant                    = 0x200d,
  59.     DTSDataPump_E_RowsetChangeMustInsert        = 0x200e,
  60.     DTSDataPump_E_DataPumpNotReentrant            = 0x200f,
  61.     DTSDataPump_E_DestColumnReadOnly            = 0x2010,
  62.     DTSDataPump_E_MustSpecifyDestOrTransform    = 0x2011,
  63.     DTSDataPump_E_BadTransformFlag                = 0x2012,
  64.     DTSDataPump_E_BadTransformStatusReturned    = 0x2013,
  65.     DTSDataPump_E_TransformServerException        = 0x2014,
  66.     DTSDataPump_E_CannotRebindColumn            = 0x2015,
  67.     DTSDataPump_E_InvalidFetchBufferSize        = 0x2016,
  68.     DTSDataPump_E_InvalidDTSBindMode            = 0x2017,
  69.     DTSDataPump_E_SourceBlobBinding                = 0x2018,
  70.     DTSDataPump_E_NonBlobStorageBind            = 0x2019,
  71.     DTSDataPump_E_LookupDupName                    = 0x201a,
  72.  
  73.     DTSDataPump_E_DestinationBlobBinding        = 0x2020,
  74.  
  75.     DTSDataPump_E_Copy_NeedSrcAndDestColumns    = 0x2024,
  76.     DTSDataPump_E_Copy_ValidateSchemaError        = 0x2025,
  77.  
  78.     DTSDataPump_E_Convert_DestNotNull            = 0x2026,
  79.     DTSDataPump_E_Convert_BadBindInfo            = 0x2027,
  80.     DTSDataPump_E_Convert_DestOverflow            = 0x2028,
  81.     DTSDataPump_E_Convert_SourceInvalidVariant    = 0x2029,
  82.     DTSDataPump_E_Convert_SourceInvalidLength    = 0x202a,
  83.     DTSDataPump_E_Convert_ConversionInvalid        = 0x202b,
  84.     DTSDataPump_E_Convert_ConversionFailed        = 0x202c,
  85.     DTSDataPump_E_Convert_ProviderOwnedTypeMismatch    = 0x202d,
  86.     DTSDataPump_E_Convert_BlobStorageNoInterface    = 0x202e,
  87.  
  88.     DTSDataPump_E_AxScript_RequiredParams        = 0x2040,
  89.     DTSDataPump_E_AxScript_ValidateSchemaError    = 0x2041,
  90.     DTSDataPump_E_AxScript_ParseError            = 0x2042,
  91.     DTSDataPump_E_AxScript_BadTransformFunction    = 0x2043,
  92.     DTSDataPump_E_AxScript_CantChangeSrcCols    = 0x2044,
  93.     DTSDataPump_E_AxScript_CantResetAfterInitialize    = 0x2045,
  94.     DTSDataPump_E_AxScript_CantInitializeEngine    = 0x2046,
  95.     DTSDataPump_E_AxScript_RunTimeError            = 0x2047,
  96.  
  97.     DTSDataPump_E_AutoBufferInterfaceNotSupported    = 0x2051,
  98.     DTSDataPump_E_InvalidSpecifyBlobDefaults    = 0x2051,
  99.     DTSDataPump_E_LineageVariableNotFound        = 0x2052,
  100.     DTSDataPump_E_LastRowCantBeLessThanFirst    = 0x2053,
  101.  
  102.     DTSDataPump_E_DDQ_NeedTransformStatus        = 0x2060,
  103.     DTSDataPump_E_DDQ_NeedInsertQuery            = 0x2061,
  104.     DTSDataPump_E_DDQ_NeedUpdateQuery            = 0x2062,
  105.     DTSDataPump_E_DDQ_NeedDeleteQuery            = 0x2063,
  106.     DTSDataPump_E_DDQ_NeedUserQuery                = 0x2064,
  107.     DTSDataPump_E_DDQ_InformationNotSet            = 0x2065,
  108.     DTSDataPump_E_DDQ_BadTransformStatusContext    = 0x2065,
  109.     DTSDataPump_E_DDQ_DestColumnNotTransformed    = 0x2066,
  110.     DTSDataPump_E_DDQ_DestColumnNeedsLength        = 0x2067,
  111.     DTSDataPump_E_DDQ_DestDoesNotSupportSQL        = 0x2068,
  112.  
  113. } DP_ENUM_END(DTSDataPumpError);
  114.  
  115. // These allow definition of how the transform will proceed.
  116. typedef DP_ENUM_BEGIN(DTSTransformFlags, "Flags (int or long) controlling Transform") {
  117.     // No flags are specified; essentially, the conversion must be between exact types.
  118.     // Note that this allows string <--> nonstring conversions, because every nonstring datatype
  119.     // has a meaningful string representation.  This may be overridden by RequireExactType,
  120.     // which is even stricter.
  121.     DTSTransformFlag_Strict                        = 0x00000000,
  122.  
  123.     // This flag means that IDTSDataPumpTransform::ValidateSchema should allow the transfer to proceed 
  124.     // even if there are potential overflows, under the assumption that the consumer is aware of this but
  125.     // knows the source values are all (or mostly) within the destination columnÆs range.  Any overflows during
  126.     // transformation will cause the row to be exceptioned.  This flag is generally of interest only to 
  127.     // the IID_IDTSDataPumpTransformCopy implementation, as this is a direct copy, whereas other
  128.     // implementations would probably convert the values or determine validity on a specific case-by-case basis.
  129.     // This value is also used for date/time conversions which result in loss, such as DATE -> DBTIME,
  130.     // where a subset of the source value is still meaningful.
  131.     DTSTransformFlag_AllowDemotion                 = 0x00000001,
  132.  
  133.     // This flag means that IDTSDataPumpTransform::ValidateSchema should allow the transfer to proceed 
  134.     // when there is promotion in the data range when moving from the source to the destination types,
  135.     // such as I2->I4 or I4->float/double.  Note that in some cases, such as I4->R4, the data range
  136.     // increases but at the loss of some digits of precision.
  137.     // If AllowLossless is specified, this is allowed by the Transform.
  138.     DTSTransformFlag_AllowPromotion             = 0x00000002,
  139.  
  140.     // This flag allows column (w)char or byte data to be truncated silently, such as when moving data
  141.     // from a char(60) to a char(40) column.  AllowDemotion is implied but overflow will be
  142.     // silently truncated instead of causing an error.
  143.     DTSTransformFlag_AllowStringTruncation         = 0x00000004,
  144.  
  145.     // This flag means that IDTSDataPumpTransform::ValidateSchema should allow the transfer to proceed 
  146.     // even in the event that the source is a floating-point or numeric/decimal type and the destination
  147.     // is an integral type.  This is a numeric flavour of AllowDemotion and will not cause an error 
  148.     // (integer overflow will still be an error; i.e. left-of-decimal digits are significant).
  149.     DTSTransformFlag_AllowNumericTruncation        = 0x00000008,
  150.  
  151.     // This flag means that IDTSDataPumpTransform::ValidateSchema should allow the transfer to proceed 
  152.     // even if the source column allows NULL values and the destination column does not.  As with
  153.     // AllowDemotion, errors may be encountered during a transform.
  154.     // If AllowLossless is specified, this is allowed by the Transform if going from nonNULLable to NULLable.
  155.     DTSTransformFlag_AllowNullChange            = 0x00000010,
  156.  
  157.     // This flag means that IDTSDataPumpTransform::ValidateSchema should allow the transfer to proceed 
  158.     // even in the event that the source and destination have a signed vs. unsigned mismatch.  As with
  159.     // AllowDemotion, errors may be encountered during a transform.
  160.     // If AllowLossless is specified, this is allowed by the Transform when going from unsigned to signed
  161.     // with promotion (e.g. UI2 -> I4).
  162.     DTSTransformFlag_AllowSignChange            = 0x00000020,
  163.  
  164.     // Require that the destination column's datatype be exactly the same as the source column's
  165.     // (including length or precision/scale, fixed vs. variable length, sign, and nullability).
  166.     // This overrides any other flags specified for column conversion validation.
  167.     // Cannot be specified with ForceConvert.
  168.     DTSTransformFlag_RequireExactType            = 0x00000040,
  169.  
  170.     // Allow the conversion to proceed at all times, even when the source and destination types are
  171.     // fundamentally different.  Currently this applies to:
  172.     //        <nonchar> <--> bytes:        Does a bitwise copy; caveats apply for endian, machine representations.
  173.     //        int/real <--> date:            DATE is a double so this just converts between int and double.
  174.     //        real <--> date:                DATE is a double so this just copies.
  175.     // Cannot be specified with RequireExactType.
  176.     DTSTransformFlag_ForceConvert                = 0x00000080,
  177.  
  178.     // Causes the TransformServer to not ClearBindingData() the destination-row storage
  179.     // for the columns in this Transform during OnRowComplete().  This allows the
  180.     // destination row's values to be reused by the next transform.
  181.     DTSTransformFlag_PreserveDestRows            = 0x00000100,
  182.  
  183.     // Causes the TransformServer to allow all conversions for which a lossless conversion is
  184.     // possible - e.g. Promotion, nonNULLable -> NULLable, unsigned -> promoted signed.
  185.     DTSTransformFlag_AllowLosslessConversion    = 0x00000200,
  186.  
  187.     // No flags are specified; essentially, the conversion must be between exact types.
  188.     // Note that this allows string <--> nonstring conversions, because every nonstring datatype
  189.     // has a meaningful string representation.  This may be overridden by RequireExactType.
  190.     DTSTransformFlag_Default                    = (DTSTransformFlag_AllowDemotion | DTSTransformFlag_AllowPromotion | DTSTransformFlag_AllowStringTruncation | DTSTransformFlag_AllowNumericTruncation | DTSTransformFlag_AllowNullChange | DTSTransformFlag_AllowSignChange)
  191.  
  192. } DP_ENUM_END(DTSTransformFlags);
  193.  
  194. // Status returned from a Transform operation.
  195. // All "normal" errors from DTSDataPumpTransform::Execute should be returned as
  196. // one of these flags, with a SUCCEEDED HRESULT (possibly with the addition of
  197. // OLEDB Error Records via the IDTSErrorRecords interface passed to 
  198. // IDTSDataPumpTransform::AddVariable).  A FAILED HRESULT returned from
  199. // DTSDataPumpTransform::Execute indicates an unrecoverable error and aborts
  200. // the DataPump.
  201. typedef DP_ENUM_BEGIN(DTSTransformStatus, "Return value (int or long) from ActiveX Scripting Transform") {
  202.     // Default; conversions (if any) succeeded; write the row to destination if
  203.     // specified, without calling any error handlers.  Default is to do Insert;
  204.     // this may be overridden for data-driven queries by other flags to do Insert,
  205.     // Update, Delete, or UserQuery for a user-defined ad-hoc query.
  206.     DTSTransformStat_OK                            = 0x00000001,
  207.  
  208.     // Success with additional info, which the app may want to process further
  209.     // by reading its pvTransformUserData (if it shares that knowledge with the
  210.     // transform server) or thru OLEDB Error Records; therefore, the Pump will 
  211.     // call the ErrorSink if one was specified, but does not increment the error
  212.     // row count.  The DTSTransformStatus result of the operation is passed to
  213.     // the ErrorSink, so the app can switch on this bit.
  214.     DTSTransformStat_Info                        = 0x00001000,
  215.  
  216.     // Write row if destination specified; also call ErrorSink with Info.
  217.     DTSTransformStat_OKInfo                        = 0x00001001,
  218.  
  219.     // Abort further processing of this row, for non-error reasons.
  220.     DTSTransformStat_SkipRow                    = 0x00000002,
  221.  
  222.     // Abort further processing of this row, and calls ErrorSink with Info.
  223.     DTSTransformStat_SkipRowInfo                = 0x00001002,
  224.  
  225.     // Do not fetch the next row; re-execute all transforms against the current
  226.     // source and destination rows.  No initialization is done to the destination
  227.     // row, so this could be used to generate multiple output rows from a single
  228.     // input row.  Subsequent transforms are still executed unless a SkipRow* flag
  229.     // is also present.
  230.     DTSTransformStat_SkipFetch                    = 0x00000004,
  231.  
  232.     // Do not write the current row to destination.  Usually used to fetch the next
  233.     // source row to generate a simple aggregate.  Subsequent transforms are still
  234.     // executed unless a SkipRow* flag is also present.  DTSTransformStat_SkipInsert
  235.     // forces DTSTransformFlag_PreserveDestRows behaviour for the row for which it
  236.     // is specified.
  237.     DTSTransformStat_SkipInsert                    = 0x00000008,
  238.  
  239.     // The following 4 flags are not compatible together.  They execute the
  240.     // similarly-named statement passed to SetRowsetAndQueries on the Destination,
  241.     // with values from the currently transformed Destination Row.
  242.     DTSTransformStat_InsertQuery                = 0x00000010,
  243.     DTSTransformStat_UpdateQuery                = 0x00000020,
  244.     DTSTransformStat_DeleteQuery                = 0x00000040,
  245.     DTSTransformStat_UserQuery                    = 0x00000080,
  246.  
  247.     // May be bit-OR'd into the following error returns.
  248.     DTSTransformStat_Error                        = 0x00002000,
  249.  
  250.     // Abort further processing of this row due to error and call the error sink,
  251.     // but do not write to exception file.  Should be handled by the ErrorSink.
  252.     DTSTransformStat_ErrorSkipRow                = 0x00002002,
  253.  
  254.     // Abort further processing of this row as an exception and call the error sink,
  255.     // and write this row to exception file.  Should be handled by the ErrorSink.
  256.     // Note this bit does not map to any non-error bits.
  257.     DTSTransformStat_ExceptionRow                = 0x00002100,
  258.  
  259.     // OrÆd with prior bits to abort processing any further rows and return
  260.     // DTSTransformExec_AbortPump from IDTSDataPump::Execute().  
  261.     // This does not include the Error bit so &'ing with it will only return
  262.     // TRUE for this bit.
  263.     DTSTransformStat_AbortPump                    = 0x00004000,
  264.  
  265.     // Transform determined that this row is the last one to be operated on,
  266.     // so allows the pump to be aborted "normally" (without signifying an error).
  267.     // May be or'd with other bits to skip the current row; otherwise it will go
  268.     // to the next transforms and then write it to destination (in accordance with
  269.     // how the following transforms specify).
  270.     DTSTransformStat_NoMoreRows                    = 0x00008000,
  271.  
  272. } DP_ENUM_END(DTSTransformStatus);
  273.  
  274. // Status returned from an IDataPump::Execute operation.
  275. typedef DP_ENUM_BEGIN(DTSExecuteStatus, "Return value (int or long) from DataPump Execution") {
  276.     // All rows copied (or skipped) without error.
  277.     DTSTransformExec_OK                            = 0x00000000,
  278.  
  279.     // Bit-ORÆd into the following error returns.
  280.     DTSTransformExec_Error                        = 0x00001000,    // Bit-orÆd into following
  281.  
  282.     // Pump continued to completion but errors were encountered
  283.     DTSTransformExec_OKErrors                    = 0x00001001,
  284.  
  285.     // Pump aborted because too many rows had errors.
  286.     DTSTransformExec_ErrorCountExceeded            = 0x00001002,
  287.  
  288.     // Pump aborted due to Transform request or ErrorSink return.
  289.     DTSTransformExec_AbortPump                    = 0x00001004,
  290. } DP_ENUM_END(DTSExecuteStatus);
  291.  
  292. #endif    // DTSDataPump_CONSTANTS_
  293.  
  294. ////////////////////////////////////////////
  295. // CPP-only definitions
  296. ////////////////////////////////////////////
  297.  
  298. #ifndef DTSDataPump_ODL_
  299.  
  300. // Define parameter usage.
  301. #define DP_IN
  302. #define DP_OUT
  303. #define DP_INOUT
  304.  
  305. #ifdef NONAMELESSUNION
  306. #define DP_UNION_NAME(u)    u
  307. #else
  308. #define DP_UNION_NAME(u)
  309. #endif
  310.  
  311. // For safety, struct initialization values are set in ctors for C++ clients.
  312. #if !defined(__cplusplus) && !defined(DP_NO_AUTOCTOR)
  313. #define DP_NO_AUTOCTOR
  314. #endif
  315.  
  316. // These are the conversion flags indicating what may happen during an individual column
  317. // Convert() call, and accounts for the column lengths, nullability, sign, etc.
  318. // See DTSTransformFlags for a more detailed discussion of the similarly-named TransformFlag
  319. // which will allow conversion to proceed when these conditions are present.
  320. //    Keys:
  321. //        <T> - TransformFlag is available to explicitly allow this.
  322. //        <E>    - Error may be encountered during Convert()
  323. //        <F> - Fatal; Convert() will error as unsupported or with overflow.
  324. //
  325. typedef DP_ENUM_BEGIN(DTSConvertFlags, "DTSConvertFlags") {
  326.     // The conversion is between columns of identical type, length or precision/scale,
  327.     // and nullability, or is between text and another type, with the text being of
  328.     // sufficient length for a representation of that datatype.  Errors should not be
  329.     // encountered during Convert() unless a text conversion contains invalid data.
  330.     DTSConvertFlag_ExactType                    = 0x00000000,
  331.  
  332.     // The conversion will promote the range of data from source to destination
  333.     // (e.g. I4 -> I2, [var]char -> longer [var]char, numeric(x, y) -> numeric(x+1, y+1)).
  334.     // <T>
  335.     DTSConvertFlag_Promotion                    = 0x00000001,
  336.     
  337.     // Conversion will demote (e.g. I4 -> I2); overflow error possible.
  338.     // <T, E> 
  339.     DTSConvertFlag_Demotion                        = 0x00000002,
  340.     
  341.     // Conversion may do string or byte truncation; truncation error possible if
  342.     // this flag is not specified on Convert().
  343.     // <T, E>
  344.     DTSConvertFlag_StringTruncation                = 0x00000004,
  345.     
  346.     // Conversion may do integral rounding from float or numeric, or move a larger
  347.     // scale into a smaller scale (both cases resulting in truncation of digits to
  348.     // the right of the decimal point).  This is also flagged when moving from integral
  349.     // or numeric to float/double when source precision is greater than FLT/DBL_DIG.
  350.     // <T> 
  351.     DTSConvertFlag_NumericTruncation            = 0x00000008,
  352.     
  353.     // Conversion may try to put NULL source data into a NonNULL destination column,
  354.     // which will error, or vice-versa, which will be safe.
  355.     // <T, E>
  356.     DTSConvertFlag_NullChange                    = 0x00000010,
  357.     
  358.     // Conversion may try to put a signed value int/float into an unsigned destination, 
  359.     // or vice-versa.  This may error if the source value is negative and destination
  360.     // is unsigned, or if the source is unsigned and its value is larger than the
  361.     // signed destination's maximum signed value (overflow).
  362.     // <T, E>
  363.     DTSConvertFlag_SignChange                    = 0x00000020,
  364.     
  365.     // Destination column size is too short for a meaningful conversion from source
  366.     // column type.
  367.     // <F>
  368.     DTSConvertFlag_DestTooShort                    = 0x00000040,
  369.     
  370.     // Source column size is too short for a meaningful conversion to destination
  371.     // column type.
  372.     // <F>
  373.     DTSConvertFlag_SourceTooShort                = 0x00000080,
  374.     
  375.     // Source and destination datatypes are not really compatible, but conversion can be forced.
  376.     // <T>
  377.     DTSConvertFlag_ForceConvert                    = 0x00000100,
  378.     
  379.     // Conversion fails because of bad or incompatible column types.
  380.     // <F>
  381.     DTSConvertFlag_Unsupported                    = 0x00001000,
  382.  
  383. } DP_ENUM_END(DTSConvertFlags);
  384.  
  385. // Binding modes for column data; returned from IDTSDataPumpTransform::ValidateSchema
  386. // via DTSTransformColumnInfo.  Normally the DataPump default handling does not need to
  387. // be changed, but for Blob ((DBCOLUMNFLAGS_ISLONG) columns, custom Transforms are able
  388. // to adjust bindings to maximize performance.
  389. //
  390. typedef DP_ENUM_BEGIN(DTSBindMode, "DTSBindMode") {
  391.     // Indicates data should be bound "in-memory, out of line".  Currently this is only supported
  392.     // by the OLEDB specification for variable-length types: DBTYPE_((W)STR|BYTES); therefore,
  393.     // the DataPump will error if it is specified for other types.  DTSBindMode_(Client|Provider)Owned
  394.     // must be specified with DTSBindMode_Byref.
  395.     // 
  396.     // For source, the returned data will be a direct pointer to the provider's data if
  397.     // DTSBindMode_ProviderOwned is specified (in which case it must not be free'd or written to),
  398.     // or a CoTaskMemAlloc()'d pointer if DTSBindMode_ClientOwned is specified (in which case it
  399.     // is the client's property and must be freed).
  400.     //
  401.     // For destination, the transformation server must place the data pointer in
  402.     // pDestColumnInfo->pvRowData.  If DTSBindMode_ClientOwned is specified, then the data
  403.     // is assumed to require freeing after the InsertRow operation completes.  The DataPump
  404.     // will never perform a non-Byref, in-memory destination binding for a Blob, so this flag
  405.     // must be specified unless a Storage Object is used.
  406.     //
  407.     DTSBindMode_Byref                            = 0x00000001,
  408.  
  409.     // Default "in-memory, inline" binding mode; space for the source and destination data, including
  410.     // the full length of a DBTYPE_((W)STR|BYTES) column, is allocated in rgColumnData[ii].pvData and
  411.     // passed to IDTSDataPumpTransform::Execute.
  412.     //
  413.     // For a BLOB (DBCOLUMNFLAGS_ISLONG) column, IDTSDataPumpTransform::ValidateSchema returns
  414.     // the length to use for this binding in ppDTSColBinding[ii].cbInMemoryBlobSize.  This will
  415.     // result in a separate allocation for that Blob column (i.e. multiple Blobs are not
  416.     // allocated within a single contiguous row).
  417.     //
  418.     // On fetch from Source, the DBSTATUS in the binding will indicate whether the data was
  419.     // truncated; it is up to the Transform server how (or if) this is handled.
  420.     //
  421.     // For performance reasons, this flag should not be specified for non-Blob (W)STR|BYTES
  422.     // source columns; DTSBindMode_Byref_ProviderOwned is the default, to use a pointer to the
  423.     // provider's data cache and avoid an unnecessary copy.
  424.     //
  425.     // For DBTYPE_BSTR and DBTYPE_VARIANT, this specifies that the binding is DBMEMOWNER_CLIENTOWNED
  426.     // (without BYREF), and the client is responsible for freeing it (e.g. IDTSDataConvert::ClearBindingData).
  427.     //
  428.     DTSBindMode_ClientOwned                        = 0x00000002,
  429.  
  430.     // For Source DBTYPE_((W)STR|BYTES), this flag causes the OLEDB binding to be done as DBTYPE_BYREF
  431.     // with DBMEMOWNER_CLIENTOWNED, resulting in a CoTaskMemAlloc which the client is
  432.     // responsible for freeing (e.g. via IDTSDataConvert::ClearBindingData).  For a BLOB
  433.     // column, the length to use for this binding is returned from ValidateSchema() in 
  434.     // ppDTSColBinding[ii].cbInMemoryBlobSize.  On fetch from Source, the DBSTATUS in the binding
  435.     // will indicate whether the data was truncated; it is up to the Transform server how (or if)
  436.     // this is handled.
  437.     //
  438.     // This flag causes each row to have a separate CoTaskMemAlloc for the source column.  This is
  439.     // somewhat less efficient than the other in-memory options, and thus should only be used by
  440.     // a Transform which wants to assume ownership of that allocation.  The Transform is responsible
  441.     // for tracking and freeing the allocation (and for ensuring that OnRowComplete does not free
  442.     // it if it is to be used in subsequent Transforms).
  443.     //
  444.     // For destination columns, this is the "safest" way to pass an in-memory pointer, as some providers
  445.     // may not allow ProviderOwned on a destination (such as with Blob columns).  The Transform must
  446.     // ensure that it does not double-free a pointer.
  447.     //
  448.     DTSBindMode_Byref_ClientOwned                = 0x00000003,
  449.  
  450.     // By itself, ProviderOwned is seldom used by itself except for BSTR, which does not always
  451.     // support Byref.  It is primarily for DBTYPE_((W)STR|BYTES) with Byref, to reduce allocations
  452.     // and/or copies, as described below.  It may not be supported by providers for other datatypes.
  453.     //
  454.     DTSBindMode_ProviderOwned                    = 0x00000004,
  455.  
  456.     // This flag causes source columns to be bound to return a pointer into the provider's memory
  457.     // space for DBTYPE_((W)STR|BYTES).  This pointer is read-only and must not be freed.
  458.     //
  459.     // For Blob columns, the Source Provider may not support (Byref_)ProviderOwned Blobs; this
  460.     // would require that the entire Blob be buffered contiguously.  Therefore, unless you have
  461.     // specific knowledge of the provider, this flag is discouraged.
  462.     //
  463.     // For DBTYPE_BSTR, the BYREF specification may not be supported, and may require DBMEMOWNER_PROVIDEROWNED
  464.     // (without BYREF).  The client must not free the data.
  465.     //
  466.     // For other types, including DBTYPE_VARIANT, OLEDB raises an error for this specification
  467.     // when creating an accessor.
  468.     //
  469.     // For the destination, specifying ProviderOwned requires that the data be shallow-copied into
  470.     // the destination binding to avoid memory leaks (this is automatically done by IDTSDataConvert::
  471.     // ConvertToBinding).
  472.     //
  473.     DTSBindMode_Byref_ProviderOwned                = 0x00000005,
  474.  
  475.     // This indicates whether the Pump should buffer Source Blob Storage Objects.  For most cases,
  476.     // this should be left _BufferDefault; for performance reasons, the DataPump will only buffer
  477.     // where it is necessary to avoid data loss.  This is in the following cases:
  478.     //    DTSBindMode_Blob_BufferAlways
  479.     //    DTSBindMode_Blob_BufferDefault, provider doesn't allow multiple SO's, and any of following:
  480.     //        The column is referenced in a subsequent transform.
  481.     //        The column is not the rightmost column of all transforms up to and including it.
  482.     //
  483.     // The DataPump can buffer from a source provider's ISequentialStream or ILockBytes, and
  484.     // exposes both these interfaces on its own object.  Because it is a buffer, the object's data
  485.     // can be edited via Write(At) to reduce memory requirements in the TransformServer (allowing the
  486.     // source object to be placed in the destination row, if the destination supports Storage Objects).
  487.     //
  488.     // DTSBindMode_Blob_* is ignored for in-memory binding, which is an implicit buffering.
  489.     DTSBindMode_Blob_BufferDefault                = 0x00000010,
  490.     DTSBindMode_Blob_BufferAlways                = 0x00000020,
  491.     DTSBindMode_Blob_BufferNever                = 0x00000040,
  492.  
  493.     // This indicates whether to use a Structured Storage object for binding a BLOB column.  The Transform
  494.     // Server should indicate which interface it wants in DTSBindInfo::fStorageObject, on return from
  495.     // ValidateSchema().  The DataPump supports the following behaviour:
  496.     //    Custom Transformations:
  497.     //       For Source, if the DataPump does not buffer, only the provider-supported Storage Object interfaces
  498.     //            are available.  Generally this will always include ISequentialStream.  See comments regarding
  499.     //            DTSBindMode_Blob_Buffer*; if the DataPump buffers the Blob data, it supports only ISequentialStream
  500.     //            and ILockBytes.
  501.     //          If the source does not support storage objects, then the Transform Server must not request a
  502.     //            Storage Object, and must bind the source data as in-memory, specifying DTSBindInfo::cbInMemoryBlobSize.
  503.     //       For Destination, the Transform Server supplies the Storage object placed into the row, and must
  504.     //            specify one interface from fProviderStorageObjects for the DataPump to bind the destination.
  505.     //          If the destination does not support storage objects, then the TransformServer must not request
  506.     //            a Storage Object, and must bind the destination data as in-memory, ClientOwned or ProviderOwned,
  507.     //            specifying DTSBindInfo::cbInMemoryBlobSize.
  508.     //    Default (DataPump-supplied) TransformCopy:
  509.     //       If either Source or Destination do not support ISequentialStream, then the DataPump will bind both
  510.     //          as ClientOwned in-memory, using the source column's DTSBindInfo::cbInMemoryBlobSize.
  511.     //            Otherwise, the DataPump will bind to the providers as ISequentialStream, with default buffering.
  512.     //            See also comments regarding DTSBindMode_Blob_Buffer*; this can be specified to override the
  513.     //            Pump's default handling even in the TransformCopy case.
  514.     //
  515.     // DTSBindMode_Blob_StorageObject cannot be specified with non-DTSBindMode_Blob_* flags.
  516.     DTSBindMode_Blob_StorageObject                = 0x00000100,
  517. } DP_ENUM_END(DTSBindMode);
  518.  
  519. // Indicates which of the DataPump defaults are to be overridden on a single AddTransform().
  520. typedef DP_ENUM_BEGIN(DTSSpecifyBlobDefaults, "Specify overrides of DataPump Blob-handling defaults") {
  521.     DTSBlobDefault_DataPumpDefaults        = 0x0000,    // None (initialization)
  522.     DTSBlobDefault_BufferSource            = 0x0001,    // Override DTSBindMode_Blob_BufferDefault for source Blob Storage Objects
  523.     DTSBlobDefault_InMemorySize            = 0x0002,    // Override DTS_DEFAULT_INMEMORY_BLOB_SIZE.
  524.     DTSBlobDefault_ForceInMemory         = 0x0004,    // Force Blobs to be InMemory (no Storage Objects) for this Transform.
  525.                                                     // Forces DTSTransformColumnInfo.fProviderStorageObjects
  526.                                                     // sent to the Transformer to be 0.
  527.     DTSBlobDefault_ForceMultipleStorageObjects    = 0x0008,    // Forces DTSTransformColumnInfo.dtsProviderFlags sent to the
  528.                                                     // Transformer to include DTSProviderFlag_Blob_MultipleStorageObjects.
  529.                                                     // This could be an optimization if the Source provider supports multiple
  530.                                                     // storage objects and the destination is known to support them only
  531.                                                     // multiple blobs for insert, since the OLEDB spec does not distinguish
  532.                                                     // between multiple-StorageObject support for GetData vs. SetData/Insert.
  533. } DP_ENUM_END(DTSSpecifyBlobDefaults);
  534.  
  535. // Flags indicating known Provider Blob capabilities; their absence indicates
  536. // corresponding Provider restrictions or requirements.
  537. typedef DP_ENUM_BEGIN(DTSProviderFlags, "Provider behaviour characteristics") {
  538.     DTSProviderFlag_None                    = 0x00000000,    // None
  539.  
  540.     DTSProviderFlag_ProviderOwned            = 0x00000001,    // Provider supports Byref binding (some may not).
  541.  
  542.     DTSProviderFlag_Blob_InsertNoLength        = 0x00000100,    // Blob Inserts do not require length to be prespecified
  543.     DTSProviderFlag_Blob_Revisitable        = 0x00000200,    // Provider guarantees that Blob data is not skipped when succeeding columns fetched
  544.     DTSProviderFlag_Blob_Rewindable            = 0x00000400,    // Provider guarantees Blob data supports random access
  545.     DTSProviderFlag_Blob_ProviderOwned        = 0x00000800,    // Provider allows the PROVIDEROWNED flag for use with Blobs
  546.     DTSProviderFlag_Blob_MultipleStorageObjects = 0x00001000,        // Provider supports multiple storage objects per row.
  547.     DTSProviderFlag_Blob_NonBlockingStorageObjects = 0x00002000,    // Provider supports multiple nonblocking storage objects per row.
  548. } DP_ENUM_END(DTSProviderFlags);
  549.  
  550. // The actual structure passed to AddTransform to specify overriding Blob defaults.
  551. // This is most useful for the default TransformCopy case, but can also be used by
  552. // a client who predetermines (e.g. via a query) the maximum Blob size in the coming
  553. // result set, for the most efficient memory allocations.
  554. #ifndef DP_NO_AUTOCTOR
  555.     struct DTSTransformBlobDefaults {
  556. #else   // DP_NO_AUTOCTOR
  557.     typedef struct {
  558. #endif  // DP_NO_AUTOCTOR
  559.         DTSSpecifyBlobDefaults dtsSpecifyMask;        // Which of the following items to override.
  560.         BOOL bBufferSource;                            // If dtsSpecifyMask & DTSBlobDefault_BufferSource;
  561.                                                     // TRUE or FALSE forces Pump to buffer source Blobs or not.
  562.         ULONG cbInMemorySize;                        // If dtsSpecifyMask & DTSBlobDefault_InMemorySize;
  563.                                                     // overrides DTS_DEFAULT_INMEMORY_BLOB_SIZE.  Size in bytes.
  564. #ifndef DP_NO_AUTOCTOR
  565.         DTSTransformBlobDefaults()
  566.                 : dtsSpecifyMask(DTSBlobDefault_DataPumpDefaults)
  567.             {    }
  568.     };
  569. #else   // DP_NO_AUTOCTOR
  570.     } DTSTransformBlobDefaults;
  571. #endif  // DP_NO_AUTOCTOR
  572. typedef DTSTransformBlobDefaults *LPDTSTransformBlobDefaults;
  573. typedef const DTSTransformBlobDefaults *LPCDTSTransformBlobDefaults;
  574.  
  575. // Specifies an individual column passed to AddTransform.  The column may be specified by
  576. // name, or if the name is NULL, by an ordinal (this makes unnamed columns easier for the
  577. // consumer to specify).
  578. typedef struct {
  579.     LPOLESTR pwzColumnName;                        // Name of column
  580.     ULONG ulColumnOrdinal;                        // Ordinal of column if name is NULL; 1-based for OLEDB consistency.
  581. } DTSTransformColumnSpecification, *LPDTSTransformColumnSpecification;
  582. typedef const DTSTransformColumnSpecification *LPCDTSTransformColumnSpecification;
  583.  
  584. // Specifies a list of columns passed to AddTransform.
  585. #ifndef DP_NO_AUTOCTOR
  586.     struct DTSTransformColumnsSpecification {
  587. #else   // DP_NO_AUTOCTOR
  588.     typedef struct {
  589. #endif  // DP_NO_AUTOCTOR
  590.  
  591.         ULONG cSourceColumns;                        // Specify source columns
  592.         LPCDTSTransformColumnSpecification pSourceColumns;
  593.         ULONG cDestinationColumns;                    // Specify destination columns
  594.         LPCDTSTransformColumnSpecification pDestinationColumns;
  595.         DTSTransformBlobDefaults BlobDefaults;        // Blob default overrides if specified
  596.  
  597. #ifndef DP_NO_AUTOCTOR
  598.         DTSTransformColumnsSpecification() 
  599.                 : cSourceColumns(0)
  600.                 , pSourceColumns(NULL)
  601.                 , cDestinationColumns(0)
  602.                 , pDestinationColumns(NULL)
  603.             {    }
  604.     };
  605. #else   // DP_NO_AUTOCTOR
  606.     } DTSTransformColumnsSpecification;
  607. #endif   // DP_NO_AUTOCTOR
  608. typedef DTSTransformColumnsSpecification *LPDTSTransformColumnsSpecification;
  609. typedef const DTSTransformColumnsSpecification *LPCDTSTransformColumnsSpecification;
  610.  
  611. // Specifies a query and list of columns for IDTSDataDrivenQuery.
  612. #ifndef DP_NO_AUTOCTOR
  613.     struct DTSTransformQuerySpecification {
  614. #else   // DP_NO_AUTOCTOR
  615.     typedef struct {
  616. #endif  // DP_NO_AUTOCTOR
  617.  
  618.         LPCOLESTR wzQuery;                                // The Parameterized Query
  619.         ULONG cColumns;                                    // Specify count of columns
  620.         LPCDTSTransformColumnSpecification pColumns;    // Specify column mapping to parameters, in order found in query.
  621.  
  622. #ifndef DP_NO_AUTOCTOR
  623.         DTSTransformQuerySpecification() 
  624.                 : wzQuery(NULL)
  625.                 , cColumns(0)
  626.                 , pColumns(NULL)
  627.             {    }
  628.     };
  629. #else   // DP_NO_AUTOCTOR
  630.     } DTSTransformQuerySpecification;
  631. #endif   // DP_NO_AUTOCTOR
  632. typedef DTSTransformQuerySpecification *LPDTSTransformQuerySpecification;
  633. typedef const DTSTransformQuerySpecification *LPCDTSTransformQuerySpecification;
  634.  
  635. // Transform-server specifiable binding information.  An array of these structures is passed to
  636. // ValidateSchema() with default values (possibly derived from DTSTransformBlobDefaults overrides),
  637. // and the Transform Server can set the values.  Because source columns can appear multiple times
  638. // in the same or different transactions, the last specification wins; therefore, a TransformServer's
  639. // Execute() method should gracefully handle a source binding different from what it specified in
  640. // ValidateSchema().
  641. typedef struct {
  642.     DTSBindMode eBindMode;                        // Per above.  For Blobs, specifying a Buffering mode overrides
  643.                                                 // the DataPump and any DTSTransformBlobDefaults default.
  644.     DWORD fStorageObject;                        // For DTSBindMode_Blob_StorageObject; one of DBPROPVAL_SS_*.  If
  645.                                                 // specified, eBindMode must be DTSBindMode_Blob_StorageObject.
  646.     ULONG cbInMemoryBlobSize;                    // For DTSBindMode of inmemory Blobs.  Setting this value overrides
  647.                                                 // the DataPump and any DTSTransformBlobDefaults default.  Size in bytes.
  648. } DTSBindInfo;
  649.  
  650. // This is a single column definition, binding, and data item for DTSTransformColumnInfo.
  651. typedef struct {
  652.     const DBCOLUMNINFO *pDBColumnInfo;            // Pointer to source or destination DBCOLUMNINFO for this column.
  653.     const DBBINDING *pDBBinding;                // Pointer to source or destination DBBINDING for this column.
  654.                                                 // wType == DBTYPE_EMPTY if this column is not referenced in any transform.
  655.     DTSBindInfo *pDTSBindInfo;                    // Pointer to source or destination DTSBindInfo for this column.
  656.     LPBYTE pvData;                                // Data space for this column, indexed by pDBBinding offsets.
  657.                                                 // NULL if this column was not referenced in any Transform.
  658. } DTSColumnData;
  659.  
  660. // The DBCOLUMNFLAGS and pwszName are in DBCOLUMNINFO and not DBBINDING;
  661. // therefore pass both structures to transform code.  The COM Transform server uses the
  662. // binding info to access the pvRowData.  This structure is passed to ITransformExecute::
  663. // Execute to expose the source and destination columns specified by the Transform.
  664. typedef struct {
  665.     DWORD fProviderStorageObjects;                // DBPROPVAL_SS_*; Blob Storage Object interfaces supported
  666.                                                 // by source or destination provider.  Will be 0 if none supported,
  667.                                                 // or if DTSTransformBlobDefaults::bForceBlobsInMemory is specified.
  668.     DTSProviderFlags dtsProviderFlags;            // Provider characterstics, e.g Blob Flags.
  669.     ULONG cColumns;                                // Count of columns in rgColumns
  670.     DTSColumnData *rgColumnData;                // Column schema and binding information
  671.     ULONG cPriorBlobStorageObjects;                // Number of Blobs bound as Storage Objects in prior transforms.
  672.                                                 // Can be used with DTSProviderFlag_Blob_MultipleStorageObjects
  673.                                                 // to determine if the current Transform can use a storage object.
  674. } DTSTransformColumnInfo, *LPDTSTransformColumnInfo;
  675. typedef const DTSTransformColumnInfo *LPCDTSTransformColumnInfo;
  676.  
  677. typedef enum {
  678.     DTSGuid_Variant,
  679.     DTSGuid_Guid,
  680.     DTSGuid_OleStr
  681. } DTSGuidType;
  682.  
  683. typedef struct {
  684.     DTSGuidType eType;                            // Indexes union.
  685.     union {
  686.         GUID Guid;                                // GUID form
  687.         VARIANT Variant;                        // BSTR == progid or clsid (differentiated by looking for æ.Æ in name)
  688.                                                 // BYTE/LONG == guid encoding (e.g. Repository))
  689.                                                 // UNKNOWN == pointer to IID_IDTSDataPumpTransform
  690.         LPOLESTR OleStr;                        // Progid or clsid (differentiated by looking for æ.Æ in name)
  691.     } DP_UNION_NAME(u);
  692. } DTSGuid;
  693.  
  694. #define DTS_DEFAULT_LookupCacheSize        100
  695.  
  696. // Specifies a query and list of columns for IDTSDataDrivenQuery.
  697. #ifndef DP_NO_AUTOCTOR
  698.     struct DTSTransformLookupSpecification {
  699. #else   // DP_NO_AUTOCTOR
  700.     typedef struct {
  701. #endif  // DP_NO_AUTOCTOR
  702.  
  703.         LPCOLESTR wzName;                                // Name of the Lookup (for disambiguation)
  704.         LPCOLESTR wzQuery;                                // The Parameterized Query
  705.         IUnknown *pIUnkSession;                            // Session to use for the Lookup
  706.         ULONG cMaxCacheRows;                            // Number of rows to cache
  707.  
  708. #ifndef DP_NO_AUTOCTOR
  709.         DTSTransformLookupSpecification() 
  710.                 : wzName(NULL)
  711.                 , wzQuery(NULL)
  712.                 , pIUnkSession(NULL)
  713.                 , cMaxCacheRows(DTS_DEFAULT_LookupCacheSize)
  714.             {    }
  715.     };
  716. #else   // DP_NO_AUTOCTOR
  717.     } DTSTransformLookupSpecification;
  718. #endif   // DP_NO_AUTOCTOR
  719. typedef DTSTransformLookupSpecification *LPDTSTransformLookupSpecification;
  720. typedef const DTSTransformLookupSpecification *LPCDTSTransformLookupSpecification;
  721.  
  722. ///////////////////////////////////////////////////////////////////////////////////////
  723. // Class and IID definitions
  724. ///////////////////////////////////////////////////////////////////////////////////////
  725.  
  726. // Forward-define all interfaces.
  727. #define DP_FWD_DEFINE_INTERFACE(itf)                    \
  728.     interface itf;                                        \
  729.     typedef interface itf * LP##itf;
  730.  
  731. // Repeat the IUnknown and IDispatch members because C doesn't provide inheritance.
  732. #ifndef DTSDataPump_Unknown_Base
  733. #define DTSDataPump_Unknown_Base()                                                            \
  734.         STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID * ppvObj) PURE;                \
  735.         STDMETHOD_(ULONG,AddRef) (THIS) PURE;                                                \
  736.         STDMETHOD_(ULONG,Release) (THIS) PURE;
  737. #endif
  738. #ifndef DTSDataPump_Dispatch_Base
  739. #define DTSDataPump_Dispatch_Base(itf)                                                        \
  740.         DTSDataPump_Unknown_Base()                                                            \
  741.         STDMETHOD(GetTypeInfoCount)(UINT FAR* pcTypeInfo) PURE;                                \
  742.         STDMETHOD(GetTypeInfo)(UINT iTypeInfo, LCID lcid, ITypeInfo FAR* FAR* ppTI) PURE;    \
  743.         STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR FAR* rgszNames, UINT cNames,            \
  744.                                 LCID lcid, DISPID FAR* rgdispid) PURE;                        \
  745.         STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags,            \
  746.                                 DISPPARAMS FAR* pdispparams, LPVARIANT pvarResult,            \
  747.                                 LPEXCEPINFO pexcepinfo, UINT FAR* puArgErr) PURE;
  748. #endif
  749. #ifndef DTSDataPump_IDispatch
  750. #define DTSDataPump_IDispatch IDispatch
  751. #endif
  752.  
  753. // Include <initguid.h> to define ownership of these GUIDs.
  754. // {xxxxxxxx-740b-11d0-ae7b-00aa004a34d5}
  755. #define DEFINE_DTSDataPumpGUID(name, lval) \
  756.       DEFINE_GUID(name, 0x##lval, 0x740b, 0x11d0, 0xae, 0x7b, 0x0, 0xaa, 0x0, 0x4a, 0x34, 0xd5);
  757.  
  758. // DTSPump-supplied classes and interfaces.
  759. DP_FWD_DEFINE_INTERFACE(IDTSDataPump)
  760. #define Progid_DTSDataPump            OLESTR("DTS.DataPump")
  761. DEFINE_DTSDataPumpGUID(CLSID_DTSDataPump, 10010100)
  762. DEFINE_DTSDataPumpGUID(IID_IDTSDataPump, 10010101)
  763.  
  764. #define Progid_DTSErrorLookup        OLESTR("DTS.ErrorLookup")
  765. DEFINE_DTSDataPumpGUID(CLSID_DTSErrorLookup, 10010102)
  766.  
  767. DP_FWD_DEFINE_INTERFACE(IDTSDataConvert)
  768. #define Progid_DTSDataConvert        OLESTR("DTS.DataConvert")
  769. DEFINE_DTSDataPumpGUID(CLSID_DTSDataConvert, 10010103)
  770. DEFINE_DTSDataPumpGUID(IID_IDTSDataConvert, 10010104)
  771. DEFINE_DTSDataPumpGUID(IID_IDTSDataDrivenQuery, 10010105)
  772. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpSpecifyLookups, 10010106)
  773.  
  774. // DTS Typelib IID's.
  775. DEFINE_DTSDataPumpGUID(LIBID_DataPump, 10010200)
  776. DP_FWD_DEFINE_INTERFACE(IDTSDataPumpColumns)
  777. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpColumns, 10010201)
  778. DP_FWD_DEFINE_INTERFACE(IDTSDataPumpColumn)
  779. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpColumn, 10010202)
  780. DEFINE_DTSDataPumpGUID(IID_IDTSErrorRecords, 10010203)
  781. DP_FWD_DEFINE_INTERFACE(IDTSDataPumpLookups)
  782. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpLookups, 10010204)
  783. DP_FWD_DEFINE_INTERFACE(IDTSDataPumpLookup)
  784. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpLookup, 10010205)
  785. DP_FWD_DEFINE_INTERFACE(IDTSDataPumpLookupVariant)
  786. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpLookupVariant, 10010206)
  787.  
  788. // Repository Storage IIDs.
  789. DEFINE_DTSDataPumpGUID(IID_IDTSRepositoryProvider, 100202F1)
  790. DEFINE_DTSDataPumpGUID(IID_IDTSRepositoryStorage, 100202F2)
  791.  
  792. /////////////////////////////////////////////////////////////////////////////////
  793. // Category id of DTS custom transforms.
  794. /////////////////////////////////////////////////////////////////////////////////
  795. DEFINE_DTSDataPumpGUID(CATID_DTSCustomXform, 10010100)    //we will use the same id as the pump clsid.
  796.  
  797. // Consumer-supplied classes and interfaces.
  798. DP_FWD_DEFINE_INTERFACE(IDTSDataPumpTransform)
  799. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpTransform, 10010300)
  800.  
  801. DP_FWD_DEFINE_INTERFACE(IDTSDataPumpErrorSink)
  802. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpErrorSink, 10010301)
  803.  
  804. DP_FWD_DEFINE_INTERFACE(IDTSDataPumpProgressSink)
  805. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpProgressSink, 10010302)
  806.  
  807. DP_FWD_DEFINE_INTERFACE(IDTSDataDrivenQuerySink)
  808. DEFINE_DTSDataPumpGUID(IID_IDTSDataDrivenQuerySink, 10010303)
  809.  
  810. // DTSDataPump-supplied COM Transform Servers
  811. // A "Transformation Server" coclass consists of:
  812. //        coclass TTransformServer {
  813. //            required IDTSDataPumpTransform;
  814. //
  815. //            // The following are optional if the TransformServer has no custom
  816. //            // properties requiring editing.  If it has, these are required.
  817. //            optional <Custom OleAut properties interface>;
  818. //            optional ISpecifyPropertyPages;
  819. //                optional IPropertyPage;
  820. //            optional IPersistPropertyBag;
  821. //        }
  822.  
  823. #define Progid_DTSDataPumpTransformCopy        OLESTR("DTS.DataPumpTransformCopy")
  824. DEFINE_DTSDataPumpGUID(CLSID_DTSDataPumpTransformCopy, 10010400)
  825. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpTransformCopy, 10010401)
  826. // No custom properties, therefore no custom interface or IID.
  827.  
  828. #define Progid_DTSDataPumpTransformScript    OLESTR("DTS.DataPumpTransformScript")
  829. DEFINE_DTSDataPumpGUID(CLSID_DTSDataPumpTransformScript, 10010501);
  830. DP_FWD_DEFINE_INTERFACE(IDTSDataPumpTransformScriptProperties)
  831. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpTransformScriptProperties, 10010502);
  832. DEFINE_DTSDataPumpGUID(IID_IDTSDataPumpTransformScript, 10010503);
  833.  
  834. //optional interface to be implemented by custom transform providers - used by DTS UI to configure the transforms
  835. DEFINE_DTSDataPumpGUID(IID_IDTSCustomTransformUI, 10010601);
  836.  
  837.  
  838. ////////////////////////////////////////////////////////////////////////////////////////
  839. //
  840. //    DataPump-supplied Transform variables.
  841. //
  842. // These are passed to IDTSDataPumpTransform::AddVariable.  They are all of type
  843. // VT_VARIANT.  IDTSErrorRecords (interface defined below) allows any transform
  844. // to append OLEDB Error Records to IErrorInfo for the current thread.  The name
  845. // "DTSErrorRecords" is what is passed to IDTSDataPumpTransform::AddVariable; the
  846. // VT_DISPATCH ma be QI'd (or cast) to IDTSErrorRecords.  This object is also
  847. // inserted into ActiveX Scripting namespaces invoked by the Pump.  All DTS-generated
  848. // variables are inserted into ActiveX scripting namespaces as non-global variables
  849. // (i.e. their methods must be qualified with the object name).
  850. //
  851. //        Name                    Type
  852. //        ----                    ----
  853. //        DTSError                DTS.Error
  854. #define wzDTSErrorRecords    OLESTR("DTSErrorRecords")
  855.  
  856. //
  857. // These are inserted by name into the global namespace of an ActiveX scripting transform.
  858. // View the type library to see the type definitions.  Note that the return value from the
  859. // method (FunctionEntry) must be an integral type.
  860. //
  861. //        Name                    Type
  862. //        ----                    ----
  863. //        DTSSource                DTS.Columns
  864. //        DTSDestination            DTS.Columns
  865. //        (return value)            adInt or adSmallInt (DTSTransformStatus)
  866. //
  867.  
  868. //
  869. // These are inserted by name into the global namespace of an ActiveX scripting transform,
  870. // as well as being passed to IDTSDataPumpTransform::AddVariable.
  871. //
  872. //        Name                    Type
  873. //        ----                    ----
  874. //        DTSLookups                DTS.Lookups
  875. #define wzDTSLookups        OLESTR("DTSLookups")
  876.  
  877. // These are the DTS-Package-supplied global variables, if the Pump is being run from
  878. // the Package.
  879. #define wzDTSGlobalVariables        OLESTR("DTSGlobalVariables")
  880.  
  881. // These are special pseudo-columnnames corresponding to Lineage.  They are also
  882. // the names of the corresponding GlobalVariables; TransformCopy will automatically
  883. // map them over to the specified destination column.  These names must not be used
  884. // by source column names.
  885. #define wzDTSLineage_FullString        OLESTR("DTSLineage_Full")
  886. #define wzDTSLineage_IntegerCRC        OLESTR("DTSLineage_Short")
  887.  
  888. ////////////////////////////////////////////////////////////////////////////////////////
  889.  
  890. ////////////////////////////////////////////////////////////////////////////////////////
  891. //
  892. //    DataPump-supplied interface definitions.
  893. //
  894. ////////////////////////////////////////////////////////////////////////////////////////
  895.  
  896. ///////////////////////////////////////
  897. // IDTSDataPump - Primary interface to specify source and destination rowsets,
  898. // add Transforms, and Execute() the transfer.  AddTransform will error if
  899. // SetRowsets has not been called, and SetRowsets will error if any transforms
  900. // have been added (because ValidateSchema has been done on them already).
  901. // InitNew() reinitializes the IDTSDataPump object.  Execute returns E_FAIL if aborted,
  902. // DB_E_ERRORSOCCURRED if max error count exceeded; DB_S_ERRORSOCCURRED if errors
  903. // less than the max allowed occurred, possible provider-specific errors, or NOERROR
  904. // if completed with no errors.
  905. ///////////////////////////////////////
  906.  
  907. #undef INTERFACE
  908. #define INTERFACE IDTSDataPump
  909. DECLARE_INTERFACE_(IDTSDataPump, IUnknown)
  910. {
  911.     DTSDataPump_Unknown_Base()
  912.  
  913.     STDMETHOD(InitNew)(THIS) PURE;
  914.     STDMETHOD(GetRowsets)(THIS_ 
  915.             DP_OUT IRowset **ppSrcRowset,
  916.             DP_OUT IRowsetChange **ppDestRowsetChange
  917.         ) PURE;
  918.     STDMETHOD(SetRowsets)(THIS_ 
  919.             DP_IN IRowset *pSrcRowset,                            // Must be able to retrieve these rows
  920.             DP_IN IRowsetChange *pDestRowsetChange                // Must have DBPROP_UPDATABILITY: DPBROP_UP_INSERT
  921.         ) PURE;
  922.     STDMETHOD(SetProgressRowCount)(THIS_
  923.             DP_IN ULONG cIn                                        // Interval for IDTSDataPumpProgressSink::OnIntervalComplete; default == 1000
  924.         ) PURE;
  925.     STDMETHOD(SetMaximumErrorRowCount)(THIS_
  926.             DP_IN ULONG cIn                                        // Maximum allowable error rows; default = 0 (abort on first error row).
  927.         ) PURE;
  928.     STDMETHOD(SetFetchBufferSize)(THIS_
  929.             DP_IN ULONG cIn                                        // Size of the GetNextRows HROW buffer (default = 1)
  930.         ) PURE;
  931.     STDMETHOD(SetInsertCommitSize)(THIS_
  932.             DP_IN ULONG cIn                                        // Number of successful InsertRows between "Commits", if supported by provider (default == 0; all rows in one batch).
  933.         ) PURE;
  934.     STDMETHOD(AddTransform)(THIS_ 
  935.             DP_IN LPCOLESTR pwzName,                            // Transform name
  936.             DP_IN LPBYTE pvUserData,                            // Will be passed to Sink if event occurs on Transform.
  937.             DP_IN LPCDTSTransformColumnsSpecification pColumns,    // Source and destination columns
  938.             DP_IN DTSGuid ServerClsid,                            // COM server ProgID or CLSID or IUnknown
  939.             DP_IN VARIANT ServerParameters,                        // Parameters to server for this transform
  940.             DP_IN DTSTransformFlags dwFlags,                    // Transformation column-validation flags
  941.             DP_IN IStorage *pIStorage                            // Pointer to persistent storage of Transform properties
  942.         ) PURE;
  943.     STDMETHOD(AddTransformVariable)(THIS_ 
  944.             DP_IN LPCOLESTR pwzName,                            // Variable name
  945.             DP_IN BOOL bGlobal,                                    // For ActiveX scripts, indicates whether this variable's
  946.                                                                 // methods must be qualified by the object name.
  947.             DP_IN VARIANT Variable                                // Variable value; passed to and updatable by Transform
  948.         ) PURE;
  949.     STDMETHOD(Execute)(THIS_ 
  950.             DP_IN LPBYTE pvUserData,                            // User data passed back to Sinks.
  951.             DP_OUT ULARGE_INTEGER *puliRowsComplete,            // Total number of source rows processed (including those skipped).
  952.             DP_OUT ULONG *pulErrorRows,                            // Total number of error rows encountered.
  953.             DP_OUT LPDTSExecuteStatus pExecStatus                // Pump return status.
  954.         ) PURE;
  955.     STDMETHOD(SetFirstRow)(THIS_
  956.             DP_IN ULARGE_INTEGER cIn                            // First source row to copy. Default is 1 (first row).
  957.         ) PURE;
  958.     STDMETHOD(SetLastRow)(THIS_
  959.             DP_IN ULARGE_INTEGER cIn                            // Last source row to copy. Default is 0 (copy all rows).
  960.         ) PURE;
  961. };
  962.  
  963. ///////////////////////////////////////
  964. // IDTSDataDrivenQuery - Allows specification of individual queries instead
  965. // of simple Insert at the Destination.  QI'd from IDTSDataPump.
  966. ///////////////////////////////////////
  967.  
  968. #undef INTERFACE
  969. #define INTERFACE IDTSDataDrivenQuery
  970. DECLARE_INTERFACE_(IDTSDataDrivenQuery, IUnknown)
  971. {
  972.     DTSDataPump_Unknown_Base()
  973.  
  974.     // The following four pairs of properties and methods should be called in the
  975.     // order listed.
  976.  
  977.     // Specify and retrieve the source rowset from which data will be read.
  978.     STDMETHOD(SetSourceRowset)(THIS_ 
  979.             DP_IN IRowset *pSrcRowset
  980.         ) PURE;
  981.     STDMETHOD(GetSourceRowset)(THIS_ 
  982.             DP_OUT IRowset **ppSrcRowset
  983.         ) PURE;
  984.  
  985.     // Specify and retrieve the destination session and column schema; this defines how the
  986.     // parameters to the queries will be bound.  Specifying the schema is done in one of two ways:
  987.     //    - If cColumnDescs is 0, then rgColumnDescs is ignored and pDestConnection must
  988.     //      be a Rowset.  Rowset information will be retrieved, but the Rowset itself will not
  989.     //      be retained.  The Session will be retrieved from the Rowset and retained.
  990.     //    - If cColumnDescs is not 0, then rgColumnDescs must not be NULL and pDestConnection
  991.     //      must be a Session.  The destination column definitions are created from the DBCOLUMNDESCs.
  992.     //
  993.     STDMETHOD(SetDestinationInfo)(THIS_
  994.             DP_IN IUnknown *pDestConnection,
  995.             DP_IN ULONG cColumnDescs,
  996.             DP_IN DBCOLUMNDESC rgColumnDescs[]
  997.         ) PURE;
  998.     // pcColumns, prgInfo, and ppStringsBuffer are allocated as in IColumnsInfo::GetColumnInfo.
  999.     STDMETHOD(GetDestinationInfo)(THIS_
  1000.             DP_IN REFIID riidSession, 
  1001.             DP_OUT IUnknown **ppIUnkSession,
  1002.             DP_OUT ULONG *pcColumns,
  1003.             DP_OUT DBCOLUMNINFO **prgInfo,
  1004.             DP_OUT OLECHAR **ppStringsBuffer
  1005.         ) PURE;
  1006.  
  1007.     // Specify and retrieve the destination queries and their column mappings to parameters.
  1008.     // Unused queries may be NULL, in which case a Transform return status of DTSTransformStat_*Query
  1009.     // indicating an unset query will result in an error.
  1010.     STDMETHOD(SetDestinationQueries)(THIS_ 
  1011.             DP_IN LPCDTSTransformQuerySpecification pInsertQuerySpec,
  1012.             DP_IN LPCDTSTransformQuerySpecification pUpdateQuerySpec,
  1013.             DP_IN LPCDTSTransformQuerySpecification pDeleteQuerySpec,
  1014.             DP_IN LPCDTSTransformQuerySpecification pUserQuerySpec
  1015.         ) PURE;
  1016.     // Each pointer is a single CoTaskMemAlloc containing space for the base QuerySpecification structure,
  1017.     // the array of column info, and the string buffer.  Internal pointers are based (with alignment)
  1018.     // according to this allocated space.
  1019.     STDMETHOD(GetDestinationQueries)(THIS_ 
  1020.             DP_OUT LPDTSTransformQuerySpecification *ppInsertQuerySpec,
  1021.             DP_OUT LPDTSTransformQuerySpecification *ppUpdateQuerySpec,
  1022.             DP_OUT LPDTSTransformQuerySpecification *ppDeleteQuerySpec,
  1023.             DP_OUT LPDTSTransformQuerySpecification *ppUserQuerySpec
  1024.         ) PURE;
  1025. };
  1026.  
  1027. ///////////////////////////////////////
  1028. // IDTSDataPumpLookups - Allows specification of Lookups for TransformServer use.
  1029. ///////////////////////////////////////
  1030.  
  1031. #undef INTERFACE
  1032. #define INTERFACE IDTSDataPumpSpecifyLookups
  1033. DECLARE_INTERFACE_(IDTSDataPumpSpecifyLookups, IUnknown)
  1034. {
  1035.     DTSDataPump_Unknown_Base()
  1036.  
  1037.     // Specify and retrieve the lookup specifications for this DataPump instance.
  1038.     STDMETHOD(SetLookups)(THIS_ 
  1039.             DP_IN ULONG cLookups,
  1040.             DP_IN LPCDTSTransformLookupSpecification pLookups
  1041.         ) PURE;
  1042.     // The pointer is a single CoTaskMemAlloc containing space for the base LookupSpecification structure
  1043.     // and the string buffer.  Internal pointers are based (with alignment) according to this allocated space.
  1044.     // pIUnkSession is AddRef'd and must be released.
  1045.     STDMETHOD(GetLookups)(THIS_ 
  1046.             DP_IN ULONG *pcLookups,
  1047.             DP_IN LPDTSTransformLookupSpecification *ppLookups
  1048.         ) PURE;
  1049. };
  1050.  
  1051. ///////////////////////////////////////
  1052. // IDTSDataConvert - The DTS data-conversion interface.
  1053. ///////////////////////////////////////
  1054.  
  1055. #undef INTERFACE
  1056. #define INTERFACE IDTSDataConvert
  1057. DECLARE_INTERFACE_(IDTSDataConvert, IDataConvert)
  1058. {
  1059.     DTSDataPump_Unknown_Base()
  1060.  
  1061.     //////////////////////////////////////////////////////
  1062.     // IDataConvert interface members (msdadc.h required).
  1063.     //////////////////////////////////////////////////////
  1064.  
  1065.     // Copies or converts data from one DBTYPE to another.  If wDstType includes DBTYPE_BYREF,
  1066.     // it must be a variable-length type (DBTYPE_((W)STR|BYTES)) or this method will error.
  1067.     // Otherwise, for all DBTYPE_BYREF destination conversions, this method CoTaskMemAlloc(s)
  1068.     // the destination data pointer, and it is the caller's responsibility to CoTaskMemFree it.
  1069.     // This method should not be used to place data into the DataPump's destination binding;
  1070.     // instead, use the ConvertToBinding method.
  1071.     STDMETHOD(DataConvert)( 
  1072.             DP_IN DBTYPE wSrcType,
  1073.             DP_IN DBTYPE wDstType,
  1074.             DP_IN ULONG cbSrcLength,
  1075.             DP_INOUT ULONG *pcbDstLength,
  1076.             DP_IN void *pSrc,
  1077.             DP_OUT void *pDst,
  1078.             DP_IN ULONG cbDstMaxLength,
  1079.             DP_IN DBSTATUS dbsSrcStatus,
  1080.             DP_OUT DBSTATUS *pdbsStatus,
  1081.             DP_IN BYTE bPrecision,
  1082.             DP_IN BYTE bScale,
  1083.             DP_IN DBDATACONVERT dwFlags
  1084.         ) PURE;
  1085.  
  1086.     // Determines if two types are potentially compatible.  See GetConvertFlags
  1087.     // for more detailed information about what the conversion may encounter.
  1088.     STDMETHOD(CanConvert)( 
  1089.             DP_IN DBTYPE wSrcType,
  1090.             DP_IN DBTYPE wDstType
  1091.         ) PURE;
  1092.  
  1093.     // Returns the required conversion size in bytes.  May base this on pcbSrcLength
  1094.     // and/or pSrc, if supplied, to get per-data-item information.
  1095.     //
  1096.     // DBTYPE_BSTR is considered a fixed type; its binding length is sizeof(BSTR).
  1097.     // To determine the length necessary to pre-allocate a BSTR, pass in DBTYPE_STR
  1098.     // for the destination type - for this type, character count == byte count.
  1099.     // Alternatively, use WSTR and divide the return by sizeof(WCHAR).
  1100.     //
  1101.     STDMETHOD(GetConversionSize)( 
  1102.             DP_IN DBTYPE wSrcType,
  1103.             DP_IN DBTYPE wDstType,
  1104.             DP_IN ULONG *pcbSrcLength,
  1105.             DP_OUT ULONG *pcbDstLength,
  1106.             DP_IN void *pSrc
  1107.         ) PURE;
  1108.  
  1109.     //////////////////////////////////////////////////////
  1110.     // DTS extensions.
  1111.     //////////////////////////////////////////////////////
  1112.  
  1113.     // This method first calls CanConvert() to determine if the conversion can succeed at all
  1114.     // given the source and destination datatypes, and if so, returns extended information about
  1115.     // how (or if) the conversion can proceed after that.
  1116.     // It uses the following fields for source and destination (S and D):
  1117.     //    DBCOLUMNINFO - validates all conversion info between columns.
  1118.     //        dwFlags                    S,D
  1119.     //        ulColumnSize            S,D
  1120.     //        wType                    S,D
  1121.     //        bPrecision                S,D
  1122.     //        bScale                    S,D
  1123.     //    Fields other than dwFlags and wType can be zero'd and the output ConvertFlags
  1124.     //    tested for the Unsupported bit if length validation is not required.
  1125.     // Note that this does not set a flag for nontext <-> text if the text length is
  1126.     // sufficient to accommodate it; this is because all such conversions should be valid
  1127.     // If this level of exactness is required, simply compare the datatypes for equality.
  1128.     STDMETHOD(GetConvertFlags)(
  1129.             DP_IN const DBCOLUMNINFO *pSrcColumnInfo,        // Source column metadata
  1130.             DP_IN const DBCOLUMNINFO *pDestColumnInfo,        // Destination column metadata
  1131.             DP_OUT DTSConvertFlags *pConvertFlags            // Output conversion flags
  1132.         ) PURE;
  1133.  
  1134.     // This method allows the Transform Server to convert source data (which may come from
  1135.     // the source binding directly, as in the comment examples, or from ad-hoc source data).
  1136.     // It uses the following fields in the destination binding (S is fields that are used
  1137.     // from a source binding if that is how the source data is stored):
  1138.     //    DBBINDING:
  1139.     //        obValue                    S,D        -- must be bound
  1140.     //        obLength                S,D        -- must be bound
  1141.     //        obStatus                S,D        -- must be bound
  1142.     //        dwPart                    S,D        -- must include length, value, status
  1143.     //        cbMaxLen                D
  1144.     //        wType                    S,D
  1145.     //        bPrecision                D
  1146.     //        bScale                    D
  1147.     //
  1148.     // The destination data is set according to eTransformFlags and pDestBind->dwMemOwner, which
  1149.     // is handled as follows:
  1150.     //
  1151.     // DBMEMOWNER_CLIENTOWNED: normal conversion is done; data is copied from source to destination,
  1152.     //        converted as needed, and allocations are done as needed.  Specifically:
  1153.     //            BSTR data is deep-copied
  1154.     //            BYREF destination data is copied into a CoTaskMemAlloc()'d pointer.
  1155.     //            IUnknown and IDispatch pointers are AddRef()'d.
  1156.     //        The destination binding data must always be free'd.  The foregoing lists what is freed
  1157.     //        (or Release()'d) by IDTSDataConvert::ClearBindingData.
  1158.     //
  1159.     // DBMEMOWNER_PROVIDEROWNED:  Conversion will attempt to shallow-copy data, avoiding allocations.
  1160.     //        This requires that the source and destination datatypes be identical (except for DBTYPE_BYREF).
  1161.     //        This is intended as a performance enhancement and requires that the source data remain stable
  1162.     //        for the lifetime of the Destination binding (such as while being inserted via the DataPump).
  1163.     //        It handles only the following cases:
  1164.     //            If the destination type includes DBTYPE_BYREF    // it must therefore be ((W)STR|BYTES)
  1165.     //                *pvDestData = pvSrcData (or *pvSrcData if source type is BYREF)
  1166.     //                StringTruncation is performed by adjusting destination datalength
  1167.     //            else if destination type is BSTR
  1168.     //                *pvDestData = *pvSrcData (or **pvSrcData if source type is BYREF)
  1169.     //                StringTruncation is NOT checked here as this is a fixed-length datatype
  1170.     //            else 
  1171.     //                Normal conversion is done, including:
  1172.     //                    AddRefs of IDispatch/IUnknown pointers
  1173.     //                    VariantCopy (OLEDB behaviour does not allow PROVIDEROWNED Variant binding).
  1174.     // DBMEMOWNER_PROVIDEROWNED binding data will not be freed by IDTSDataConvert::ClearBindingData.
  1175.     // If a custom allocator is used for BYREF destination data, then it must be freed by a corresponding
  1176.     // custom deallocator, rather than by ClearBindingData.  Therefore, it should be bound ProviderOwned;
  1177.     // the pointer will be shallow-copied into the binding by IDTSDataConvert::ConvertToBinding.
  1178.     //
  1179.     STDMETHOD(ConvertToBinding)(
  1180.             DP_IN DBTYPE wSrcType,                            // Source datatype:  e.g. pSrcBind->wType
  1181.             DP_IN ULONG cbSrcLength,                        // Source data length:  e.g. *(reinterpret_cast<ULONG *>(pSrcColumnInfo->pvRowData + pSrcBind->obLength));
  1182.             DP_IN DBSTATUS dbsSrcStatus,                    // Source data status:  e.g. *(reinterpret_cast<DBSTATUS *>(pSrcColumnInfo->pvRowData + pSrcBind->obStatus));
  1183.             DP_IN const BYTE *pvSrcColData,                    // Source column data: e.g. pSrcColumnInfo->pvRowData + pSrcBind->obValue;
  1184.             DP_IN const DBBINDING *pDestBind,                // Dest binding info
  1185.             DP_IN BYTE *pvDestRowData,                        // Dest row data; NOT obValue-offset as the Binding will reference it 3 ways (obLength, obValue, obStatus)
  1186.             DP_IN DBCOLUMNFLAGS dwDestColumnFlags,            // Dest flags such as nullability
  1187.             DP_IN ULONG ulDestColumnSize,                    // If nonzero and Dest is BYREF, tested for String Truncation
  1188.             DP_IN DTSTransformFlags eTransformFlags            // Transformation flags.  Currently considered:
  1189.                                                             //        DTSTransformFlag_AllowStringTruncation
  1190.                                                             //        DTSTransformFlag_ForceConvert as it applies to foregoing
  1191.         ) PURE;
  1192.  
  1193.     // This method frees any CLIENTOWNED allocations in the Binding, as discussed in ConvertToBinding.
  1194.     // This method always sets length to 0 and status to DBSTATUS_S_ISNULL, and can zeroinit if specified.
  1195.     STDMETHOD(ClearBindingData)(
  1196.             DP_IN const DBBINDING *pDestBind,                // Dest binding info
  1197.             DP_IN BYTE *pvDestRowData,                        // Dest row data; NOT obValue-offset as the Binding will reference it 3 ways (obLength, obValue, obStatus)
  1198.             DP_IN BOOL bZeroInit                            // If TRUE, zero's the data value
  1199.         ) PURE;
  1200. };
  1201.  
  1202. ///////////////////////////////////////
  1203. // IDTSErrorRecords - Allows the caller to append OLEDB Error Records to the current
  1204. // thread's IErrorInfo.  The Error Lookup Service is CLSID_DTSErrorLookup.
  1205. // This interface is derived from IDispatch and may be used in ActiveX Scripts as
  1206. // well as from C/C++.
  1207. ///////////////////////////////////////
  1208.  
  1209. #undef INTERFACE
  1210. #define INTERFACE IDTSErrorRecords
  1211. DECLARE_INTERFACE_(IDTSErrorRecords, DTSDataPump_IDispatch)
  1212. {
  1213.     DTSDataPump_Dispatch_Base(IDTSErrorRecords)
  1214.  
  1215.     STDMETHOD(Clear)(THIS) PURE;
  1216.     STDMETHOD(Add)(THIS_ DP_IN long Number,
  1217.                 DP_IN long NativeError,
  1218.                 DP_IN BSTR Description,
  1219.                 DP_IN BSTR Source,
  1220.                 DP_IN BSTR Helpfile,
  1221.                 DP_IN long Helpid
  1222.             ) PURE;
  1223. };
  1224.  
  1225. ///////////////////////////////////////
  1226. // IDTSDataPumpColumns - Columns collection as exposed to AxScript.
  1227. // We expose DTSSource and DTSDestination collections.
  1228. // This interface is derived from IDispatch and may be used in ActiveX Scripts as
  1229. // well as from C/C++.  This is identical to the ADO.Field interface.
  1230. ///////////////////////////////////////
  1231.  
  1232. #undef INTERFACE
  1233. #define INTERFACE IDTSDataPumpColumns
  1234. DECLARE_INTERFACE_(IDTSDataPumpColumns, DTSDataPump_IDispatch)
  1235. {
  1236.     DTSDataPump_Dispatch_Base(IDTSDataPumpColumns)
  1237.  
  1238.     STDMETHOD(Item)(THIS_ DP_IN VARIANT Index, DP_OUT IDTSDataPumpColumn **pRetVal) PURE;
  1239.     STDMETHOD(get__NewEnum)(THIS_ DP_OUT IUnknown **ppEnum) PURE;
  1240.     STDMETHOD(get_Count)(THIS_ DP_OUT long *pRetVal) PURE;
  1241. };
  1242.  
  1243. ///////////////////////////////////////
  1244. // IDTSDataPumpColumn - Column object as exposed to AxScript.
  1245. // These objects make up the DTSSource and DTSDestination collections.
  1246. // They provide access to the column value and its metadata
  1247. // This interface is derived from IDispatch and may be used in ActiveX Scripts as
  1248. // well as from C/C++.  This is identical to the ADO.Field interface.
  1249. ///////////////////////////////////////
  1250.  
  1251. #undef INTERFACE
  1252. #define INTERFACE IDTSDataPumpColumn
  1253. DECLARE_INTERFACE_(IDTSDataPumpColumn, DTSDataPump_IDispatch)
  1254. {
  1255.     DTSDataPump_Dispatch_Base(IDTSDataPumpColumn)
  1256.  
  1257.     STDMETHOD(get_Value)(THIS_ DP_OUT VARIANT *pRetVal) PURE;
  1258.     STDMETHOD(put_Value)(THIS_ DP_IN VARIANT NewValue) PURE;
  1259.     STDMETHOD(get_ActualSize)(THIS_ DP_OUT long  *pl) PURE;
  1260.     STDMETHOD(get_Attributes)(THIS_ DP_OUT long  *pl) PURE;
  1261.     STDMETHOD(get_DefinedSize)(THIS_ DP_OUT long  *pl) PURE;
  1262.     STDMETHOD(get_Name)(THIS_ DP_OUT BSTR  *pbstr) PURE;
  1263.     STDMETHOD(get_Type)(THIS_ DP_OUT long  *pDataType) PURE;
  1264.     STDMETHOD(get_Precision)(THIS_ DP_OUT BYTE  *pbPrecision) PURE;
  1265.     STDMETHOD(get_NumericScale)(THIS_ DP_OUT BYTE  *pbNumericScale) PURE;
  1266.     STDMETHOD(get_OriginalValue)(THIS_ DP_OUT VARIANT  *pvar) PURE;
  1267.     STDMETHOD(get_UnderlyingValue)(THIS_ DP_OUT VARIANT  *pvar) PURE;
  1268.     STDMETHOD(AppendChunk)(THIS_ DP_IN VARIANT Data) PURE;
  1269.     STDMETHOD(GetChunk)(THIS_ DP_IN long Length, DP_OUT VARIANT  *pvar) PURE;
  1270. };
  1271.  
  1272. ///////////////////////////////////////
  1273. // IDTSDataPumpLookups - Lookups collection as exposed to AxScript.
  1274. // We expose DTSLookups as a collection.
  1275. // This interface is derived from IDispatch and may be used in ActiveX Scripts as
  1276. // well as from C/C++.
  1277. ///////////////////////////////////////
  1278.  
  1279. #undef INTERFACE
  1280. #define INTERFACE IDTSDataPumpLookups
  1281. DECLARE_INTERFACE_(IDTSDataPumpLookups, DTSDataPump_IDispatch)
  1282. {
  1283.     DTSDataPump_Dispatch_Base(IDTSDataPumpLookups)
  1284.  
  1285.     STDMETHOD(Item)(THIS_ DP_IN VARIANT Index, DP_OUT IDTSDataPumpLookup **pRetVal) PURE;
  1286.     STDMETHOD(Get_NewEnum)(THIS_ DP_OUT IUnknown **ppEnum) PURE;
  1287.     STDMETHOD(GetCount)(THIS_ DP_OUT long *pRetVal) PURE;
  1288. };
  1289.  
  1290. ///////////////////////////////////////
  1291. // IDTSDataPumpLookup - Lookup object as exposed to AxScript.
  1292. // These objects make up the DTSLookups collection.
  1293. // This interface is derived from IDispatch and may be used in ActiveX Scripts as
  1294. // well as from C/C++.  The KeyValues input parameter to the methods is a SafeArray
  1295. // of Variant, using the vararg attribute on the methods, for best use in ActiveX
  1296. // scripts.  The return value is a variant (if single-valued) or an array of variants
  1297. // (if multi-valued) corresponding to the sequence of columns in the single output
  1298. // row resulting from execution of the query.  If multiple rows are returned, only
  1299. // the first is returned in the output variant.  LastRowCount is used in case an
  1300. // app wants to assert that only one row was returned.
  1301. ///////////////////////////////////////
  1302.  
  1303. // This form is understood by scripting languages to take a variable number of
  1304. // arguments in the key values specification.  It can be used from C++ as well.
  1305. #undef INTERFACE
  1306. #define INTERFACE IDTSDataPumpLookup
  1307. DECLARE_INTERFACE_(IDTSDataPumpLookup, DTSDataPump_IDispatch)
  1308. {
  1309.     DTSDataPump_Dispatch_Base(IDTSDataPumpLookup)
  1310.  
  1311.     STDMETHOD(get_Name)(THIS_ DP_OUT BSTR  *pbstr) PURE;
  1312.     STDMETHOD(get_LastRowCount)(THIS_ LONG *pRetVal) PURE;
  1313.     STDMETHOD(Execute)(THIS_ DP_IN SAFEARRAY * KeyValues, DP_OUT VARIANT *pRetVal) PURE;
  1314.     STDMETHOD(AddToCache)(THIS_ DP_IN VARIANT DataValues, DP_IN SAFEARRAY * KeyValues) PURE;
  1315.     STDMETHOD(RemoveFromCache)(THIS_ DP_IN SAFEARRAY * KeyValues) PURE;
  1316. };
  1317.  
  1318. // This is a form of the interface which takes a single Variant, more convenient
  1319. // for C++ programs which know they'll only have a single key column.  The variant
  1320. // may be a single value or may itself contain a safearray.
  1321. #undef INTERFACE
  1322. #define INTERFACE IDTSDataPumpLookupVariant
  1323. DECLARE_INTERFACE_(IDTSDataPumpLookupVariant, IUnknown)
  1324. {
  1325.     STDMETHOD(Execute)(THIS_ DP_IN VARIANT KeyValues, DP_OUT VARIANT *pRetVal) PURE;
  1326.     STDMETHOD(AddToCache)(THIS_ DP_IN VARIANT DataValues, DP_IN VARIANT KeyValues) PURE;
  1327.     STDMETHOD(RemoveFromCache)(THIS_ DP_IN VARIANT KeyValues) PURE;
  1328. };
  1329.  
  1330. ////////////////////////////////////////////////////////////////////////////////////////
  1331. //
  1332. //    Pump-supplied Transform custom-property interfaces.
  1333. //
  1334. ////////////////////////////////////////////////////////////////////////////////////////
  1335.  
  1336. ///////////////////////////////////////
  1337. // IDTSDataPumpTransformScriptProperties - Sets custom properties for the
  1338. // ActiveX scripting transformation server.
  1339. ///////////////////////////////////////
  1340.  
  1341. #undef INTERFACE
  1342. #define INTERFACE IDTSDataPumpTransformScriptProperties
  1343. DECLARE_INTERFACE_(IDTSDataPumpTransformScriptProperties, DTSDataPump_IDispatch)
  1344. {
  1345.     DTSDataPump_Dispatch_Base(IDTSDataPumpTransformScriptProperties)
  1346.  
  1347.     STDMETHOD(GetText)(THIS_ BSTR DP_OUT *pRetVal) PURE;
  1348.     STDMETHOD(SetText)(THIS_ BSTR DP_IN NewValue) PURE;
  1349.     STDMETHOD(GetLanguage)(THIS_ BSTR DP_OUT *pRetVal) PURE;
  1350.     STDMETHOD(SetLanguage)(THIS_ BSTR DP_IN NewValue) PURE;
  1351.     STDMETHOD(GetFunctionEntry)(THIS_ BSTR DP_OUT *pRetVal) PURE;
  1352.     STDMETHOD(SetFunctionEntry)(THIS_ BSTR DP_IN NewValue) PURE;
  1353. };
  1354.  
  1355. ////////////////////////////////////////////////////////////////////////////////////////
  1356. //
  1357. //    Consumer-supplied interface definitions.
  1358. //
  1359. ////////////////////////////////////////////////////////////////////////////////////////
  1360.  
  1361. ///////////////////////////////////////
  1362. // IDTSDataPumpTransform - Required interface of the "COM Server" instantiated by ServerClsid
  1363. // passed to IDTSDataPump::AddTransform.  This interface is retrieved and its methods called
  1364. // by the Pump to perform individual transforms. 
  1365. //
  1366. // ServerParameters allows the DataPump Consumer to instantiate a single instance of an
  1367. // IDTSDataPumpTransform implementation and pass it to multiple IDTSDataPump::AddTransform calls.
  1368. // This is only useful for custom Transform Servers (the DTS-supplied ones ignore this), and may be
  1369. // helpful for internal summations etc.  If this is done, the TransformServer should track this in its
  1370. // pvTransformServerData to optimize operations such as AddVariable, On(Row|Transform)Complete, etc.
  1371. ///////////////////////////////////////
  1372.  
  1373. #undef INTERFACE
  1374. #define INTERFACE IDTSDataPumpTransform
  1375. DECLARE_INTERFACE_(IDTSDataPumpTransform, IUnknown)
  1376. {
  1377.     DTSDataPump_Unknown_Base()
  1378.  
  1379.     // Allows the TransformServer to initialize its state for the current Transform.  The output
  1380.     // LPBYTE is passed to all subsequent methods, so a single TransformServer instance may be
  1381.     // used to implement multiple separate transforms.
  1382.     STDMETHOD(Initialize)(THIS_
  1383.             DP_IN LPCOLESTR pwzName,                            // Transform name
  1384.             DP_IN VARIANT ServerParameters,                        // Parameters to server for this transform
  1385.             DP_OUT LPBYTE *ppvTransformServerData                // Transform server state data.
  1386.         ) PURE;
  1387.  
  1388.     // Validates the schema that will be transformed.  Allows the TransformServer to specify
  1389.     // certain modifications to the default binding modes, such as for BLOBs.  The default 
  1390.     // p(Src|Dest)ColumnInfo->ppDTSColBinding[ii].eBindModes intialized by the DataPump are:
  1391.     //
  1392.     // All BLOBs must be ClientOwned by OLEDB spec, so Source and Destination BLOBs are always
  1393.     // DTSBindMode_Byref_ClientOwned.
  1394.     // 
  1395.     // Source:  For efficiency, nonBLOB ((W)STR|BYTES) binding defaults to _Byref_ProviderOwned
  1396.     // to avoid unnecessary copying.  BSTR defaults to ProviderOwned.  All other types must be
  1397.     // non-Byref ClientOwned by OLEDB spec and behaviour.
  1398.     //
  1399.     // Destination:  Because the destination data is likely to be the result of a transformation,
  1400.     // destination binding always defaults to ClientOwned for all datatypes.  All nonBLOB types are
  1401.     // allocated Inline; this includes ((W)STR|BYTES), to minimize per-row (re)allocation overhead.
  1402.     //
  1403.     // A Transformation which simply passes-thru nonBLOB ((W)STR|BYTES)s or BSTRs from the Source
  1404.     // IRowset to the destination (and doesn't use the TransformCopy server, which is supplied for
  1405.     // this purpose) should override this to ProviderOwned to avoid unnecessary (re)allocations.
  1406.     //
  1407.     STDMETHOD(ValidateSchema)(THIS_
  1408.             DP_IN LPBYTE pvTransformServerData,                    // Transform server state data.
  1409.             DP_INOUT LPCDTSTransformColumnInfo pSrcColumnInfo,     // Source columns and rowdata
  1410.             DP_INOUT LPCDTSTransformColumnInfo pDestColumnInfo, // Dest columns and rowdata
  1411.             DP_IN IDTSDataConvert *pIDTSDataConvert,            // Pointer to the data conversion interface
  1412.             DP_IN DTSTransformFlags eTransformFlags                // Input Flags for Transformation validation and execution
  1413.         ) PURE;
  1414.  
  1415.     // Adds a variable to the TransformServer's execution context.  This is always called once before
  1416.     // ValidateSchema, in order to add the IDTSErrorRecords object.
  1417.     STDMETHOD(AddVariable)(THIS_ 
  1418.             DP_IN LPBYTE pvTransformServerData,                    // Transform server state data.
  1419.             DP_IN LPCOLESTR pwzName,                            // Variable name
  1420.             DP_IN BOOL bGlobal,                                    // For ActiveX scripts, indicates whether this variable's
  1421.                                                                 // methods must be qualified by the object name.
  1422.             DP_IN VARIANT Variable                                // Variable value; passed to and updatable by Transform
  1423.         ) PURE;
  1424.  
  1425.     // Executes the transformation for a single row.  This method should return a SUCCEED
  1426.     // hr except in catastrophic failure; a FAILED hr here will abort the Pump.  "Normal"
  1427.     // errors such as data violations should be handled as a returned pTransformStatus,
  1428.     // which will cause IDTSDataPumpErrorSink::OnTransformError to be called.
  1429.     //
  1430.     // Because some providers may have restrictions on the number of Storage Objects which
  1431.     // may be open, Execute() should release any Blob Storage Objects in the source upon
  1432.     // completion, rather than waiting for OnRowComplete.  The DataPump handles refcounting
  1433.     // for multiple transforms of its buffered Source objects.  If the Blob column is
  1434.     // buffered by the DataPump or the Transform has knowledge of the Source Provider, it
  1435.     // can defer Release()ing the Source Storage Object until OnRowComplete.  Note that
  1436.     // returning DTSTransformStat_SkipFetch (and therefore not releasing the Source Storage
  1437.     // Object) may require buffering of the source Blob data.
  1438.     STDMETHOD(Execute)(THIS_
  1439.             DP_IN LPBYTE pvTransformServerData,                    // Transform server state data.
  1440.             DP_IN LPCDTSTransformColumnInfo pSrcColumnInfo,     // Source columns and rowdata
  1441.             DP_INOUT LPDTSTransformColumnInfo pDestColumnInfo,     // Dest columns and rowdata
  1442.             DP_IN IDTSDataConvert *pIDTSDataConvert,            // Pointer to the data conversion interface
  1443.             DP_OUT LPDTSTransformStatus peTransformStatus        // Result of transform
  1444.         ) PURE;
  1445.  
  1446.     // After a successful Fetch, the pump calls Execute and then attempts to insert the row into the
  1447.     // destination IRowsetChange (if one is specified).  OnRowComplete is called for every successful
  1448.     // Fetch (whether the Execute() and InsertRow succeeded or failed); this allows the TransformServer
  1449.     // to free per-row allocations and CLIENTOWNED data in both source and destination rows (such as
  1450.     // by calling pIDTSDataConvert->ClearBindingData).  A FAILED return from OnRowComplete aborts the Pump.
  1451.     // hrInsert indicates whether the IRowsetChange::InsertRow() succeeded; eTransformStatus indicates
  1452.     // if errors occurred such that InsertRow was not called.
  1453.     //
  1454.     // Note that OLEDB specifies that IRowsetChange::InsertRow() Releases any contained Storage Objects
  1455.     // in the row (but not other types of "allocations"), so the Transform server must be careful not to 
  1456.     // call pIDTSDataConvert->ClearBindingData on an already final-released Storage Object (in the event
  1457.     // that InsertRow is not called due to a Transform returning an error, the DataPump will release any
  1458.     // Storage Objects in the dest row for any Transforms for which Execute was called prior to the erroring
  1459.     // Transform, to present a consistent refcounting interface to TransformServers:  If Execute() returned
  1460.     // a non-NULL Storage Object in the row, it will be released once before OnRowComplete is called).
  1461.     //
  1462.     STDMETHOD(OnRowComplete)(THIS_
  1463.             DP_IN LPBYTE pvTransformServerData,                    // Transform server state data.
  1464.             DP_INOUT LPDTSTransformColumnInfo pSrcColumnInfo,    // Source columns and rowdata
  1465.             DP_INOUT LPDTSTransformColumnInfo pDestColumnInfo,     // Dest columns and rowdata
  1466.             DP_IN IDTSDataConvert *pIDTSDataConvert,            // Pointer to the data conversion interface
  1467.             DP_IN DTSTransformStatus eTransformStatus,            // Result of Execute()
  1468.             DP_IN HRESULT hrInsert                                // Result of IRowsetChange::InsertRow()
  1469.         ) PURE;
  1470.  
  1471.     // After all rows have been transformed (or the pump has been shutdown due to errors),
  1472.     // OnTransformComplete is called to give the TransformServer a chance to clean up all
  1473.     // allocations made for the Transform.  OnTransformComplete is called only if ValidateSchema
  1474.     // returned successfully.
  1475.     STDMETHOD(OnTransformComplete)(THIS_
  1476.             DP_IN LPBYTE pvTransformServerData,                    // Transform server state data.
  1477.             DP_INOUT LPDTSTransformColumnInfo pSrcColumnInfo,    // Source columns and rowdata
  1478.             DP_INOUT LPDTSTransformColumnInfo pDestColumnInfo,     // Dest columns and rowdata
  1479.             DP_IN IDTSDataConvert *pIDTSDataConvert                // Pointer to the data conversion interface
  1480.         ) PURE;
  1481. };
  1482.  
  1483.  
  1484. ///////////////////////////////////////
  1485. // IDTSDataPumpErrorSink - Specifies pump error handler sink.  Only one method will
  1486. // be called for any row, and the method called indicates where the error was encountered:
  1487. // reading from source, transforming, or writing to destination.
  1488. ///////////////////////////////////////
  1489.  
  1490. #undef INTERFACE
  1491. #define INTERFACE IDTSDataPumpErrorSink
  1492. DECLARE_INTERFACE_(IDTSDataPumpErrorSink, IUnknown)
  1493. {
  1494.     DTSDataPump_Unknown_Base()
  1495.  
  1496.     // An error occurred on Binding in CreateAccessor.  This is only useful for designing custom Transform
  1497.     // Servers, primarily for diagnosing Blob difficulties.
  1498.     STDMETHOD(OnBindingError)(THIS_ 
  1499.             DP_IN LPBYTE pvExecUserData,                // User data pointer passed to IDTSDataPump::Execute
  1500.             DP_IN HRESULT hrError,                        // The errorcode from CreateAccessor; for Destination if pDestinationRow, else for Source.
  1501.             DP_IN LPCDTSTransformColumnInfo pSourceRow,    // Pointer to the source row and binding info.
  1502.             DP_IN const DBBINDSTATUS *pSourceDBBindStatus,        // Pointer to source binding status returns.
  1503.             DP_IN LPCDTSTransformColumnInfo pDestinationRow,    // Pointer to the destination row and binding info; NULL if from Source Binding error.
  1504.             DP_IN const DBBINDSTATUS *pDestinationDBBindStatus    // Pointer to destination binding status returns; NULL if from Source Binding error.
  1505.         ) PURE;
  1506.  
  1507.     // An error occurred during GetNextRows or GetData.
  1508.     STDMETHOD(OnSourceError)(THIS_ 
  1509.             DP_IN LPBYTE pvExecUserData,                // User data pointer passed to IDTSDataPump::Execute
  1510.             DP_IN LPDTSTransformColumnInfo pSourceRow,    // Pointer to the source row and binding info; NULL if GetNextRows or GetData failed.
  1511.             DP_IN HRESULT hrError,                        // The errorcode from the OLEDB or system call.
  1512.             DP_IN ULARGE_INTEGER uliRow,                // Number of the row failing.
  1513.             DP_IN ULONG cErrors,                        // Number of error rows encountered so far (including this one).
  1514.             DP_OUT BOOL *pbAbort                        // Set TRUE by Sink if this error should abort IDTSDataPump::Execute.
  1515.                                                         // Otherwise, Execute() continues until MaximumErrorRowCount is exceeded.
  1516.         ) PURE;
  1517.  
  1518.     // An error occurred on one or more Transforms.
  1519.     STDMETHOD(OnTransformError)(THIS_ 
  1520.             DP_IN LPBYTE pvExecUserData,                // User data pointer passed to IDTSDataPump::Execute
  1521.             DP_IN LPCOLESTR pwzName,                    // Transform name
  1522.             DP_IN LPBYTE pvTransformUserData,            // User data pointer passed to IDTSDataPump::AddTransform
  1523.                                                         // in LPCDTSTransformColumnsSpecification parameter.
  1524.             DP_IN IDTSDataPumpTransform *pTransformServer,    // The transform server raising the error; can be QI'd to custom interface for more info.
  1525.             DP_IN LPDTSTransformColumnInfo pSourceRow,    // Pointer to the source row and binding info.
  1526.             DP_IN DTSTransformStatus TransformStatus,    // Returned status code from the transformation.
  1527.             DP_IN HRESULT hrTransform,                    // The HRESULT returned from DTSDataPumpTransform::Execute.
  1528.             DP_IN ULARGE_INTEGER uliRow,                // Number of the row failing.
  1529.             DP_IN ULONG cErrors,                        // Number of error rows encountered so far (including this one).
  1530.             DP_OUT BOOL *pbAbort                        // Set TRUE by Sink if this error should abort IDTSDataPump::Execute.
  1531.                                                         // Otherwise, Execute() continues until MaximumErrorRowCount is exceeded.
  1532.         ) PURE;
  1533.  
  1534.     // An error occurred during InsertRow.
  1535.     STDMETHOD(OnDestinationError)(THIS_ 
  1536.             DP_IN LPBYTE pvExecUserData,                // User data pointer passed to IDTSDataPump::Execute
  1537.             DP_IN LPDTSTransformColumnInfo pSourceRow,    // Pointer to the source row.
  1538.             DP_IN LPDTSTransformColumnInfo pDestinationRow,    // Pointer to the destination row and binding info; NULL if prior to transform execution.
  1539.             DP_IN HRESULT hrError,                        // The errorcode from the OLEDB or system call.
  1540.             DP_IN ULARGE_INTEGER uliRow,                // Number of the row failing.
  1541.             DP_IN ULONG cErrors,                        // Number of error rows encountered so far (including this one).
  1542.             DP_OUT BOOL *pbAbort                        // Set TRUE by Sink if this error should abort IDTSDataPump::Execute.
  1543.                                                         // Otherwise, Execute() continues until MaximumErrorRowCount is exceeded.
  1544.         ) PURE;
  1545. };
  1546.  
  1547. ///////////////////////////////////////
  1548. // IDTSDataDrivenQuerySink - Specifies event sink for Data Driven Queries.
  1549. ///////////////////////////////////////
  1550.  
  1551. #undef INTERFACE
  1552. #define INTERFACE IDTSDataDrivenQuerySink
  1553. DECLARE_INTERFACE_(IDTSDataDrivenQuerySink, IUnknown)
  1554. {
  1555.     DTSDataPump_Unknown_Base()
  1556.  
  1557.     STDMETHOD(OnDDQBindingError)(THIS_ 
  1558.             DP_IN LPBYTE pvExecUserData,                // User data pointer passed to IDTSDataPump::Execute
  1559.             DP_IN DTSTransformStatus fQueryType,        // Insert, Update, Delete, or User Query.
  1560.             DP_IN HRESULT hrError,                        // The errorcode from CreateAccessor for Command parameters
  1561.             DP_IN LPCDTSTransformColumnInfo pDestinationRow,    // Pointer to the destination row and transform binding info
  1562.             DP_IN ULONG cParameterColumns,                // Number of parameter columns
  1563.             DP_IN const DBBINDING *pParameterDBBinding,    // Pointer to destination parameter bindings
  1564.             DP_IN const DBBINDSTATUS *pParameterDBBindStatus    // Pointer to destination parameter binding status returns
  1565.         ) PURE;
  1566.  
  1567.     STDMETHOD(OnDDQCommandError)(THIS_ 
  1568.             DP_IN LPBYTE pvExecUserData,                // User data pointer passed to IDTSDataPump::Execute
  1569.             DP_IN DTSTransformStatus fQueryType,        // Insert, Update, Delete, or User Query.
  1570.             DP_IN LPDTSTransformColumnInfo pSourceRow,    // Pointer to the source row.
  1571.             DP_IN LPDTSTransformColumnInfo pDestinationRow,    // Pointer to the destination row and binding info.
  1572.             DP_IN HRESULT hrError,                        // The errorcode from the OLEDB or system call.
  1573.             DP_IN ULARGE_INTEGER uliRow,                // Number of the row failing.
  1574.             DP_IN ULONG cErrors,                        // Number of error rows encountered so far (including this one).
  1575.             DP_OUT BOOL *pbAbort                        // Set TRUE by Sink if this error should abort IDTSDataPump::Execute.
  1576.                                                         // Otherwise, Execute() continues until MaximumErrorRowCount is exceeded.
  1577.         ) PURE;
  1578.  
  1579.     STDMETHOD(OnDDQCommandComplete)(THIS_ 
  1580.             DP_IN LPBYTE pvExecUserData,                // User data pointer passed to IDTSDataPump::Execute
  1581.             DP_IN DTSTransformStatus fQueryType,        // Insert, Update, Delete, or User Query.
  1582.             DP_IN LPDTSTransformColumnInfo pSourceRow,    // Pointer to the source row.
  1583.             DP_IN LPDTSTransformColumnInfo pDestinationRow,    // Pointer to the destination row and binding info.
  1584.             DP_IN LONG cDestinationRowsAffected,        // Rows affected by Command; -1 if provider unable to determine.
  1585.             DP_IN ULARGE_INTEGER uliRow                    // Number of the source row for which the Query was Execute()d.
  1586.         ) PURE;
  1587. };
  1588.  
  1589. ///////////////////////////////////////
  1590. // IDTSCustomTransformUI - 
  1591. // optional interface to be implemented by custom transform providers - used by DTS UI to configure the transforms
  1592. ///////////////////////////////////////
  1593.  
  1594. #undef INTERFACE
  1595. #define INTERFACE IDTSCustomTransformUI
  1596. DECLARE_INTERFACE_(IDTSCustomTransformUI, IUnknown)
  1597. {
  1598.     DTSDataPump_Unknown_Base()
  1599.  
  1600.     STDMETHOD(Initialize)(THIS_ DP_IN LPUNKNOWN pDTSPkgTransformObject) PURE;
  1601.     STDMETHOD(New)(THIS_ DP_IN long hwndParent) PURE;
  1602.     STDMETHOD(Edit)(THIS_ DP_IN long hwndParent) PURE;
  1603.     STDMETHOD(Delete)(THIS_ DP_IN long hwndParent) PURE;
  1604.     STDMETHOD(Help)(THIS_ DP_IN long hwndParent) PURE;
  1605. };
  1606.  
  1607. ///////////////////////////////////////
  1608. // IDTSDataPumpProgressSink - Progress indicator event sink.
  1609. ///////////////////////////////////////
  1610.  
  1611. #undef INTERFACE
  1612. #define INTERFACE IDTSDataPumpProgressSink
  1613. DECLARE_INTERFACE_(IDTSDataPumpProgressSink, IUnknown)
  1614. {
  1615.     DTSDataPump_Unknown_Base()
  1616.  
  1617.     STDMETHOD(OnIntervalComplete)(THIS_
  1618.             DP_IN LPBYTE pvExecUserData,                // User data pointer passed to IDTSDataPump::Execute
  1619.             DP_IN ULARGE_INTEGER uliRowsComplete,        // Total Source Rows processed at this interval (includes those skipped)
  1620.             DP_OUT BOOL *pbAbort                        // Set TRUE by Sink to abort IDTSDataPump::Execute.
  1621.         ) PURE;
  1622. };
  1623.  
  1624. /////////////////////////////////////////////////////////////////////////////////
  1625. // DTS Repository-support interfaces.
  1626. /////////////////////////////////////////////////////////////////////////////////
  1627.  
  1628. // Repository interfaces and definitions are shared between DTSDataPump and DTSPackage.
  1629.  
  1630. #ifdef OBJID_DtsTransformationTask
  1631.  
  1632. // A covering utility interface around a Repository object, provided by the DTS Package
  1633. // when requesting repository storage from a custom Task or Transformation.  This interface
  1634. // is passed to IDTSRepositoryStorage methods during DTSPackage.SaveToRepository.
  1635. #undef INTERFACE
  1636. #define INTERFACE IDTSRepositoryProvider
  1637. DECLARE_INTERFACE_(INTERFACE, IUnknown)
  1638. {
  1639.     DTSDataPump_Unknown_Base()
  1640.  
  1641.     // Return a reference to the Repository object.
  1642.     STDMETHOD(GetRepository)(THIS_
  1643.             DP_OUT IRepository **ppIRepository                // The repository object.
  1644.         ) PURE;
  1645.  
  1646.     // Creates an object and sets its name.
  1647.     STDMETHOD(CreateObject)(THIS_
  1648.             DP_IN LPCOLESTR wzObjidClass                    // Repository class to create
  1649.             , DP_IN LPCOLESTR wzObjidInstance                // class instance (object) id, or NULL
  1650.             , DP_IN LPCOLESTR wzInstanceName                // class instance (object) name, or NULL
  1651.             , DP_OUT IRepositoryObject **ppRepositoryObject    // created object
  1652.         ) PURE;
  1653.  
  1654.     // Finds an IDbmConnection object for a DTS connection in the associated DTS Package.
  1655.     STDMETHOD(FindConnection)(THIS_
  1656.             DP_IN LPCOLESTR wzName                            // DTSConnection.Name
  1657.             , DP_IN long lID                                // DTSConnection.ID
  1658.             , DP_OUT IRepositoryDispatch **ppIDbmConnection    // output object
  1659.         ) PURE;
  1660.  
  1661.     // When a custom Task or Transformation references a table or view, it should create a
  1662.     // relationship to that table or view if the appropriate datasource and catalog's metadata
  1663.     // has been scanned (by dbscanner) into the Repository.  To do so, the IDTSRepositoryStorage
  1664.     // implementation should call FindScannedObject, passing the name of the table or view
  1665.     // to be referenced.  Note that this name should be qualified as necessary to resolve
  1666.     // ambiguity, if multi-part names are supported by the connection provider.  This qualification
  1667.     // must be done according to DBPROP_CATALOGUSAGE and DBPROP_SCHEMAUSAGE, and the following
  1668.     // DBLITERALs:
  1669.     //        DBLITERAL_QUOTE_PREFIX
  1670.     //        DBLITERAL_QUOTE_SUFFIX
  1671.     //        DBLITERAL_CATALOG_SEPARATOR
  1672.     //        DBLITERAL_SCHEMA_SEPARATOR
  1673.     //
  1674.     // DTSPackage.SaveToRepository will search for a scanned catalog contained within any
  1675.     // IDbmDataSource with IsPublic TRUE.  A table or view resides in the repository as follows:
  1676.     //        Root(IUmlPackage).Elements
  1677.     //            ... possibly some intervening level of package or system...
  1678.     //            IDbmDataSource(IUmlPackage).Elements
  1679.     //                IDbmDeployedCatalog(IUmlPackage).Elements
  1680.     //                    IDbmSchema(IUmlPackage).Elements
  1681.     //                        IDbmDeployedTable, IDbmDeployedView
  1682.     // The catalog in which wzObjectName is resolved is determined by the first name found in
  1683.     // the following order:
  1684.     //        A catalog name parsed from wzObjectName
  1685.     //        DBPROP_CURRENTCATALOG after IDTSConnection.OpenConnection; this may be set by either of:
  1686.     //            IDTSConnection.DefaultCatalog
  1687.     //            IDTSConnection.ConnectionProperties(DBPROP_INIT_CATALOG)
  1688.     //        If DBPROP_CURRENTCATALOG is not supported, a placeholder catalog is 
  1689.     //            created by the scanner; this catalog is used to resolve scanned object references.
  1690.     //        
  1691.     // The schema in which wzObjectName is resolved is determined by the first name found in
  1692.     // the following order:
  1693.     //        A schema name parsed from wzObjectName
  1694.     //        IDTSConnection.UserID
  1695.     //        IDTSConnection.ConnectionProperties(DBPROP_AUTH_USERID)
  1696.     //
  1697.     // Because the connection's UserID may be simply a login id and different from the actual
  1698.     // object owner, wzObjectName should be qualified.  Only one schema will be searched for the
  1699.     // object; that schema is determined by:
  1700.     //        If a Schema-qualified wzObjectName is passed, that Schema is searched.
  1701.     //        Else if only one Schema is specified, it is searched.
  1702.     //        Else if a UserID is specified, it is used.
  1703.     //        Else EREP_OBJ_NOTFOUND.
  1704.     //
  1705.     // FindScannedObject returns the following, in order:
  1706.     //        If the call to DTSPackage.SaveToRepository specified that no scanner resolution be done,
  1707.     //        FindScannedObject returns NULL and S_FALSE.  In this case, AddUnscannedObject should be
  1708.     //        called, to create an DTSPackage-level object for AddTransformationUses to relate to.
  1709.     //
  1710.     //        If the provider does not support SchemaRowsets (necessary for scan), FindScannedObject
  1711.     //        returns NULL and S_FALSE.
  1712.     //
  1713.     //        If the catalog has not been scanned, or if the call to DTSPackage.SaveToRepository
  1714.     //        specified to rescan, then the catalog is scanned.  Any error from the dbscanner (such as
  1715.     //        the catalog not being found) is returned.
  1716.     //
  1717.     //        If wzObjectName is not found, EREP_OBJ_NOTFOUND is returned.
  1718.     //
  1719.     //        If wzObjectName is not found uniquely, such as an unqualified name appearing in more than
  1720.     //        one schema, EREP_OBJ_NOTFOUND is returned.
  1721.     //
  1722.     //        If wzObjectName is found uniquely, the IDbmDeployedTable or IDbmDeployedView is placed in
  1723.     //        ppIScannedObject and S_OK is returned.
  1724.     //
  1725.     // Note that FindScannedObject should not be called for an IDbmQuery object, as these are not
  1726.     // scanned into the repository as part of a Catalog; they are owned by the connection consumer.
  1727.     // IDbmQuery objects should be added via AddUnscannedObject.
  1728.     //
  1729.     // Generally a custom Task or Transformation will do the following (with most error handling omitted
  1730.     // for brevity):
  1731.     //    pIRepositoryProvider->CreateObject(OBJID_MyCustomTaskOrTransform
  1732.     //            , NULL
  1733.     //            , wzObjectName
  1734.     //            , &pICustomTaskOrTransform);
  1735.     //    if (referencing a table or view) {
  1736.     //        if FAILED(pIRepositoryProvider->FindScannedObject(<name>
  1737.     //            , IID_IRepositoryObject
  1738.     //            , pIDbmConnection
  1739.     //            , &pINewObject))
  1740.     //            return error;
  1741.     //    }
  1742.     //    if (NULL == pUnk) {
  1743.     //        pIRepositoryProvider->CreateObject(<parameters for the table, view, query, or other object>,
  1744.     //            , &pINewObject);
  1745.     //        pIRepositoryProvider->AddUnscannedObject(pIDbmConnection
  1746.     //            , pINewObject);
  1747.     //    }
  1748.     //    pIRepositoryProvider->AddTransformationUses(L"Source Table"
  1749.     //            , pICustomTaskOrTransform
  1750.     //            , pINewObject);
  1751.     //
  1752.     STDMETHOD(FindScannedObject)(THIS_
  1753.             DP_IN LPCOLESTR wzObjectName                    // Name of the object (may be qualified by catalog.schema.name)
  1754.             , DP_IN REFIID iidToGet                            // an IID the object must support; ignored if IID_NULL
  1755.             , DP_IN IRepositoryDispatch *pIDbmConnection    // Connection object (e.g. from FindConnection)
  1756.             , DP_OUT IRepositoryObject **ppIScannedObject    // returns scanned object or NULL on error.
  1757.         ) PURE;
  1758.  
  1759.     // This method adds an object to the repository as a way for AddTransformationUses to form a
  1760.     // relationship.  This object is not visible outside the scope of the saved DTSPackage.  pINewObject
  1761.     // is created (e.g. by CreateObject) and may be a table or view, or query, or a specialization (derived
  1762.     // class) of one, according to the following mapping:
  1763.     //        Object type        Must support        Added to
  1764.     //        -----------        ------------        ---------
  1765.     //        Query            ITfmQuery            ITfmTransformation(IUmlType).Members
  1766.     //                                            ITfmTransformationTask(IUmlType).Members
  1767.     //        Table            IDbmDeployedTable    Package-local DataSource/Catalog/Schema
  1768.     //        View            IDbmDeployedView    Package-local DataSource/Catalog/Schema
  1769.     //        other            IUmlMember            ITfmTransformation(IUmlType).Members
  1770.     //                                            ITfmTransformationTask(IUmlType).Members
  1771.     //
  1772.     STDMETHOD(AddUnscannedObject)(THIS_
  1773.             DP_IN IRepositoryDispatch *pIDbmConnection        // Connection object (e.g. from FindConnection)
  1774.             , DP_IN IRepositoryObject *pINewObject            // Task/Transform-created object.
  1775.         ) PURE;
  1776.  
  1777.     // This method creates a relationship between an ITfmTransformation or ITfmTransformationTask
  1778.     // and an IDbmColumnSet specialization (such as an IDbmDeployedTable, IDbmDeployedView, or ITfmQuery)
  1779.     // via the ITfmTransformationUses specialization of IUmlDependency, where
  1780.     //        ITfmTransformationUses(IUmlDependency).SourceElement = pITaskOrTransform
  1781.     //        ITfmTransformationUses(IUmlDependency).TargetElement = pINewObject
  1782.     //
  1783.     // Any dependencies added in this manner can be retrieved during LoadFromRepository by:
  1784.     //        pITaskOrTransform(IID_IUmlElement).TargetDependencies
  1785.     //
  1786.     STDMETHOD(AddTransformationUses)(THIS_
  1787.             DP_IN LPCOLESTR wzDependencyType                // A string describing the dependency; e.g., L"Source Table".
  1788.             , DP_IN IRepositoryObject *pITaskOrTransform    // Task/Transform-created object.
  1789.             , DP_IN IRepositoryObject *pINewObject            // Task/Transform-created object.
  1790.         ) PURE;
  1791.  
  1792.     // Creates a datatype object which maps the passed DBTYPE and other information to
  1793.     // its Repository equivalent, and creates and returns a matching object.
  1794.     STDMETHOD(CreateMappedDatatypeObject)(THIS_
  1795.             DP_IN DBTYPE dbType                                // The OLEDB datatype
  1796.             , DP_IN LONG lSize                                // Column size in characters (ignored if a fixed-length datatype)
  1797.             , DP_IN LONG lPrecision                            // Column precision if DECIMAL or NUMERIC
  1798.             , DP_IN LONG lScale                                // Column scale if DECIMAL or NUMERIC
  1799.             , DP_OUT IRepositoryObject **ppRepositoryObject    // output object
  1800.         ) PURE;
  1801.  
  1802.     // Gets information from a datatype object created by CreateMappedDataTypeObject.
  1803.     STDMETHOD(GetMappedDatatypeInfo)(THIS_
  1804.             DP_IN IRepositoryObject *pRepositoryObject        // input object
  1805.             , DP_OUT DBTYPE *pdbType                        // The OLEDB datatype
  1806.             , DP_OUT LONG *plSize                            // Column size in characters (ignored if a fixed-length datatype)
  1807.             , DP_OUT LONG *plPrecision                        // Column precision if DECIMAL or NUMERIC
  1808.             , DP_OUT LONG *plScale                            // Column scale if DECIMAL or NUMERIC
  1809.         ) PURE;
  1810. };
  1811.  
  1812. // If a custom task or custom transform server wants to manage its Repository persistence itself,
  1813. // it must implement IDTSRepositoryStorage.  Otherwise, the Package will simply enumerate the
  1814. // OleAutomation properties of the custom task/transform IDispatch and store all those which
  1815. // can be Set() as (Variant)TaggedValues of an IDtsCustomTask repository object.
  1816. #undef INTERFACE
  1817. #define INTERFACE IDTSRepositoryStorage
  1818. DECLARE_INTERFACE_(INTERFACE, IUnknown)
  1819. {
  1820.     DTSDataPump_Unknown_Base()
  1821.  
  1822.     // The implementation must create its own Repository object via pIRepositoryProvider->CreateObject,
  1823.     // and the returned ppIRepositoryObject must be fully populated and must support IDtsCustomTask
  1824.     // (if a custom DTSPackage Task) or IDts(Blob)Transformation (if a custom DTSPump Transform server).
  1825.     // After this method returns, the DTSPackage will set properties for Task Name via INamedObject::Name
  1826.     // and ServerID (the ProgID or string form of CLSID by which the custom task/transformation server is
  1827.     // CoCreateInstance()'d) and any other base-class values needed.  Custom objects should not set tagged
  1828.     // values in the base object classes, to avoid possible name conflicts.
  1829.     STDMETHOD(SaveToRepository)(THIS_
  1830.             DP_IN IDTSRepositoryProvider *pIRepositoryProvider
  1831.             , DP_OUT IRepositoryObject **ppIRepositoryObject
  1832.         ) PURE;
  1833.  
  1834.     // The implementation loads its own properties from this object.  If access to the IRepository
  1835.     // object is necessary, use pIRepositoryObject->get_Repository().
  1836.     STDMETHOD(LoadFromRepository)(THIS_
  1837.             DP_IN IDTSRepositoryProvider *pIRepositoryProvider
  1838.             , DP_IN IRepositoryObject *pIRepositoryObject
  1839.         ) PURE;
  1840. };
  1841.  
  1842. #endif // def OBJID_DtsTransformationTask
  1843.  
  1844. #endif // ndef DTSDataPump_VersionOnly
  1845.  
  1846. #endif // ndef DTSDataPump_ODL_
  1847.  
  1848. #pragma option pop /*P_O_Pop*/
  1849. #endif // DTSDataPump_H_
  1850.