Merge wcautil

1 files changed, 717 insertions, 0 deletions

diff --git a/src/libs/wcautil/WixToolset.WcaUtil/wcawrapquery.cpp b/src/libs/wcautil/WixToolset.WcaUtil/wcawrapquery.cpp
new file mode 100644
index 00000000..a3b593fd
--- /dev/null
+++ b/src/libs/wcautil/WixToolset.WcaUtil/wcawrapquery.cpp
@@ -0,0 +1,717 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+#include "precomp.h"
+#include "wcawrapquery.h"
+
+static const LPWSTR ISINSTALLEDCOLUMNNAME = L"ISInstalled";
+static const LPWSTR ISACTIONCOLUMNNAME = L"ISAction";
+static const LPWSTR SOURCEPATHCOLUMNNAME = L"SourcePath";
+static const LPWSTR TARGETPATHCOLUMNNAME = L"TargetPath";
+
+// This instantiates a new query object in the deferred CA, and returns the handle to the query
+WCA_WRAPQUERY_HANDLE WIXAPI GetNewQueryInstance(
+    DWORD dwInColumns,
+    DWORD dwInRows
+    )
+{
+    HRESULT hr = S_OK;
+
+    WCA_WRAPQUERY_HANDLE hNewHandle = NULL;
+
+    hNewHandle = static_cast<WCA_WRAPQUERY_HANDLE>(MemAlloc(sizeof(WCA_WRAPQUERY_STRUCT), TRUE));
+    if (NULL == hNewHandle)
+    {
+        hr = E_OUTOFMEMORY;
+        ExitOnFailure(hr, "Failed to allocate Query Instance");
+    }
+
+    // Initialize non-array members
+    hNewHandle->dwColumns = dwInColumns;
+    hNewHandle->dwRows = dwInRows;
+    hNewHandle->dwNextIndex = 0;
+
+    // Initialize arrays
+    if (0 != hNewHandle->dwColumns)
+    {
+        hNewHandle->pcdtColumnType = static_cast<eColumnDataType *>(MemAlloc(hNewHandle->dwColumns * sizeof(eColumnDataType), TRUE));
+        if (NULL == hNewHandle->pcdtColumnType)
+        {
+            hr = E_OUTOFMEMORY;
+            ExitOnFailure(hr, "Failed to allocate column type array");
+        }
+
+        hNewHandle->ppwzColumnNames = static_cast<LPWSTR *>(MemAlloc(hNewHandle->dwColumns * sizeof(LPWSTR), TRUE));
+        if (NULL == hNewHandle->ppwzColumnNames)
+        {
+            hr = E_OUTOFMEMORY;
+            ExitOnFailure(hr, "Failed to allocate column names array");
+        }
+    }
+
+    for (DWORD i=0;i<hNewHandle->dwColumns;i++)
+    {
+        hNewHandle->pcdtColumnType[i] = cdtUnknown;
+        hNewHandle->ppwzColumnNames[i] = NULL;
+    }
+
+    if (0 != hNewHandle->dwRows)
+    {
+        hNewHandle->phRecords = static_cast<MSIHANDLE *>(MemAlloc(hNewHandle->dwRows * sizeof(MSIHANDLE), TRUE));
+        if (NULL == hNewHandle->phRecords)
+        {
+            hr = E_OUTOFMEMORY;
+            ExitOnFailure(hr, "Failed to allocate records array");
+        }
+    }
+
+    for (DWORD i=0;i<hNewHandle->dwRows;i++)
+    {
+        hNewHandle->phRecords[i] = NULL;
+    }
+
+    return hNewHandle;
+
+LExit:
+    // The handle isn't complete, so destroy any memory it allocated before returning NULL
+    if (NULL != hNewHandle)
+    {
+        WcaFinishUnwrapQuery(hNewHandle);
+    }
+
+    return NULL;
+}
+
+// This function takes in the column type string from MsiViewGetColumnInfo, and returns
+// whether the column stores strings, ints, binary streams, or
+// cdtUnknown if this information couldn't be determined.
+eColumnDataType WIXAPI GetDataTypeFromString(
+    LPCWSTR pwzTypeString
+    )
+{
+    if (!pwzTypeString || !*pwzTypeString)
+    {
+        return cdtUnknown;
+    }
+
+    switch (pwzTypeString[0])
+    {
+    case 'v':
+    case 'V':
+    case 'o':
+    case 'O':
+        return cdtStream;
+
+    case 'g':
+    case 'G':
+    case 's':
+    case 'S':
+    case 'l':
+    case 'L':
+        return cdtString;
+
+    case 'i':
+    case 'I':
+    case 'j':
+    case 'J':
+        return cdtInt;
+
+    default:
+        return cdtUnknown;
+    }
+}
+
+HRESULT WIXAPI WcaWrapEmptyQuery(
+    __inout LPWSTR * ppwzCustomActionData
+    )
+{
+    HRESULT hr = S_OK;
+
+    WcaLog(LOGMSG_TRACEONLY, "Wrapping result of empty query");
+
+    hr = WcaWriteIntegerToCaData(static_cast<int>(wqaTableBegin), ppwzCustomActionData);
+    ExitOnFailure(hr, "Failed to write table begin marker to custom action data");
+
+    hr = WcaWriteIntegerToCaData(0, ppwzCustomActionData);
+    ExitOnFailure(hr, "Failed to write number of columns to custom action data");
+
+    hr = WcaWriteIntegerToCaData(0, ppwzCustomActionData);
+    ExitOnFailure(hr, "Failed to write number of rows to custom action data");
+
+    hr = WcaWriteIntegerToCaData(static_cast<int>(wqaTableFinish), ppwzCustomActionData);
+    ExitOnFailure(hr, "Failed to write table finish marker to custom action data");
+
+//  WcaLog(LOGMSG_TRACEONLY, "Finished wrapping result of empty query");
+
+LExit:
+    return hr;
+}
+
+/********************************************************************
+WcaWrapQuery() - wraps a view and transmits it through the
+                CustomActionData property
+
+********************************************************************/
+HRESULT WIXAPI WcaWrapQuery(
+    __in_z LPCWSTR pwzQuery,
+    __inout LPWSTR * ppwzCustomActionData,
+    __in_opt DWORD dwFormatMask,
+    __in_opt DWORD dwComponentColumn,
+    __in_opt DWORD dwDirectoryColumn
+    )
+{
+    HRESULT hr = S_OK;
+    HRESULT hrTemp = S_OK;
+    UINT er = ERROR_SUCCESS;
+    UINT cViewColumns;
+    eColumnDataType *pcdtColumnTypeList = NULL;
+    LPWSTR pwzData = NULL;
+    LPWSTR pwzColumnData = NULL;
+    LPWSTR pwzRecordData = NULL;
+    BYTE* pbData = NULL;
+    DWORD dwNumRecords = 0;
+    BOOL fAddComponentState = FALSE; // Add two integer columns to the right side of the query - ISInstalled, and ISAction
+    BOOL fAddDirectoryPath = FALSE; // Add two string columns to the right side of the query - SourcePath, and TargetPath
+    int iTempInteger = 0;
+
+    WCHAR wzPath[MAX_PATH + 1];
+    DWORD dwLen;
+    INSTALLSTATE isInstalled = INSTALLSTATE_UNKNOWN;
+    INSTALLSTATE isAction = INSTALLSTATE_UNKNOWN;
+
+    PMSIHANDLE hColumnTypes, hColumnNames;
+    PMSIHANDLE hView, hRec;
+
+    WcaLog(LOGMSG_TRACEONLY, "Wrapping result of query: \"%ls\"", pwzQuery);
+
+    // open the view
+    hr = WcaOpenExecuteView(pwzQuery, &hView);
+    ExitOnFailure(hr, "Failed to execute view");
+
+    hr = WcaWriteIntegerToCaData(static_cast<int>(wqaTableBegin), ppwzCustomActionData);
+    ExitOnFailure(hr, "Failed to write table begin marker to custom action data");
+
+//  WcaLog(LOGMSG_TRACEONLY, "Starting to wrap table's column information", pwzQuery);
+
+    // Use GetColumnInfo to populate the names of the columns.
+    er = ::MsiViewGetColumnInfo(hView, MSICOLINFO_TYPES, &hColumnTypes);
+    ExitOnWin32Error(er, hr, "Failed to get column types");
+
+    er = ::MsiViewGetColumnInfo(hView, MSICOLINFO_NAMES, &hColumnNames);
+    ExitOnWin32Error(er, hr, "Failed to get column names");
+
+    cViewColumns = ::MsiRecordGetFieldCount(hColumnTypes);
+
+    if (0xFFFFFFFF == cViewColumns)
+    {
+        // According to MSDN, this return value only happens when the handle is invalid
+        hr = E_HANDLE;
+        ExitOnFailure(hr, "Failed to get number of fields in record");
+    }
+
+    if (cViewColumns >= dwComponentColumn)
+    {
+        fAddComponentState = TRUE;
+    }
+    else if (0xFFFFFFFF != dwComponentColumn)
+    {
+        hr = E_INVALIDARG;
+        ExitOnFailure(hr, "Component column %d out of range", dwComponentColumn);
+    }
+
+    if (cViewColumns >= dwDirectoryColumn)
+    {
+        fAddDirectoryPath = TRUE;
+    }
+    else if (0xFFFFFFFF != dwDirectoryColumn)
+    {
+        hr = E_INVALIDARG;
+        ExitOnFailure(hr, "Directory column %d out of range", dwDirectoryColumn);
+    }
+
+    hr = WcaWriteIntegerToCaData(static_cast<int>(cViewColumns) + 2 * static_cast<int>(fAddComponentState) + 2 * static_cast<int>(fAddDirectoryPath), ppwzCustomActionData);
+    ExitOnFailure(hr, "Failed to write number of columns to custom action data");
+
+    pcdtColumnTypeList = new eColumnDataType[cViewColumns];
+    ExitOnNull(pcdtColumnTypeList, hr, E_OUTOFMEMORY, "Failed to allocate memory to store column info types");
+
+    // Loop through all the columns reporting information about each one
+    for (DWORD i = 0; i < cViewColumns; i++)
+    {
+        hr = WcaGetRecordString(hColumnNames, i+1, &pwzData);
+        ExitOnFailure(hr, "Failed to get the column %d name", i+1);
+
+        hr = WcaWriteStringToCaData(pwzData, &pwzColumnData);
+        ExitOnFailure(hr, "Failed to write column %d name %ls to custom action data", i+1, pwzData);
+
+        hr = WcaGetRecordString(hColumnTypes, i+1, &pwzData);
+        ExitOnFailure(hr, "Failed to get the column type string for column %d", i+1);
+
+        pcdtColumnTypeList[i] = GetDataTypeFromString(pwzData);
+
+        if (cdtUnknown == pcdtColumnTypeList[i])
+        {
+            hr = E_INVALIDARG;
+            ExitOnFailure(hr, "Failed to recognize column %d type string: %ls", i+1, pwzData);
+        }
+
+        hr = WcaWriteIntegerToCaData(pcdtColumnTypeList[i], &pwzColumnData);
+        ExitOnFailure(hr, "Failed to write column %d type enumeration to custom action data", i+1);
+    }
+
+    // Add two integer columns to the right side of the query - ISInstalled, and ISAction
+    if (fAddComponentState)
+    {
+        hr = WcaWriteStringToCaData(ISINSTALLEDCOLUMNNAME, &pwzColumnData);
+        ExitOnFailure(hr, "Failed to write extra column %d name %ls to custom action data", cViewColumns + 1, ISINSTALLEDCOLUMNNAME);
+
+        hr = WcaWriteIntegerToCaData(cdtInt, &pwzColumnData);
+        ExitOnFailure(hr, "Failed to write extra column %d type to custom action data", cViewColumns + 1);
+
+        hr = WcaWriteStringToCaData(ISACTIONCOLUMNNAME, &pwzColumnData);
+        ExitOnFailure(hr, "Failed to write extra column %d name %ls to custom action data", cViewColumns + 1, ISACTIONCOLUMNNAME);
+
+        hr = WcaWriteIntegerToCaData(cdtInt, &pwzColumnData);
+        ExitOnFailure(hr, "Failed to write extra column %d type to custom action data", cViewColumns + 1);
+    }
+
+    if (fAddDirectoryPath)
+    {
+        hr = WcaWriteStringToCaData(SOURCEPATHCOLUMNNAME, &pwzColumnData);
+        ExitOnFailure(hr, "Failed to write extra column %d name %ls to custom action data", cViewColumns + 1, SOURCEPATHCOLUMNNAME);
+
+        hr = WcaWriteIntegerToCaData(cdtString, &pwzColumnData);
+        ExitOnFailure(hr, "Failed to write extra column %d type to custom action data", cViewColumns + 1);
+
+        hr = WcaWriteStringToCaData(TARGETPATHCOLUMNNAME, &pwzColumnData);
+        ExitOnFailure(hr, "Failed to write extra column %d name %ls to custom action data", cViewColumns + 1, TARGETPATHCOLUMNNAME);
+
+        hr = WcaWriteIntegerToCaData(cdtString, &pwzColumnData);
+        ExitOnFailure(hr, "Failed to write extra column %d type to custom action data", cViewColumns + 1);
+    }
+
+    // Begin wrapping actual table data
+    //WcaLog(LOGMSG_TRACEONLY, "Starting to wrap table data", pwzQuery);
+    while (S_OK == (hr = WcaFetchRecord(hView, &hRec)))
+    {
+        hr = WcaWriteIntegerToCaData(static_cast<int>(wqaRowBegin), &pwzRecordData);
+        ExitOnFailure(hr, "Failed to write row begin marker to custom action data");
+
+        for (DWORD i = 0; i < cViewColumns; i++)
+        {
+            switch (pcdtColumnTypeList[i])
+            {
+            case cdtString:
+                // If we were given a format mask, we're not past the index, and it's set to true for this column, then format the string
+                if (i < (sizeof(dwFormatMask) * 8) && (dwFormatMask & (1 << i)))
+                {
+                    hr = WcaGetRecordFormattedString(hRec, i + 1, &pwzData);
+                }
+                else
+                {
+                    hr = WcaGetRecordString(hRec, i + 1, &pwzData);
+                }
+                ExitOnFailure(hr, "Failed to get string for column %d", i + 1);
+
+                hr = WcaWriteStringToCaData(pwzData, &pwzRecordData);
+                ExitOnFailure(hr, "Failed to write string to temporary record custom action data for column %d", i + 1);
+                break;
+
+            case cdtInt:
+                if (i < (sizeof(dwFormatMask) * 8) && (dwFormatMask & (1 << i)))
+                {
+                    hr = WcaGetRecordFormattedInteger(hRec, i + 1, &iTempInteger);
+                }
+                else
+                {
+                    hr = WcaGetRecordInteger(hRec, i + 1, &iTempInteger);
+                }
+                ExitOnFailure(hr, "Failed to get integer for column %d", i + 1);
+
+                hr = WcaWriteIntegerToCaData(iTempInteger, &pwzRecordData);
+                ExitOnFailure(hr, "Failed to write integer to temporary record custom action data for column %d", i + 1);
+                break;
+
+            case cdtStream:
+                hr = E_NOTIMPL;
+                ExitOnFailure(hr, "A query was wrapped which contained a binary stream data field in column %d - however, the ability to wrap stream data fields is not implemented at this time", i);
+                break;
+
+            case cdtUnknown:
+            default:
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Failed to recognize column type enumeration %d for column %d", pcdtColumnTypeList[i], i + 1);
+            }
+        }
+
+        // Add two integer columns to the right side of the query - ISInstalled, and ISAction
+        if (fAddComponentState)
+        {
+            // Get the component ID
+            hr = WcaGetRecordString(hRec, dwComponentColumn, &pwzData);
+            ExitOnFailure(hr, "Failed to get component from column %d while adding extra columns", dwComponentColumn);
+
+            if (!pwzData || !*pwzData)
+            {
+                // If no component was provided, set these both to zero as though a structure to store them were allocated with memory zero'd out
+                isInstalled = (INSTALLSTATE)0;
+                isAction = (INSTALLSTATE)0;
+            }
+            else
+            {
+                er = ::MsiGetComponentStateW(WcaGetInstallHandle(), pwzData, &isInstalled, &isAction);
+                // If we don't get the component state, that may be because the component ID was invalid, but isn't necessarily an error, so write NULL's
+                if (FAILED(HRESULT_FROM_WIN32(er)))
+                {
+                    ExitOnFailure(hr, "Failed to get component state for component %ls", pwzData);
+                }
+            }
+
+            hr = WcaWriteIntegerToCaData(isInstalled, &pwzRecordData);
+            ExitOnFailure(hr, "Failed to write extra ISInstalled column to custom action data");
+
+            hr = WcaWriteIntegerToCaData(isAction, &pwzRecordData);
+            ExitOnFailure(hr, "Failed to write extra ISAction column to custom action data");
+        }
+
+        // Add two string columns to the right side of the query - SourcePath, and TargetPath
+        if (fAddDirectoryPath)
+        {
+            hr = WcaGetRecordString(hRec, dwDirectoryColumn, &pwzData);
+            // If this fails, ignore it, and just leave those columns blank
+            if (SUCCEEDED(hr))
+            {
+                // Only get source path if the component state is INSTALLSTATE_SOURCE, or if we have no component to check the installstate of
+                if (INSTALLSTATE_SOURCE == isAction || !fAddComponentState)
+                {
+                    dwLen = countof(wzPath);
+                    er = ::MsiGetSourcePathW(WcaGetInstallHandle(), pwzData, wzPath, &dwLen);
+                    hrTemp = HRESULT_FROM_WIN32(er);
+                    if (dwLen > countof(wzPath))
+                    {
+                        hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+                        ExitOnRootFailure(hr, "Failed to record entire Source Path for Directory %ls because its length was greater than MAX_PATH.", pwzData);
+                    }
+
+                    if (SUCCEEDED(hrTemp))
+                    {
+                        hr = WcaWriteStringToCaData(wzPath, &pwzRecordData);
+                        ExitOnFailure(hr, "Failed to write source path string to record data string");
+                    }
+                    else
+                    {
+                        hr = WcaWriteStringToCaData(L"", &pwzRecordData);
+                        ExitOnFailure(hr, "Failed to write empty source path string to record data string");
+                    }
+                }
+                else
+                {
+                    hr = WcaWriteStringToCaData(L"", &pwzRecordData);
+                    ExitOnFailure(hr, "Failed to write empty source path string before writing target path string to record data string");
+                }
+
+                dwLen = countof(wzPath);
+                er = ::MsiGetTargetPathW(WcaGetInstallHandle(), pwzData, wzPath, &dwLen);
+                hrTemp = HRESULT_FROM_WIN32(er);
+                if (dwLen > countof(wzPath))
+                {
+                    hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+                    ExitOnRootFailure(hr, "Failed to record entire Source Path for Directory %ls because its length was greater than MAX_PATH.", pwzData);
+                }
+                if (SUCCEEDED(hrTemp))
+                {
+                    hr = WcaWriteStringToCaData(wzPath, &pwzRecordData);
+                    ExitOnFailure(hr, "Failed to write target path string to record data string");
+                }
+                else
+                {
+                    hr = WcaWriteStringToCaData(L"", &pwzRecordData);
+                    ExitOnFailure(hr, "Failed to write empty target path string to record data string");
+                }
+            }
+            else
+            {
+                // Write both fields as blank
+                hr = WcaWriteStringToCaData(L"", &pwzRecordData);
+                hr = WcaWriteStringToCaData(L"", &pwzRecordData);
+            }
+        }
+
+        hr = WcaWriteIntegerToCaData(static_cast<int>(wqaRowFinish), &pwzRecordData);
+        ExitOnFailure(hr, "Failed to write row finish marker to custom action data");
+
+        ++dwNumRecords;
+    }
+
+    hr = WcaWriteIntegerToCaData(dwNumRecords, ppwzCustomActionData);
+    ExitOnFailure(hr, "Failed to write number of records to custom action data");
+
+    if (NULL != pwzColumnData)
+    {
+        hr = WcaWriteStringToCaData(pwzColumnData, ppwzCustomActionData);
+        ExitOnFailure(hr, "Failed to write column data to custom action data");
+    }
+
+    if (NULL != pwzRecordData)
+    {
+        hr = WcaWriteStringToCaData(pwzRecordData, ppwzCustomActionData);
+        ExitOnFailure(hr, "Failed to write record data to custom action data");
+    }
+
+    hr = WcaWriteIntegerToCaData(static_cast<int>(wqaTableFinish), ppwzCustomActionData);
+    ExitOnFailure(hr, "Failed to write table finish marker to custom action data");
+
+//  WcaLog(LOGMSG_TRACEONLY, "Finished wrapping result of query: \"%ls\"", pwzQuery);
+
+LExit:
+    ReleaseStr(pwzData);
+    ReleaseStr(pwzColumnData);
+    ReleaseStr(pwzRecordData);
+
+    ReleaseMem(pbData);
+
+    return hr;
+}
+
+
+/********************************************************************
+WcaBeginUnwrapQuery() - unwraps a view for direct access from the
+                        CustomActionData property
+
+********************************************************************/
+HRESULT WIXAPI WcaBeginUnwrapQuery(
+    __out WCA_WRAPQUERY_HANDLE * phWrapQuery,
+    __inout LPWSTR * ppwzCustomActionData
+    )
+{
+    HRESULT hr = S_OK;
+    int iTempInteger = 0;
+    int iColumns = 0;
+    int iRows = 0;
+    BYTE* pbData = NULL;
+    LPWSTR pwzData = NULL;
+    WCA_WRAPQUERY_HANDLE hWrapQuery = NULL;
+
+    WcaLog(LOGMSG_TRACEONLY, "Unwrapping a query from custom action data");
+
+    hr = WcaReadIntegerFromCaData(ppwzCustomActionData, &iTempInteger);
+    if (wqaTableBegin != iTempInteger)
+    {
+        hr = E_INVALIDARG;
+    }
+    ExitOnFailure(hr, "Failed to read table begin marker from custom action data (read %d instead)", iTempInteger);
+
+    hr = WcaReadIntegerFromCaData(ppwzCustomActionData, &iColumns);
+    ExitOnFailure(hr, "Failed to read number of columns from custom action data");
+
+    hr = WcaReadIntegerFromCaData(ppwzCustomActionData, &iRows);
+    ExitOnFailure(hr, "Failed to read number of rows from custom action data");
+
+    hWrapQuery = GetNewQueryInstance(iColumns, iRows);
+    if (NULL == hWrapQuery)
+    {
+        hr = E_POINTER;
+    }
+    ExitOnFailure(hr, "Failed to get a query instance with %d columns and %d rows", iColumns, iRows);
+
+    for (int i = 0; i < iColumns; i++)
+    {
+        hr = WcaReadStringFromCaData(ppwzCustomActionData, &(hWrapQuery->ppwzColumnNames[i]));
+        ExitOnFailure(hr, "Failed to read column %d's name from custom action data", i+1);
+
+        hr = WcaReadIntegerFromCaData(ppwzCustomActionData, &iTempInteger);
+        if (cdtString != iTempInteger && cdtInt != iTempInteger && cdtStream != iTempInteger)
+        {
+            hr = E_INVALIDARG;
+        }
+        ExitOnFailure(hr, "Failed to read column %d's type from custom action data", i+1);
+
+        // Set the column type into the actual data structure
+        hWrapQuery->pcdtColumnType[i] = (eColumnDataType)iTempInteger;
+    }
+
+    for (int i = 0; i < iRows; i++)
+    {
+        hr = WcaReadIntegerFromCaData(ppwzCustomActionData, &iTempInteger);
+        if (wqaRowBegin != iTempInteger)
+        {
+            hr = E_INVALIDARG;
+        }
+        ExitOnFailure(hr, "Failed to read begin row marker from custom action data (read %d instead)", iTempInteger);
+
+        hWrapQuery->phRecords[i] = ::MsiCreateRecord((unsigned int)iColumns);
+
+        for (int j = 0; j < iColumns; j++)
+        {
+            switch (hWrapQuery->pcdtColumnType[j])
+            {
+            case cdtString:
+                hr = WcaReadStringFromCaData(ppwzCustomActionData, &pwzData);
+                ExitOnFailure(hr, "Failed to read string from custom action data");
+
+                hr = WcaSetRecordString(hWrapQuery->phRecords[i], j+1, pwzData);
+                ExitOnFailure(hr, "Failed to write string %ls to record in column %d", pwzData, j+1);
+                break;
+
+            case cdtInt:
+                WcaReadIntegerFromCaData(ppwzCustomActionData, &iTempInteger);
+                ExitOnFailure(hr, "Failed to read integer from custom action data");
+
+                WcaSetRecordInteger(hWrapQuery->phRecords[i], j+1, iTempInteger);
+                ExitOnFailure(hr, "Failed to write integer %d to record in column %d", iTempInteger, j+1);
+                break;
+
+            case cdtStream:
+                hr = E_NOTIMPL;
+                ExitOnFailure(hr, "A query was wrapped which contained a stream data field - however, the ability to wrap stream data fields is not implemented at this time");
+                break;
+
+            case cdtUnknown:
+            default:
+                hr = E_INVALIDARG;
+                ExitOnFailure(hr, "Failed to recognize column type enumeration %d for column %d", hWrapQuery->pcdtColumnType[j+1], i+1);
+            }
+        }
+
+        hr = WcaReadIntegerFromCaData(ppwzCustomActionData, &iTempInteger);
+        if (wqaRowFinish != iTempInteger)
+        {
+            hr = E_INVALIDARG;
+        }
+        ExitOnFailure(hr, "Failed to read row finish marker from custom action data (read %d instead)", iTempInteger);
+    }
+
+    hr = WcaReadIntegerFromCaData(ppwzCustomActionData, &iTempInteger);
+    if (wqaTableFinish != iTempInteger)
+    {
+        hr = E_INVALIDARG;
+    }
+    ExitOnFailure(hr, "Failed to read table finish marker from custom action data (read %d instead)", iTempInteger);
+
+    *phWrapQuery = hWrapQuery;
+
+//  WcaLog(LOGMSG_TRACEONLY, "Successfully finished unwrapping a query from custom action data");
+
+LExit:
+    ReleaseStr(pwzData);
+    ReleaseMem(pbData);
+
+    return hr;
+}
+
+// This function returns the total number of records in a query
+DWORD WIXAPI WcaGetQueryRecords(
+    __in const WCA_WRAPQUERY_HANDLE hWrapQuery
+    )
+{
+    return hWrapQuery->dwRows;
+}
+
+// This function resets a query back to its first row, so that the next fetch returns the first record
+void WIXAPI WcaFetchWrappedReset(
+    __in WCA_WRAPQUERY_HANDLE hWrapQuery
+    )
+{
+    hWrapQuery->dwNextIndex = 0;
+}
+
+// Fetches the next record in the query
+// NOTE: the MSIHANDLE returned by this function should not be released, as it is the same handle used by the query object to maintain the item.
+//       so, don't use this function with PMSIHANDLE objects!
+HRESULT WIXAPI WcaFetchWrappedRecord(
+    __in WCA_WRAPQUERY_HANDLE hWrapQuery,
+    __out MSIHANDLE* phRec
+    )
+{
+    DWORD dwNextIndex = hWrapQuery->dwNextIndex;
+
+    if (dwNextIndex >= hWrapQuery->dwRows)
+    {
+        return E_NOMOREITEMS;
+    }
+
+    if (NULL == hWrapQuery->phRecords[dwNextIndex])
+    {
+        return E_HANDLE;
+    }
+
+    *phRec = hWrapQuery->phRecords[hWrapQuery->dwNextIndex];
+
+    // Increment our next index variable
+    ++hWrapQuery->dwNextIndex;
+
+    return S_OK;
+}
+
+// Fetch the next record in the query where the string value in column dwComparisonColumn equals the value pwzExpectedValue
+// NOTE: the MSIHANDLE returned by this function should not be released, as it is the same handle used by the query object to maintain the item.
+//       so, don't use this function with PMSIHANDLE objects!
+HRESULT WIXAPI WcaFetchWrappedRecordWhereString(
+    __in WCA_WRAPQUERY_HANDLE hWrapQuery,
+    __in DWORD dwComparisonColumn,
+    __in_z LPCWSTR pwzExpectedValue,
+    __out MSIHANDLE* phRec
+    )
+{
+    HRESULT hr = S_OK;
+    MSIHANDLE hRec = NULL;
+    LPWSTR pwzData = NULL;
+
+    while (S_OK == (hr = WcaFetchWrappedRecord(hWrapQuery, &hRec)))
+    {
+        ExitOnFailure(hr, "Failed to fetch a wrapped record");
+
+        hr = WcaGetRecordString(hRec, dwComparisonColumn, &pwzData);
+        ExitOnFailure(hr, "Failed to get record string in column %d", dwComparisonColumn);
+
+        if (0 == lstrcmpW(pwzData, pwzExpectedValue))
+        {
+            *phRec = hRec;
+            ExitFunction1(hr = S_OK);
+        }
+    }
+    // If we errored here but not because there were no records left, write an error to the log
+    if (hr != E_NOMOREITEMS)
+    {
+        ExitOnFailure(hr, "Failed while searching for a wrapped record where column %d is set to %ls", dwComparisonColumn, pwzExpectedValue);
+    }
+
+LExit:
+    ReleaseStr(pwzData);
+
+    return hr;
+}
+
+/********************************************************************
+WcaBeginUnwrapQuery() - Finishes unwrapping a view for direct access
+                        from the CustomActionData property
+
+********************************************************************/
+void WIXAPI WcaFinishUnwrapQuery(
+    __in_opt WCA_WRAPQUERY_HANDLE hWrapQuery
+    )
+{
+    if (NULL == hWrapQuery)
+    {
+        WcaLog(LOGMSG_TRACEONLY, "Failed to finish an unwrap query - ignoring");
+        return;
+    }
+
+    ReleaseMem(hWrapQuery->pcdtColumnType);
+
+    for (DWORD i=0;i<hWrapQuery->dwColumns;i++)
+    {
+        ReleaseStr(hWrapQuery->ppwzColumnNames[i]);
+    }
+    ReleaseMem(hWrapQuery->ppwzColumnNames);
+
+    for (DWORD i=0;i<hWrapQuery->dwRows;i++)
+    {
+        if (NULL != hWrapQuery->phRecords[i])
+        {
+            ::MsiCloseHandle(hWrapQuery->phRecords[i]);
+        }
+    }
+    ReleaseMem(hWrapQuery->phRecords);
+
+    ReleaseMem(hWrapQuery);
+}