1 files changed, 625 insertions, 0 deletions
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller/View.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller/View.cs
new file mode 100644
index 00000000..21e8543e
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller/View.cs
@@ -0,0 +1,625 @@
+// 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.
+namespace WixToolset.Dtf.WindowsInstaller
+{
+    using System;
+    using System.Text;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Diagnostics.CodeAnalysis;
+    /// <summary>
+    /// A View represents a result set obtained when processing a query using the
+    /// <see cref="WixToolset.Dtf.WindowsInstaller.Database.OpenView"/> method of a
+    /// <see cref="Database"/>. Before any data can be transferred,
+    /// the query must be executed using the <see cref="Execute(Record)"/> method, passing to
+    /// it all replaceable parameters designated within the SQL query string.
+    /// </summary>
+    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")]
+    public class View : InstallerHandle, IEnumerable<Record>
+    {
+        private Database database;
+        private string sql;
+        private IList<TableInfo> tables;
+        private ColumnCollection columns;
+        internal View(IntPtr handle, string sql, Database database)
+            : base(handle, true)
+        {
+            this.sql = sql;
+            this.database = database;
+        }
+        /// <summary>
+        /// Gets the Database on which this View was opened.
+        /// </summary>
+        public Database Database
+        {
+            get { return this.database; }
+        }
+        /// <summary>
+        /// Gets the SQL query string used to open this View.
+        /// </summary>
+        public string QueryString
+        {
+            get { return this.sql; }
+        }
+        /// <summary>
+        /// Gets the set of tables that were included in the SQL query for this View.
+        /// </summary>
+        public IList<TableInfo> Tables
+        {
+            get
+            {
+                if (this.tables == null)
+                {
+                    if (this.sql == null)
+                    {
+                        return null;
+                    }
+                    // Parse the table names out of the SQL query string by looking
+                    // for tokens that can come before or after the list of tables.
+                    string parseSql = this.sql.Replace('\t', ' ').Replace('\r', ' ').Replace('\n', ' ');
+                    string upperSql = parseSql.ToUpper(CultureInfo.InvariantCulture);
+                    string[] prefixes = new string[] { " FROM ", " INTO ", " TABLE " };
+                    string[] suffixes = new string[] { " WHERE ", " ORDER ", " SET ", " (", " ADD " };
+                    int index;
+                    for (int i = 0; i < prefixes.Length; i++)
+                    {
+                        if ((index = upperSql.IndexOf(prefixes[i], StringComparison.Ordinal)) > 0)
+                        {
+                            parseSql = parseSql.Substring(index + prefixes[i].Length);
+                            upperSql = upperSql.Substring(index + prefixes[i].Length);
+                        }
+                    }
+                    if (upperSql.StartsWith("UPDATE ", StringComparison.Ordinal))
+                    {
+                        parseSql = parseSql.Substring(7);
+                        upperSql = upperSql.Substring(7);
+                    }
+                    for (int i = 0; i < suffixes.Length; i++)
+                    {
+                        if ((index = upperSql.IndexOf(suffixes[i], StringComparison.Ordinal)) > 0)
+                        {
+                            parseSql = parseSql.Substring(0, index);
+                            upperSql = upperSql.Substring(0, index);
+                        }
+                    }
+                    if (upperSql.EndsWith(" HOLD", StringComparison.Ordinal) ||
+                        upperSql.EndsWith(" FREE", StringComparison.Ordinal))
+                    {
+                        parseSql = parseSql.Substring(0, parseSql.Length - 5);
+                        upperSql = upperSql.Substring(0, upperSql.Length - 5);
+                    }
+                    // At this point we should be left with a comma-separated list of table names,
+                    // optionally quoted with grave accent marks (`).
+                    string[] tableNames = parseSql.Split(',');
+                    IList<TableInfo> tableList = new List<TableInfo>(tableNames.Length);
+                    for (int i = 0; i < tableNames.Length; i++)
+                    {
+                        string tableName = tableNames[i].Trim(' ', '`');
+                        tableList.Add(new TableInfo(this.database, tableName));
+                    }
+                    this.tables = tableList;
+                }
+                return new List<TableInfo>(this.tables);
+            }
+        }
+        /// <summary>
+        /// Gets the set of columns that were included in the query for this View,
+        /// or null if this view is not a SELECT query.
+        /// </summary>
+        /// <exception cref="InstallerException">the View is not in an active state</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewgetcolumninfo.asp">MsiViewGetColumnInfo</a>
+        /// </p></remarks>
+        public ColumnCollection Columns
+        {
+            get
+            {
+                if (this.columns == null)
+                {
+                    this.columns = new ColumnCollection(this);
+                }
+                return this.columns;
+            }
+        }
+        /// <summary>
+        /// Executes a SQL View query and supplies any required parameters. The query uses the
+        /// question mark token to represent parameters as described in SQL Syntax. The values of
+        /// these parameters are passed in as the corresponding fields of a parameter record.
+        /// </summary>
+        /// <param name="executeParams">Optional Record that supplies the parameters. This
+        /// Record contains values to replace the parameter tokens in the SQL query.</param>
+        /// <exception cref="InstallerException">the View could not be executed</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewexecute.asp">MsiViewExecute</a>
+        /// </p></remarks>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Params"), SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters")]
+        public void Execute(Record executeParams)
+        {
+            uint ret = RemotableNativeMethods.MsiViewExecute(
+                (int) this.Handle,
+                (executeParams != null ? (int) executeParams.Handle : 0));
+            if (ret == (uint) NativeMethods.Error.BAD_QUERY_SYNTAX)
+            {
+                throw new BadQuerySyntaxException(this.sql);
+            }
+            else if (ret != 0)
+            {
+                throw InstallerException.ExceptionFromReturnCode(ret);
+            }
+        }
+        /// <summary>
+        /// Executes a SQL View query.
+        /// </summary>
+        /// <exception cref="InstallerException">the View could not be executed</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewexecute.asp">MsiViewExecute</a>
+        /// </p></remarks>
+        public void Execute() { this.Execute(null); }
+        /// <summary>
+        /// Fetches the next sequential record from the view, or null if there are no more records.
+        /// </summary>
+        /// <exception cref="InstallerException">the View is not in an active state</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// The Record object should be <see cref="InstallerHandle.Close"/>d after use.
+        /// It is best that the handle be closed manually as soon as it is no longer
+        /// needed, as leaving lots of unused handles open can degrade performance.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewfetch.asp">MsiViewFetch</a>
+        /// </p></remarks>
+        public Record Fetch()
+        {
+            int recordHandle;
+            uint ret = RemotableNativeMethods.MsiViewFetch((int) this.Handle, out recordHandle);
+            if (ret == (uint) NativeMethods.Error.NO_MORE_ITEMS)
+            {
+                return null;
+            }
+            else if (ret != 0)
+            {
+                throw InstallerException.ExceptionFromReturnCode(ret);
+            }
+            Record r = new Record((IntPtr) recordHandle, true, this);
+            r.IsFormatStringInvalid = true;
+            return r;
+        }
+        /// <summary>
+        /// Updates a fetched Record.
+        /// </summary>
+        /// <param name="mode">specifies the modify mode</param>
+        /// <param name="record">the Record to modify</param>
+        /// <exception cref="InstallerException">the modification failed,
+        /// or a validation was requested and the data did not pass</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// You can update or delete a record immediately after inserting, or seeking provided you
+        /// have NOT modified the 0th field of the inserted or sought record.
+        /// </p><p>
+        /// To execute any SQL statement, a View must be created. However, a View that does not
+        /// create a result set, such as CREATE TABLE, or INSERT INTO, cannot be used with any of
+        /// the Modify methods to update tables though the view.
+        /// </p><p>
+        /// You cannot fetch a record containing binary data from one database and then use
+        /// that record to insert the data into another database. To move binary data from one database
+        /// to another, you should export the data to a file and then import it into the new database
+        /// using a query and the <see cref="Record.SetStream(int,string)"/>. This ensures that each database has
+        /// its own copy of the binary data.
+        /// </p><p>
+        /// Note that custom actions can only add, modify, or remove temporary rows, columns,
+        /// or tables from a database. Custom actions cannot modify persistent data in a database,
+        /// such as data that is a part of the database stored on disk.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>
+        /// </p></remarks>
+        /// <seealso cref="Refresh"/>
+        /// <seealso cref="Insert"/>
+        /// <seealso cref="Update"/>
+        /// <seealso cref="Assign"/>
+        /// <seealso cref="Replace"/>
+        /// <seealso cref="Delete"/>
+        /// <seealso cref="InsertTemporary"/>
+        /// <seealso cref="Seek"/>
+        /// <seealso cref="Merge"/>
+        /// <seealso cref="Validate"/>
+        /// <seealso cref="ValidateNew"/>
+        /// <seealso cref="ValidateFields"/>
+        /// <seealso cref="ValidateDelete"/>
+        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters")]
+        public void Modify(ViewModifyMode mode, Record record)
+        {
+            if (record == null)
+            {
+                throw new ArgumentNullException("record");
+            }
+            uint ret = RemotableNativeMethods.MsiViewModify((int) this.Handle, (int) mode, (int) record.Handle);
+            if (mode == ViewModifyMode.Insert || mode == ViewModifyMode.InsertTemporary)
+            {
+                record.IsFormatStringInvalid = true;
+            }
+            if (ret != 0)
+            {
+                throw InstallerException.ExceptionFromReturnCode(ret);
+            }
+        }
+        /// <summary>
+        /// Refreshes the data in a Record.
+        /// </summary>
+        /// <param name="record">the Record to be refreshed</param>
+        /// <exception cref="InstallerException">the refresh failed</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// The Record must have been obtained by calling <see cref="Fetch"/>. Fails with
+        /// a deleted Record. Works only with read-write Records.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>
+        /// </p></remarks>
+        public void Refresh(Record record) { this.Modify(ViewModifyMode.Refresh, record); }
+        /// <summary>
+        /// Inserts a Record into the view.
+        /// </summary>
+        /// <param name="record">the Record to be inserted</param>
+        /// <exception cref="InstallerException">the insertion failed</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Fails if a row with the same primary keys exists. Fails with a read-only database.
+        /// This method cannot be used with a View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>
+        /// </p></remarks>
+        public void Insert(Record record) { this.Modify(ViewModifyMode.Insert, record); }
+        /// <summary>
+        /// Updates the View with new data from the Record.
+        /// </summary>
+        /// <param name="record">the new data</param>
+        /// <exception cref="InstallerException">the update failed</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Only non-primary keys can be updated. The Record must have been obtained by calling
+        /// <see cref="Fetch"/>. Fails with a deleted Record. Works only with read-write Records.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>
+        /// </p></remarks>
+        public void Update(Record record) { this.Modify(ViewModifyMode.Update, record); }
+        /// <summary>
+        /// Updates or inserts a Record into the View.
+        /// </summary>
+        /// <param name="record">the Record to be assigned</param>
+        /// <exception cref="InstallerException">the assignment failed</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Updates record if the primary keys match an existing row and inserts if they do not match.
+        /// Fails with a read-only database. This method cannot be used with a View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>
+        /// </p></remarks>
+        public void Assign(Record record) { this.Modify(ViewModifyMode.Assign, record); }
+        /// <summary>
+        /// Updates or deletes and inserts a Record into the View.
+        /// </summary>
+        /// <param name="record">the Record to be replaced</param>
+        /// <exception cref="InstallerException">the replacement failed</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// The Record must have been obtained by calling <see cref="Fetch"/>. Updates record if the
+        /// primary keys are unchanged. Deletes old row and inserts new if primary keys have changed.
+        /// Fails with a read-only database. This method cannot be used with a View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>
+        /// </p></remarks>
+        public void Replace(Record record) { this.Modify(ViewModifyMode.Replace, record); }
+        /// <summary>
+        /// Deletes a Record from the View.
+        /// </summary>
+        /// <param name="record">the Record to be deleted</param>
+        /// <exception cref="InstallerException">the deletion failed</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// The Record must have been obtained by calling <see cref="Fetch"/>. Fails if the row has been
+        /// deleted. Works only with read-write records. This method cannot be used with a View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>
+        /// </p></remarks>
+        public void Delete(Record record) { this.Modify(ViewModifyMode.Delete, record); }
+        /// <summary>
+        /// Inserts a Record into the View.  The inserted data is not persistent.
+        /// </summary>
+        /// <param name="record">the Record to be inserted</param>
+        /// <exception cref="InstallerException">the insertion failed</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Fails if a row with the same primary key exists. Works only with read-write records.
+        /// This method cannot be used with a View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>
+        /// </p></remarks>
+        public void InsertTemporary(Record record) { this.Modify(ViewModifyMode.InsertTemporary, record); }
+        /// <summary>
+        /// Refreshes the information in the supplied record without changing the position
+        /// in the result set and without affecting subsequent fetch operations.
+        /// </summary>
+        /// <param name="record">the Record to be filled with the result of the seek</param>
+        /// <exception cref="InstallerException">the seek failed</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// After seeking, the Record may then be used for subsequent Update, Delete, and Refresh
+        /// operations.  All primary key columns of the table must be in the query and the Record must
+        /// have at least as many fields as the query. Seek cannot be used with multi-table queries.
+        /// This method cannot be used with a View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>
+        /// </p></remarks>
+        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters")]
+        public bool Seek(Record record)
+        {
+            if (record == null)
+            {
+                throw new ArgumentNullException("record");
+            }
+            uint ret = RemotableNativeMethods.MsiViewModify((int) this.Handle, (int) ViewModifyMode.Seek, (int) record.Handle);
+            record.IsFormatStringInvalid = true;
+            if (ret == (uint) NativeMethods.Error.FUNCTION_FAILED)
+            {
+                return false;
+            }
+            else if (ret != 0)
+            {
+                throw InstallerException.ExceptionFromReturnCode(ret);
+            }
+            return true;
+        }
+        /// <summary>
+        /// Inserts or validates a record.
+        /// </summary>
+        /// <param name="record">the Record to be merged</param>
+        /// <returns>true if the record was inserted or validated, false if there is an existing
+        /// record with the same primary keys that is not identical</returns>
+        /// <exception cref="InstallerException">the merge failed (for a reason other than invalid data)</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Works only with read-write records. This method cannot be used with a
+        /// View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>
+        /// </p></remarks>
+        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters")]
+        public bool Merge(Record record)
+        {
+            if (record == null)
+            {
+                throw new ArgumentNullException("record");
+            }
+            uint ret = RemotableNativeMethods.MsiViewModify((int) this.Handle, (int) ViewModifyMode.Merge, (int) record.Handle);
+            if (ret == (uint) NativeMethods.Error.FUNCTION_FAILED)
+            {
+                return false;
+            }
+            else if (ret != 0)
+            {
+                throw InstallerException.ExceptionFromReturnCode(ret);
+            }
+            return true;
+        }
+        /// <summary>
+        /// Validates a record, returning information about any errors.
+        /// </summary>
+        /// <param name="record">the Record to be validated</param>
+        /// <returns>null if the record was validated; if there is an existing record with
+        /// the same primary keys that has conflicting data then error information is returned</returns>
+        /// <exception cref="InstallerException">the validation failed (for a reason other than invalid data)</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// The Record must have been obtained by calling <see cref="Fetch"/>.
+        /// Works with read-write and read-only records. This method cannot be used
+        /// with a View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI APIs:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>,
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewgeterror.asp">MsiViewGetError</a>
+        /// </p></remarks>
+        public ICollection<ValidationErrorInfo> Validate(Record record) { return this.InternalValidate(ViewModifyMode.Validate, record); }
+        /// <summary>
+        /// Validates a new record, returning information about any errors.
+        /// </summary>
+        /// <param name="record">the Record to be validated</param>
+        /// <returns>null if the record was validated; if there is an existing
+        /// record with the same primary keys then error information is returned</returns>
+        /// <exception cref="InstallerException">the validation failed (for a reason other than invalid data)</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Checks for duplicate keys. The Record must have been obtained by
+        /// calling <see cref="Fetch"/>. Works with read-write and read-only records.
+        /// This method cannot be used with a View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI APIs:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>,
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewgeterror.asp">MsiViewGetError</a>
+        /// </p></remarks>
+        [SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix")]
+        public ICollection<ValidationErrorInfo> ValidateNew(Record record) { return this.InternalValidate(ViewModifyMode.ValidateNew, record); }
+        /// <summary>
+        /// Validates fields of a fetched or new record, returning information about any errors.
+        /// Can validate one or more fields of an incomplete record.
+        /// </summary>
+        /// <param name="record">the Record to be validated</param>
+        /// <returns>null if the record was validated; if there is an existing record with
+        /// the same primary keys that has conflicting data then error information is returned</returns>
+        /// <exception cref="InstallerException">the validation failed (for a reason other than invalid data)</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Works with read-write and read-only records. This method cannot be used with
+        /// a View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI APIs:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>,
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewgeterror.asp">MsiViewGetError</a>
+        /// </p></remarks>
+        public ICollection<ValidationErrorInfo> ValidateFields(Record record) { return this.InternalValidate(ViewModifyMode.ValidateField, record); }
+        /// <summary>
+        /// Validates a record that will be deleted later, returning information about any errors.
+        /// </summary>
+        /// <param name="record">the Record to be validated</param>
+        /// <returns>null if the record is safe to delete; if another row refers to
+        /// the primary keys of this row then error information is returned</returns>
+        /// <exception cref="InstallerException">the validation failed (for a reason other than invalid data)</exception>
+        /// <exception cref="InvalidHandleException">the View handle is invalid</exception>
+        /// <remarks><p>
+        /// Validation does not check for the existence of the primary keys of this row in properties
+        /// or strings. Does not check if a column is a foreign key to multiple tables. Works with
+        /// read-write and read-only records. This method cannot be used with a View containing joins.
+        /// </p><p>
+        /// See <see cref="Modify"/> for more remarks.
+        /// </p><p>
+        /// Win32 MSI APIs:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewmodify.asp">MsiViewModify</a>,
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewgeterror.asp">MsiViewGetError</a>
+        /// </p></remarks>
+        public ICollection<ValidationErrorInfo> ValidateDelete(Record record) { return this.InternalValidate(ViewModifyMode.ValidateDelete, record); }
+        /// <summary>
+        /// Enumerates over the Records retrieved by the View.
+        /// </summary>
+        /// <returns>An enumerator of Record objects.</returns>
+        /// <exception cref="InstallerException">The View was not <see cref="Execute(Record)"/>d before attempting the enumeration.</exception>
+        /// <remarks><p>
+        /// Each Record object should be <see cref="InstallerHandle.Close"/>d after use.
+        /// It is best that the handle be closed manually as soon as it is no longer
+        /// needed, as leaving lots of unused handles open can degrade performance.
+        /// However, note that it is not necessary to complete the enumeration just
+        /// for the purpose of closing handles, because Records are fetched lazily
+        /// on each step of the enumeration.
+        /// </p><p>
+        /// Win32 MSI API:
+        /// <a href="http://msdn.microsoft.com/library/en-us/msi/setup/msiviewfetch.asp">MsiViewFetch</a>
+        /// </p></remarks>
+        public IEnumerator<Record> GetEnumerator()
+        {
+            Record rec;
+            while ((rec = this.Fetch()) != null)
+            {
+                yield return rec;
+            }
+        }
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+        private ICollection<ValidationErrorInfo> InternalValidate(ViewModifyMode mode, Record record)
+        {
+            uint ret = RemotableNativeMethods.MsiViewModify((int) this.Handle, (int) mode, (int) record.Handle);
+            if (ret == (uint) NativeMethods.Error.INVALID_DATA)
+            {
+                ICollection<ValidationErrorInfo> errorInfo = new List<ValidationErrorInfo>();
+                while (true)
+                {
+                    uint bufSize = 40;
+                    StringBuilder column = new StringBuilder("", (int) bufSize);
+                    int error = RemotableNativeMethods.MsiViewGetError((int) this.Handle, column, ref bufSize);
+                    if (error == -2 /*MSIDBERROR_MOREDATA*/)
+                    {
+                        column.Capacity = (int) ++bufSize;
+                        error = RemotableNativeMethods.MsiViewGetError((int) this.Handle, column, ref bufSize);
+                    }
+                    
+                    if (error == -3 /*MSIDBERROR_INVALIDARG*/)
+                    {
+                        throw InstallerException.ExceptionFromReturnCode((uint) NativeMethods.Error.INVALID_PARAMETER);
+                    }
+                    else if (error == 0 /*MSIDBERROR_NOERROR*/)
+                    {
+                        break;
+                    }
+                    errorInfo.Add(new ValidationErrorInfo((ValidationError) error, column.ToString()));
+                }
+                return errorInfo;
+            }
+            else if (ret != 0)
+            {
+                throw InstallerException.ExceptionFromReturnCode(ret);
+            }
+            return null;
+        }
+    }
+}