Merge Dtf

8 files changed, 2240 insertions, 0 deletions

diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/AssemblyInfo.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/AssemblyInfo.cs
new file mode 100644
index 00000000..94abf1dc
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/AssemblyInfo.cs
@@ -0,0 +1,6 @@
+// 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.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Scope = "member", Target = "WixToolset.Dtf.WindowsInstaller.Linq.QTable`1.System.Linq.IQueryable<TRecord>.CreateQuery(System.Linq.Expressions.Expression):System.Linq.IQueryable`1<TElement>")]
+[assembly: SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Scope = "member", Target = "WixToolset.Dtf.WindowsInstaller.Linq.QTable`1.System.Linq.IQueryable<TRecord>.Execute(System.Linq.Expressions.Expression):TResult")]
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/Attributes.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/Attributes.cs
new file mode 100644
index 00000000..60008bc8
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/Attributes.cs
@@ -0,0 +1,60 @@
+// 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.Linq
+{
+    using System;
+
+    /// <summary>
+    /// Apply to a subclass of QRecord to indicate the name of
+    /// the table the record type is to be used with.
+    /// </summary>
+    /// <remarks>
+    /// If this attribute is not used on a record type, the default
+    /// table name will be derived from the record type name. (An
+    /// optional underscore suffix is stripped.)
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public class DatabaseTableAttribute : Attribute
+    {
+        /// <summary>
+        /// Creates a new DatabaseTableAttribute for the specified table.
+        /// </summary>
+        /// <param name="table">name of the table associated with the record type</param>
+        public DatabaseTableAttribute(string table)
+        {
+            this.Table = table;
+        }
+
+        /// <summary>
+        /// Gets or sets the table associated with the record type.
+        /// </summary>
+        public string Table { get; set; }
+    }
+
+    /// <summary>
+    /// Apply to a property on a subclass of QRecord to indicate
+    /// the name of the column the property is to be associated with.
+    /// </summary>
+    /// <remarks>
+    /// If this attribute is not used on a property, the default
+    /// column name will be the same as the property name.
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
+    public class DatabaseColumnAttribute : Attribute
+    {
+        /// <summary>
+        /// Creates a new DatabaseColumnAttribute which maps a
+        /// record property to a column.
+        /// </summary>
+        /// <param name="column">name of the column associated with the property</param>
+        public DatabaseColumnAttribute(string column)
+        {
+            this.Column = column;
+        }
+
+        /// <summary>
+        /// Gets or sets the column associated with the record property.
+        /// </summary>
+        public string Column { get; set; }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/Entities.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/Entities.cs
new file mode 100644
index 00000000..1c51b861
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/Entities.cs
@@ -0,0 +1,150 @@
+// 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.Linq.Entities
+{
+    // Silence warnings about style and doc-comments
+    #if !CODE_ANALYSIS
+    #pragma warning disable 1591
+    #region Generated code
+
+    public class Component_ : QRecord
+    {
+        public string Component   { get { return this[0]; } set { this[0] = value; } }
+        public string ComponentId { get { return this[1]; } set { this[1] = value; } }
+        public string Directory_  { get { return this[2]; } set { this[2] = value; } }
+        public string Condition   { get { return this[4]; } set { this[4] = value; } }
+        public string KeyPath     { get { return this[5]; } set { this[5] = value; } }
+        public ComponentAttributes Attributes
+        { get { return (ComponentAttributes) this.I(3); } set { this[3] = ((int) value).ToString(); } }
+    }
+
+    public class CreateFolder_ : QRecord
+    {
+        public string Directory_ { get { return this[0]; } set { this[0] = value; } }
+        public string Component_ { get { return this[1]; } set { this[1] = value; } }
+    }
+
+    public class CustomAction_ : QRecord
+    {
+        public string Action { get { return this[0]; } set { this[0] = value; } }
+        public string Source { get { return this[2]; } set { this[2] = value; } }
+        public string Target { get { return this[3]; } set { this[3] = value; } }
+        public CustomActionTypes Type
+        { get { return (CustomActionTypes) this.I(1); } set { this[1] = ((int) value).ToString(); } }
+    }
+
+    public class Directory_ : QRecord
+    {
+        public string Directory        { get { return this[0]; } set { this[0] = value; } }
+        public string Directory_Parent { get { return this[1]; } set { this[1] = value; } }
+        public string DefaultDir       { get { return this[2]; } set { this[2] = value; } }
+    }
+
+    public class DuplicateFile_ : QRecord
+    {
+        public string FileKey    { get { return this[0]; } set { this[0] = value; } }
+        public string Component_ { get { return this[1]; } set { this[1] = value; } }
+        public string File_      { get { return this[2]; } set { this[2] = value; } }
+        public string DestName   { get { return this[4]; } set { this[4] = value; } }
+        public string DestFolder { get { return this[5]; } set { this[5] = value; } }
+    }
+
+    public class Feature_ : QRecord
+    {
+        public string Feature        { get { return this[0];    } set { this[0] = value; } }
+        public string Feature_Parent { get { return this[1];    } set { this[1] = value; } }
+        public string Title          { get { return this[2];    } set { this[2] = value; } }
+        public string Description    { get { return this[3];    } set { this[3] = value; } }
+        public int?   Display        { get { return this.NI(4); } set { this[4] = value.ToString(); } }
+        public int    Level          { get { return this.I(5);  } set { this[5] = value.ToString(); } }
+        public string Directory_     { get { return this[6];    } set { this[6] = value; } }
+        public FeatureAttributes Attributes
+        { get { return (FeatureAttributes) this.I(7); } set { this[7] = ((int) value).ToString(); } }
+    }
+
+    [DatabaseTable("FeatureComponents")]
+    public class FeatureComponent_ : QRecord
+    {
+        public string Feature_   { get { return this[0]; } set { this[0] = value; } }
+        public string Component_ { get { return this[1]; } set { this[1] = value; } }
+    }
+
+    public class File_ : QRecord
+    {
+        public string File       { get { return this[0];   } set { this[0] = value; } }
+        public string Component_ { get { return this[1];   } set { this[1] = value; } }
+        public string FileName   { get { return this[2];   } set { this[2] = value; } }
+        public int    FileSize   { get { return this.I(3); } set { this[3] = value.ToString(); } }
+        public string Version    { get { return this[4];   } set { this[4] = value; } }
+        public string Language   { get { return this[5];   } set { this[5] = value; } }
+        public int    Sequence   { get { return this.I(7); } set { this[7] = value.ToString(); } }
+        public FileAttributes Attributes
+        { get { return (FileAttributes) this.I(6); } set { this[6] = ((int) value).ToString(); } }
+    }
+
+    [DatabaseTable("MsiFileHash")]
+    public class FileHash_ : QRecord
+    {
+        public string File_     { get { return this[0];   } set { this[0] = value; } }
+        public int    Options   { get { return this.I(1); } set { this[1] = value.ToString(); } }
+        public int    HashPart1 { get { return this.I(2); } set { this[2] = value.ToString(); } }
+        public int    HashPart2 { get { return this.I(3); } set { this[3] = value.ToString(); } }
+        public int    HashPart3 { get { return this.I(4); } set { this[4] = value.ToString(); } }
+        public int    HashPart4 { get { return this.I(5); } set { this[5] = value.ToString(); } }
+    }
+
+    [DatabaseTable("InstallExecuteSequence")]
+    public class InstallSequence_ : QRecord
+    {
+        public string Action    { get { return this[0];   } set { this[0] = value; } }
+        public string Condition { get { return this[1];   } set { this[1] = value; } }
+        public int    Sequence  { get { return this.I(2); } set { this[2] = value.ToString(); } }
+    }
+
+    public class LaunchCondition_ : QRecord
+    {
+        public string Condition   { get { return this[0]; } set { this[0] = value; } }
+        public string Description { get { return this[1]; } set { this[1] = value; } }
+    }
+
+    public class Media_ : QRecord
+    {
+        public int    DiskId       { get { return this.I(0); } set { this[0] = value.ToString(); } }
+        public int    LastSequence { get { return this.I(1); } set { this[1] = value.ToString(); } }
+        public string DiskPrompt   { get { return this[2];   } set { this[2] = value; } }
+        public string Cabinet      { get { return this[3];   } set { this[3] = value; } }
+        public string VolumeLabel  { get { return this[4];   } set { this[4] = value; } }
+        public string Source       { get { return this[5];   } set { this[5] = value; } }
+    }
+
+    public class Property_ : QRecord
+    {
+        public string Property { get { return this[0]; } set { this[0] = value; } }
+        public string Value    { get { return this[1]; } set { this[1] = value; } }
+    }
+
+    public class Registry_ : QRecord
+    {
+        public string Registry   { get { return this[0]; } set { this[0] = value; } }
+        public string Key        { get { return this[2]; } set { this[2] = value; } }
+        public string Name       { get { return this[3]; } set { this[3] = value; } }
+        public string Value      { get { return this[4]; } set { this[4] = value; } }
+        public string Component_ { get { return this[5]; } set { this[5] = value; } }
+        public RegistryRoot Root
+        { get { return (RegistryRoot) this.I(1); } set { this[0] = ((int) value).ToString(); } }
+    }
+
+    public class RemoveFile_ : QRecord
+    {
+        public string FileKey     { get { return this[0]; } set { this[0] = value; } }
+        public string Component_  { get { return this[2]; } set { this[2] = value; } }
+        public string FileName    { get { return this[3]; } set { this[3] = value; } }
+        public string DirProperty { get { return this[4]; } set { this[4] = value; } }
+        public RemoveFileModes InstallMode
+        { get { return (RemoveFileModes) this.I(5); } set { this[5] = ((int) value).ToString(); } }
+    }
+
+    #endregion // Generated code
+    #pragma warning restore 1591
+    #endif // !CODE_ANALYSIS
+}
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/QDatabase.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/QDatabase.cs
new file mode 100644
index 00000000..b4de2f60
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/QDatabase.cs
@@ -0,0 +1,214 @@
+// 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.Linq
+{
+    using System;
+    using System.IO;
+    using WixToolset.Dtf.WindowsInstaller.Linq.Entities;
+
+    /// <summary>
+    /// Allows any Database instance to be converted into a queryable database.
+    /// </summary>
+    public static class Queryable
+    {
+        /// <summary>
+        /// Converts any Database instance into a queryable database.
+        /// </summary>
+        /// <param name="db"></param>
+        /// <returns>Queryable database instance that operates on the same
+        /// MSI handle.</returns>
+        /// <remarks>
+        /// This extension method is meant for convenient on-the-fly conversion.
+        /// If the existing database instance already happens to be a QDatabase,
+        /// then it is returned unchanged. Otherwise since the new database
+        /// carries the same MSI handle, only one of the instances needs to be
+        /// closed, not both.
+        /// </remarks>
+        public static QDatabase AsQueryable(this Database db)
+        {
+            QDatabase qdb = db as QDatabase;
+            if (qdb == null && db != null)
+            {
+                qdb = new QDatabase(db.Handle, true, db.FilePath, db.OpenMode);
+            }
+            return qdb;
+        }
+    }
+
+    /// <summary>
+    /// Queryable MSI database - extends the base Database class with
+    /// LINQ query functionality along with predefined entity types
+    /// for common tables.
+    /// </summary>
+    public class QDatabase : Database
+    {
+        /// <summary>
+        /// Opens an existing database in read-only mode.
+        /// </summary>
+        /// <param name="filePath">Path to the database file.</param>
+        /// <exception cref="InstallerException">the database could not be created/opened</exception>
+        /// <remarks>
+        /// Because this constructor initiates database access, it cannot be used with a
+        /// running installation.
+        /// <para>The Database object should be <see cref="InstallerHandle.Close"/>d after use.
+        /// The finalizer will close the handle if it is still open, however due to the nondeterministic
+        /// nature of finalization 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.</para>
+        /// </remarks>
+        public QDatabase(string filePath)
+            : base(filePath)
+        {
+        }
+
+        /// <summary>
+        /// Opens an existing database with another database as output.
+        /// </summary>
+        /// <param name="filePath">Path to the database to be read.</param>
+        /// <param name="outputPath">Open mode for the database</param>
+        /// <returns>Database object representing the created or opened database</returns>
+        /// <exception cref="InstallerException">the database could not be created/opened</exception>
+        /// <remarks>
+        /// When a database is opened as the output of another database, the summary information stream
+        /// of the output database is actually a read-only mirror of the original database and thus cannot
+        /// be changed. Additionally, it is not persisted with the database. To create or modify the
+        /// summary information for the output database it must be closed and re-opened.
+        /// <para>The returned Database object should be <see cref="InstallerHandle.Close"/>d after use.
+        /// The finalizer will close the handle if it is still open, however due to the nondeterministic
+        /// nature of finalization 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.</para>
+        /// </remarks>
+        public QDatabase(string filePath, string outputPath)
+            : base(filePath, outputPath)
+        {
+        }
+
+        /// <summary>
+        /// Opens an existing database or creates a new one.
+        /// </summary>
+        /// <param name="filePath">Path to the database file. If an empty string
+        /// is supplied, a temporary database is created that is not persisted.</param>
+        /// <param name="mode">Open mode for the database</param>
+        /// <exception cref="InstallerException">the database could not be created/opened</exception>
+        /// <remarks>
+        /// To make and save changes to a database first open the database in transaction,
+        /// create or, or direct mode. After making the changes, always call the Commit method
+        /// before closing the database handle. The Commit method flushes all buffers.
+        /// <para>Always call the Commit method on a database that has been opened in direct
+        /// mode before closing the database. Failure to do this may corrupt the database.</para>
+        /// <para>Because this constructor initiates database access, it cannot be used with a
+        /// running installation.</para>
+        /// <para>The Database object should be <see cref="InstallerHandle.Close"/>d after use.
+        /// The finalizer will close the handle if it is still open, however due to the nondeterministic
+        /// nature of finalization 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.</para>
+        /// </remarks>
+        public QDatabase(string filePath, DatabaseOpenMode mode)
+            : base(filePath, mode)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new database from an MSI handle.
+        /// </summary>
+        /// <param name="handle">Native MSI database handle.</param>
+        /// <param name="ownsHandle">True if the handle should be closed
+        /// when the database object is disposed</param>
+        /// <param name="filePath">Path of the database file, if known</param>
+        /// <param name="openMode">Mode the handle was originally opened in</param>
+        protected internal QDatabase(
+            IntPtr handle, bool ownsHandle, string filePath, DatabaseOpenMode openMode)
+            : base(handle, ownsHandle, filePath, openMode)
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets a log where all MSI SQL queries are written.
+        /// </summary>
+        /// <remarks>
+        /// The log can be useful for debugging, or simply to watch the LINQ magic in action.
+        /// </remarks>
+        public TextWriter Log { get; set; }
+
+        /// <summary>
+        /// Gets a queryable table from the datbaase.
+        /// </summary>
+        /// <param name="table">name of the table</param>
+        public QTable<QRecord> this[string table]
+        {
+            get
+            {
+                return new QTable<QRecord>(this, table);
+            }
+        }
+
+        #if !CODE_ANALYSIS
+        #region Queryable tables
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<Component_> Components
+        { get { return new QTable<Component_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<CreateFolder_> CreateFolders
+        { get { return new QTable<CreateFolder_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<CustomAction_> CustomActions
+        { get { return new QTable<CustomAction_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<Directory_> Directories
+        { get { return new QTable<Directory_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<DuplicateFile_> DuplicateFiles
+        { get { return new QTable<DuplicateFile_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<Feature_> Features
+        { get { return new QTable<Feature_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<FeatureComponent_> FeatureComponents
+        { get { return new QTable<FeatureComponent_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<File_> Files
+        { get { return new QTable<File_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<FileHash_> FileHashes
+        { get { return new QTable<FileHash_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<InstallSequence_> InstallExecuteSequences
+        { get { return new QTable<InstallSequence_>(this, "InstallExecuteSequence"); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<InstallSequence_> InstallUISequences
+        { get { return new QTable<InstallSequence_>(this, "InstallUISequence"); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<LaunchCondition_> LaunchConditions
+        { get { return new QTable<LaunchCondition_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<Media_> Medias
+        { get { return new QTable<Media_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<Property_> Properties
+        { get { return new QTable<Property_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<Registry_> Registries
+        { get { return new QTable<Registry_>(this); } }
+
+        /// <summary>Queryable standard table with predefined specialized record type.</summary>
+        public QTable<RemoveFile_> RemoveFiles
+        { get { return new QTable<RemoveFile_>(this); } }
+
+        #endregion // Queryable tables
+        #endif // !CODE_ANALYSIS
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/QRecord.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/QRecord.cs
new file mode 100644
index 00000000..4b3145fd
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/QRecord.cs
@@ -0,0 +1,501 @@
+// 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.Linq
+{
+    using System;
+    using System.IO;
+    using System.Text;
+    using System.Globalization;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Generic record entity for queryable databases,
+    /// and base for strongly-typed entity subclasses.
+    /// </summary>
+    /// <remarks>
+    /// Several predefined specialized subclasses are provided for common
+    /// standard tables. Subclasses for additional standard tables
+    /// or custom tables are not necessary, but they are easy to create
+    /// and make the coding experience much nicer.
+    /// <para>When creating subclasses, the following attributes may be
+    /// useful: <see cref="DatabaseTableAttribute"/>,
+    /// <see cref="DatabaseColumnAttribute"/></para>
+    /// </remarks>
+    public class QRecord
+    {
+        /// <summary>
+        /// Do not call. Use QTable.NewRecord() instead.
+        /// </summary>
+        /// <remarks>
+        /// Subclasses must also provide a public parameterless constructor.
+        /// <para>QRecord constructors are only public due to implementation
+        /// reasons (to satisfy the new() constraint on the QTable generic
+        /// class). They are not intended to be called by user code other than
+        /// a subclass constructor. If the constructor is invoked directly,
+        /// the record instance will not be properly initialized (associated
+        /// with a database table) and calls to methods on the instance
+        /// will throw a NullReferenceException.</para>
+        /// </remarks>
+        /// <seealso cref="QTable&lt;TRecord&gt;.NewRecord()"/>
+        public QRecord()
+        {
+        }
+
+        internal QDatabase Database { get; set; }
+
+        internal TableInfo TableInfo { get; set; }
+
+        internal IList<string> Values { get; set; }
+
+        internal bool Exists { get; set; }
+
+        /// <summary>
+        /// Gets the number of fields in the record.
+        /// </summary>
+        public int FieldCount
+        {
+            get
+            {
+                return this.Values.Count;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a record field.
+        /// </summary>
+        /// <param name="field">column name of the field</param>
+        /// <remarks>
+        /// Setting a field value will automatically update the database.
+        /// </remarks>
+        public string this[string field]
+        {
+            get
+            {
+                if (field == null)
+                {
+                    throw new ArgumentNullException("field");
+                }
+
+                int index = this.TableInfo.Columns.IndexOf(field);
+                if (index < 0)
+                {
+                    throw new ArgumentOutOfRangeException("field");
+                }
+
+                return this[index];
+            }
+
+            set
+            {
+                if (field == null)
+                {
+                    throw new ArgumentNullException("field");
+                }
+
+                this.Update(new string[] { field }, new string[] { value });
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a record field.
+        /// </summary>
+        /// <param name="index">zero-based column index of the field</param>
+        /// <remarks>
+        /// Setting a field value will automatically update the database.
+        /// </remarks>
+        public string this[int index]
+        {
+            get
+            {
+                if (index < 0 || index >= this.FieldCount)
+                {
+                    throw new ArgumentOutOfRangeException("index");
+                }
+
+                return this.Values[index];
+            }
+
+            set
+            {
+                if (index < 0 || index >= this.FieldCount)
+                {
+                    throw new ArgumentOutOfRangeException("index");
+                }
+
+                this.Update(new int[] { index }, new string[] { value });
+            }
+        }
+
+        /// <summary>
+        /// Used by subclasses to get a field as an integer.
+        /// </summary>
+        /// <param name="index">zero-based column index of the field</param>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "I")]
+        protected int I(int index)
+        {
+            string value = this[index];
+            return value.Length > 0 ?
+                Int32.Parse(value, CultureInfo.InvariantCulture) : 0;
+        }
+
+        /// <summary>
+        /// Used by subclasses to get a field as a nullable integer.
+        /// </summary>
+        /// <param name="index">zero-based column index of the field</param>
+        protected int? NI(int index)
+        {
+            string value = this[index];
+            return value.Length > 0 ?
+                new int?(Int32.Parse(value, CultureInfo.InvariantCulture)) : null;
+        }
+
+        /// <summary>
+        /// Dumps all record fields to a string.
+        /// </summary>
+        public override string ToString()
+        {
+            StringBuilder buf = new StringBuilder(this.GetType().Name);
+            buf.Append(" {");
+            for (int i = 0; i < this.FieldCount; i++)
+            {
+                buf.AppendFormat("{0} {1} = {2}",
+                    (i > 0 ? "," : String.Empty),
+                    this.TableInfo.Columns[i].Name,
+                    this[i]);
+            }
+            buf.Append(" }");
+            return buf.ToString();
+        }
+
+        /// <summary>
+        /// Update multiple fields in the record (and the database).
+        /// </summary>
+        /// <param name="fields">column names of fields to update</param>
+        /// <param name="values">new values for each field being updated</param>
+        public void Update(IList<string> fields, IList<string> values)
+        {
+            if (fields == null)
+            {
+                throw new ArgumentNullException("fields");
+            }
+
+            if (values == null)
+            {
+                throw new ArgumentNullException("values");
+            }
+
+            if (fields.Count == 0 || values.Count == 0 ||
+                fields.Count > this.FieldCount ||
+                values.Count != fields.Count)
+            {
+                throw new ArgumentOutOfRangeException("fields");
+            }
+
+            int[] indexes = new int[fields.Count];
+            for (int i = 0; i < indexes.Length; i++)
+            {
+                if (fields[i] == null)
+                {
+                    throw new ArgumentNullException("fields[" + i + "]");
+                }
+
+                indexes[i] = this.TableInfo.Columns.IndexOf(fields[i]);
+
+                if (indexes[i] < 0)
+                {
+                    throw new ArgumentOutOfRangeException("fields[" + i + "]");
+                }
+            }
+
+            this.Update(indexes, values);
+        }
+
+        /// <summary>
+        /// Update multiple fields in the record (and the database).
+        /// </summary>
+        /// <param name="indexes">column indexes of fields to update</param>
+        /// <param name="values">new values for each field being updated</param>
+        /// <remarks>
+        /// The record (primary keys) must already exist in the table.
+        /// <para>Updating primary key fields is not yet implemented; use Delete()
+        /// and Insert() instead.</para>
+        /// </remarks>
+        public void Update(IList<int> indexes, IList<string> values)
+        {
+            if (indexes == null)
+            {
+                throw new ArgumentNullException("indexes");
+            }
+
+            if (values == null)
+            {
+                throw new ArgumentNullException("values");
+            }
+
+            if (indexes.Count == 0 || values.Count == 0 ||
+                indexes.Count > this.FieldCount ||
+                values.Count != indexes.Count)
+            {
+                throw new ArgumentOutOfRangeException("indexes");
+            }
+
+            bool primaryKeyChanged = false;
+            for (int i = 0; i < indexes.Count; i++)
+            {
+                int index = indexes[i];
+                if (index < 0 || index >= this.FieldCount)
+                {
+                    throw new ArgumentOutOfRangeException("index[" + i + "]");
+                }
+
+                ColumnInfo col = this.TableInfo.Columns[index];
+                if (this.TableInfo.PrimaryKeys.Contains(col.Name))
+                {
+                    if (values[i] == null)
+                    {
+                        throw new ArgumentNullException("values[" + i + "]");
+                    }
+
+                    primaryKeyChanged = true;
+                }
+                else if (values[i] == null)
+                {
+                    if (col.IsRequired)
+                    {
+                        throw new ArgumentNullException("values[" + i + "]");
+                    }
+                }
+
+                this.Values[index] = values[i];
+            }
+
+            if (this.Exists)
+            {
+                if (!primaryKeyChanged)
+                {
+                    int updateRecSize = indexes.Count + this.TableInfo.PrimaryKeys.Count;
+                    using (Record updateRec = this.Database.CreateRecord(updateRecSize))
+                    {
+                        StringBuilder s = new StringBuilder("UPDATE `");
+                        s.Append(this.TableInfo.Name);
+                        s.Append("` SET");
+
+                        for (int i = 0; i < indexes.Count; i++)
+                        {
+                            ColumnInfo col = this.TableInfo.Columns[indexes[i]];
+                            if (col.Type == typeof(Stream))
+                            {
+                                throw new NotSupportedException(
+                                    "Cannot update stream columns via QRecord.");
+                            }
+
+                            int index = indexes[i];
+                            s.AppendFormat("{0} `{1}` = ?",
+                                (i > 0 ? "," : String.Empty),
+                                col.Name);
+
+                            if (values[i] != null)
+                            {
+                                updateRec[i + 1] = values[i];
+                            }
+                        }
+
+                        for (int i = 0; i < this.TableInfo.PrimaryKeys.Count; i++)
+                        {
+                            string key = this.TableInfo.PrimaryKeys[i];
+                            s.AppendFormat(" {0} `{1}` = ?", (i == 0 ? "WHERE" : "AND"), key);
+                            int index = this.TableInfo.Columns.IndexOf(key);
+                            updateRec[indexes.Count + i + 1] = this.Values[index];
+
+                        }
+
+                        string updateSql = s.ToString();
+                        TextWriter log = this.Database.Log;
+                        if (log != null)
+                        {
+                            log.WriteLine();
+                            log.WriteLine(updateSql);
+                            for (int field = 1; field <= updateRecSize; field++)
+                            {
+                                log.WriteLine("    ? = " + updateRec.GetString(field));
+                            }
+                        }
+
+                        this.Database.Execute(updateSql, updateRec);
+                    }
+                }
+                else
+                {
+                    throw new NotImplementedException(
+                        "Update() cannot handle changed primary keys yet.");
+                    // TODO:
+                    //   query using old values
+                    //   update values
+                    //   View.Replace
+                }
+            }
+        }
+
+        /// <summary>
+        /// Inserts the record in the database.
+        /// </summary>
+        /// <remarks>
+        /// The record (primary keys) may not already exist in the table.
+        /// <para>Use <see cref="QTable&lt;TRecord&gt;.NewRecord()"/> to get a new 
+        /// record. Prmary keys and all required fields
+        /// must be filled in before insertion.</para>
+        /// </remarks>
+        public void Insert()
+        {
+            this.Insert(false);
+        }
+
+        /// <summary>
+        /// Inserts the record into the table.
+        /// </summary>
+        /// <param name="temporary">true if the record is temporarily
+        /// inserted, to be visible only as long as the database is open</param>
+        /// <remarks>
+        /// The record (primary keys) may not already exist in the table.
+        /// <para>Use <see cref="QTable&lt;TRecord&gt;.NewRecord()"/> to get a new 
+        /// record. Prmary keys and all required fields
+        /// must be filled in before insertion.</para>
+        /// </remarks>
+        public void Insert(bool temporary)
+        {
+            using (Record updateRec = this.Database.CreateRecord(this.FieldCount))
+            {
+                string insertSql = this.TableInfo.SqlInsertString;
+                if (temporary)
+                {
+                    insertSql += " TEMPORARY";
+                }
+
+                TextWriter log = this.Database.Log;
+                if (log != null)
+                {
+                    log.WriteLine();
+                    log.WriteLine(insertSql);
+                }
+
+                for (int index = 0; index < this.FieldCount; index++)
+                {
+                    ColumnInfo col = this.TableInfo.Columns[index];
+                    if (col.Type == typeof(Stream))
+                    {
+                        throw new NotSupportedException(
+                            "Cannot insert stream columns via QRecord.");
+                    }
+
+                    if (this.Values[index] != null)
+                    {
+                        updateRec[index + 1] = this.Values[index];
+                    }
+
+                    if (log != null)
+                    {
+                        log.WriteLine("    ? = " + this.Values[index]);
+                    }
+                }
+
+                this.Database.Execute(insertSql, updateRec);
+                this.Exists = true;
+            }
+        }
+
+        /// <summary>
+        /// Deletes the record from the table if it exists.
+        /// </summary>
+        public void Delete()
+        {
+            using (Record keyRec = this.Database.CreateRecord(this.TableInfo.PrimaryKeys.Count))
+            {
+                StringBuilder s = new StringBuilder("DELETE FROM `");
+                s.Append(this.TableInfo.Name);
+                s.Append("`");
+                for (int i = 0; i < this.TableInfo.PrimaryKeys.Count; i++)
+                {
+                    string key = this.TableInfo.PrimaryKeys[i];
+                    s.AppendFormat(" {0} `{1}` = ?", (i == 0 ? "WHERE" : "AND"), key);
+                    int index = this.TableInfo.Columns.IndexOf(key);
+                    keyRec[i + 1] = this.Values[index];
+                }
+
+                string deleteSql = s.ToString();
+
+                TextWriter log = this.Database.Log;
+                if (log != null)
+                {
+                    log.WriteLine();
+                    log.WriteLine(deleteSql);
+
+                    for (int i = 0; i < this.TableInfo.PrimaryKeys.Count; i++)
+                    {
+                        log.WriteLine("    ? = " + keyRec.GetString(i + 1));
+                    }
+                }
+
+                this.Database.Execute(deleteSql, keyRec);
+                this.Exists = false;
+            }
+        }
+
+        /// <summary>
+        /// Not yet implemented.
+        /// </summary>
+        public void Refresh()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Not yet implemented.
+        /// </summary>
+        public void Assign()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Not yet implemented.
+        /// </summary>
+        public bool Merge()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Not yet implemented.
+        /// </summary>
+        public ICollection<ValidationErrorInfo> Validate()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Not yet implemented.
+        /// </summary>
+        [SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix")]
+        public ICollection<ValidationErrorInfo> ValidateNew()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Not yet implemented.
+        /// </summary>
+        public ICollection<ValidationErrorInfo> ValidateFields()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Not yet implemented.
+        /// </summary>
+        public ICollection<ValidationErrorInfo> ValidateDelete()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/QTable.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/QTable.cs
new file mode 100644
index 00000000..e0e1c154
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/QTable.cs
@@ -0,0 +1,296 @@
+// 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.Linq
+{
+    using System;
+    using System.IO;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using System.Linq;
+    using System.Linq.Expressions;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Represents one table in a LINQ-queryable Database.
+    /// </summary>
+    /// <typeparam name="TRecord">type that represents one record in the table</typeparam>
+    /// <remarks>
+    /// This class is the primary gateway to all LINQ to MSI query functionality.
+    /// <para>The TRecord generic parameter may be the general <see cref="QRecord" />
+    /// class, or a specialized subclass of QRecord.</para>
+    /// </remarks>
+    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix")]
+    public sealed class QTable<TRecord> : IOrderedQueryable<TRecord>, IQueryProvider
+        where TRecord : QRecord, new()
+    {
+        private QDatabase db;
+        private TableInfo tableInfo;
+
+        /// <summary>
+        /// Infers the name of the table this instance will be
+        /// associated with.
+        /// </summary>
+        /// <returns>table name</returns>
+        /// <remarks>
+        /// The table name is retrieved from a DatabaseTableAttribute
+        /// on the record type if it exists; otherwise the name is
+        /// derived from the name of the record type itself.
+        /// (An optional underscore suffix on the record type name is dropped.)
+        /// </remarks>
+        private static string InferTableName()
+        {
+            foreach (DatabaseTableAttribute attr in typeof(TRecord).GetCustomAttributes(
+                typeof(DatabaseTableAttribute), false))
+            {
+                string tableName = attr.Table;
+                if (!String.IsNullOrEmpty(tableName))
+                {
+                    return tableName;
+                }
+            }
+
+            string recordTypeName = typeof(TRecord).Name;
+            if (recordTypeName[recordTypeName.Length - 1] == '_')
+            {
+                return recordTypeName.Substring(0, recordTypeName.Length - 1);
+            }
+            else
+            {
+                return recordTypeName;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new QTable, inferring the table name
+        /// from the name of the record type parameter.
+        /// </summary>
+        /// <param name="db">database that contains the table</param>
+        public QTable(QDatabase db)
+            : this(db, InferTableName())
+        {
+        }
+
+        /// <summary>
+        /// Creates a new QTable with an explicit table name.
+        /// </summary>
+        /// <param name="db">database that contains the table</param>
+        /// <param name="table">name of the table</param>
+        public QTable(QDatabase db, string table)
+        {
+            if (db == null)
+            {
+                throw new ArgumentNullException("db");
+            }
+
+            if (String.IsNullOrEmpty(table))
+            {
+                throw new ArgumentNullException("table");
+            }
+
+            this.db = db;
+            this.tableInfo = db.Tables[table];
+            if (this.tableInfo == null)
+            {
+                throw new ArgumentException(
+                    "Table does not exist in database: " + table);
+            }
+        }
+
+        /// <summary>
+        /// Gets schema information about the table.
+        /// </summary>
+        public TableInfo TableInfo
+        {
+            get
+            {
+                return this.tableInfo;
+            }
+        }
+
+        /// <summary>
+        /// Gets the database this table is associated with.
+        /// </summary>
+        public QDatabase Database
+        {
+            get
+            {
+                return this.db;
+            }
+        }
+
+        /// <summary>
+        /// Enumerates over all records in the table.
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerator<TRecord> GetEnumerator()
+        {
+            string query = this.tableInfo.SqlSelectString;
+
+            TextWriter log = this.db.Log;
+            if (log != null)
+            {
+                log.WriteLine();
+                log.WriteLine(query);
+            }
+
+            using (View view = db.OpenView(query))
+            {
+                view.Execute();
+
+                ColumnCollection columns = this.tableInfo.Columns;
+                int columnCount = columns.Count;
+                bool[] isBinary = new bool[columnCount];
+
+                for (int i = 0; i < isBinary.Length; i++)
+                {
+                    isBinary[i] = columns[i].Type == typeof(System.IO.Stream);
+                }
+
+                foreach (Record rec in view) using (rec)
+                {
+                    string[] values = new string[columnCount];
+                    for (int i = 0; i < values.Length; i++)
+                    {
+                        values[i] = isBinary[i] ? "[Binary Data]" : rec.GetString(i + 1);
+                    }
+
+                    TRecord trec = new TRecord();
+                    trec.Database = this.Database;
+                    trec.TableInfo = this.TableInfo;
+                    trec.Values = values;
+                    trec.Exists = true;
+                    yield return trec;
+                }
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable<TRecord>) this).GetEnumerator();
+        }
+
+        IQueryable<TElement> IQueryProvider.CreateQuery<TElement>(Expression expression)
+        {
+            if (expression == null)
+            {
+                throw new ArgumentNullException("expression");
+            }
+
+            Query<TElement> q = new Query<TElement>(this.Database, expression);
+
+            MethodCallExpression methodCallExpression = (MethodCallExpression) expression;
+            string methodName = methodCallExpression.Method.Name;
+            if (methodName == "Where")
+            {
+                LambdaExpression argumentExpression = (LambdaExpression)
+                    ((UnaryExpression) methodCallExpression.Arguments[1]).Operand;
+                q.BuildQuery(this.TableInfo, argumentExpression);
+            }
+            else if (methodName == "OrderBy")
+            {
+                LambdaExpression argumentExpression = (LambdaExpression)
+                    ((UnaryExpression) methodCallExpression.Arguments[1]).Operand;
+                q.BuildSequence(this.TableInfo, argumentExpression);
+            }
+            else if (methodName == "Select")
+            {
+                LambdaExpression argumentExpression = (LambdaExpression)
+                    ((UnaryExpression) methodCallExpression.Arguments[1]).Operand;
+                q.BuildNullQuery(this.TableInfo, typeof(TRecord), argumentExpression);
+                q.BuildProjection(null, argumentExpression);
+            }
+            else if (methodName == "Join")
+            {
+                ConstantExpression constantExpression = (ConstantExpression)
+                    methodCallExpression.Arguments[1];
+                IQueryable inner = (IQueryable) constantExpression.Value;
+                q.PerformJoin(
+                    this.TableInfo,
+                    typeof(TRecord),
+                    inner,
+                    GetJoinLambda(methodCallExpression.Arguments[2]),
+                    GetJoinLambda(methodCallExpression.Arguments[3]),
+                    GetJoinLambda(methodCallExpression.Arguments[4]));
+            }
+            else
+            {
+                throw new NotSupportedException(
+                    "Query operation not supported: " + methodName);
+            }
+
+            return q;
+        }
+
+        private static LambdaExpression GetJoinLambda(Expression expresion)
+        {
+            UnaryExpression unaryExpression = (UnaryExpression) expresion;
+            return (LambdaExpression) unaryExpression.Operand;
+        }
+
+        IQueryable IQueryProvider.CreateQuery(Expression expression)
+        {
+            return ((IQueryProvider) this).CreateQuery<TRecord>(expression);
+        }
+
+        TResult IQueryProvider.Execute<TResult>(Expression expression)
+        {
+            throw new NotSupportedException(
+                "Direct method calls not supported -- use AsEnumerable() instead.");
+        }
+
+        object IQueryProvider.Execute(Expression expression)
+        {
+            throw new NotSupportedException(
+                "Direct method calls not supported -- use AsEnumerable() instead.");
+        }
+
+        IQueryProvider IQueryable.Provider
+        {
+            get
+            {
+                return this;
+            }
+        }
+
+        Type IQueryable.ElementType
+        {
+            get
+            {
+                return typeof(TRecord);
+            }
+        }
+
+        Expression IQueryable.Expression
+        {
+            get
+            {
+                return Expression.Constant(this);
+            }
+        }
+
+        /// <summary>
+        /// Creates a new record that can be inserted into this table.
+        /// </summary>
+        /// <returns>a record with all fields initialized to null</returns>
+        /// <remarks>
+        /// Primary keys and required fields must be filled in with
+        /// non-null values before the record can be inserted.
+        /// <para>The record is tied to this table in this database;
+        /// it cannot be inserted into another table or database.</para>
+        /// </remarks>
+        public TRecord NewRecord()
+        {
+            TRecord rec = new TRecord();
+            rec.Database = this.Database;
+            rec.TableInfo = this.TableInfo;
+            IList<string> values = new List<string>(this.TableInfo.Columns.Count);
+            for (int i = 0; i < this.TableInfo.Columns.Count; i++)
+            {
+                values.Add(null);
+            }
+            rec.Values = values;
+            return rec;
+        }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/Query.cs b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/Query.cs
new file mode 100644
index 00000000..ea58757c
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/Query.cs
@@ -0,0 +1,992 @@
+// 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.Linq
+{
+    using System;
+    using System.IO;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Linq.Expressions;
+    using System.Text;
+    using System.Reflection;
+    using System.Globalization;
+    using System.Diagnostics.CodeAnalysis;
+
+    /// <summary>
+    /// Implements the LINQ to MSI query functionality.
+    /// </summary>
+    /// <typeparam name="T">the result type of the current query --
+    /// either some kind of QRecord, or some projection of record data</typeparam>
+    internal sealed class Query<T> : IOrderedQueryable<T>, IQueryProvider
+    {
+        private QDatabase db;
+        private Expression queryableExpression;
+        private List<TableInfo> tables;
+        private List<Type> recordTypes;
+        private List<string> selectors;
+        private string where;
+        private List<object> whereParameters;
+        private List<TableColumn> orderbyColumns;
+        private List<TableColumn> selectColumns;
+        private List<TableColumn> joinColumns;
+        private List<Delegate> projectionDelegates;
+
+        internal Query(QDatabase db, Expression expression)
+        {
+            if (expression == null)
+            {
+                throw new ArgumentNullException("expression");
+            }
+
+            this.db = db;
+            this.queryableExpression = expression;
+            this.tables = new List<TableInfo>();
+            this.recordTypes = new List<Type>();
+            this.selectors = new List<string>();
+            this.whereParameters = new List<object>();
+            this.orderbyColumns = new List<TableColumn>();
+            this.selectColumns = new List<TableColumn>();
+            this.joinColumns = new List<TableColumn>();
+            this.projectionDelegates = new List<Delegate>();
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            if (this.selectColumns.Count == 0)
+            {
+                AddAllColumns(this.tables[0], this.selectColumns);                
+            }
+
+            string query = this.CompileQuery();
+            return this.InvokeQuery(query);
+        }
+
+        private string CompileQuery()
+        {
+            bool explicitTables = this.tables.Count > 1;
+
+            StringBuilder queryBuilder = new StringBuilder("SELECT");
+
+            for (int i = 0; i < this.selectColumns.Count; i++)
+            {
+                queryBuilder.AppendFormat(
+                    CultureInfo.InvariantCulture,
+                    (explicitTables ? "{0} `{1}`.`{2}`" : "{0} `{2}`"),
+                    (i > 0 ? "," : String.Empty),
+                    this.selectColumns[i].Table.Name,
+                    this.selectColumns[i].Column.Name);
+            }
+
+            for (int i = 0; i < this.tables.Count; i++)
+            {
+                queryBuilder.AppendFormat(
+                    CultureInfo.InvariantCulture,
+                    "{0} `{1}`",
+                    (i == 0 ? " FROM" : ","),
+                    this.tables[i].Name);
+            }
+
+            bool startedWhere = false;
+            for (int i = 0; i < this.joinColumns.Count - 1; i += 2)
+            {
+                queryBuilder.AppendFormat(
+                    CultureInfo.InvariantCulture,
+                    "{0} `{1}`.`{2}` = `{3}`.`{4}` ",
+                    (i == 0 ? " WHERE" : "AND"),
+                    this.joinColumns[i].Table,
+                    this.joinColumns[i].Column,
+                    this.joinColumns[i + 1].Table,
+                    this.joinColumns[i + 1].Column);
+                startedWhere = true;
+            }
+
+            if (this.where != null)
+            {
+                queryBuilder.Append(startedWhere ? "AND " : " WHERE");
+                queryBuilder.Append(this.where);
+            }
+
+            for (int i = 0; i < this.orderbyColumns.Count; i++)
+            {
+                VerifyOrderByColumn(this.orderbyColumns[i]);
+
+                queryBuilder.AppendFormat(
+                    CultureInfo.InvariantCulture,
+                    (explicitTables ? "{0} `{1}`.`{2}`" : "{0} `{2}`"),
+                    (i == 0 ? " ORDER BY" : ","),
+                    this.orderbyColumns[i].Table.Name,
+                    this.orderbyColumns[i].Column.Name);
+            }
+
+            return queryBuilder.ToString();
+        }
+
+        private static void VerifyOrderByColumn(TableColumn tableColumn)
+        {
+            if (tableColumn.Column.Type != typeof(int) &&
+                tableColumn.Column.Type != typeof(short))
+            {
+                throw new NotSupportedException(
+                    "Cannot orderby column: " + tableColumn.Column.Name +
+                    "; orderby is only supported on integer fields");
+            }
+        }
+
+        private IEnumerator<T> InvokeQuery(string query)
+        {
+            TextWriter log = this.db.Log;
+            if (log != null)
+            {
+                log.WriteLine();
+                log.WriteLine(query);
+            }
+
+            using (View queryView = this.db.OpenView(query))
+            {
+                if (this.whereParameters != null && this.whereParameters.Count > 0)
+                {
+                    using (Record paramsRec = this.db.CreateRecord(this.whereParameters.Count))
+                    {
+                        for (int i = 0; i < this.whereParameters.Count; i++)
+                        {
+                            paramsRec[i + 1] = this.whereParameters[i];
+
+                            if (log != null)
+                            {
+                                log.WriteLine("    ? = " + this.whereParameters[i]);
+                            }
+                        }
+
+                        queryView.Execute(paramsRec);
+                    }
+                }
+                else
+                {
+                    queryView.Execute();
+                }
+
+                foreach (Record resultRec in queryView) using (resultRec)
+                {
+                    yield return this.GetResult(resultRec);
+                }
+            }
+        }
+
+        private T GetResult(Record resultRec)
+        {
+            object[] results = new object[this.tables.Count];
+
+            for (int i = 0; i < this.tables.Count; i++)
+            {
+                string[] values = new string[this.tables[i].Columns.Count];
+                for (int j = 0; j < this.selectColumns.Count; j++)
+                {
+                    TableColumn col = this.selectColumns[j];
+                    if (col.Table.Name == this.tables[i].Name)
+                    {
+                        int index = this.tables[i].Columns.IndexOf(
+                            col.Column.Name);
+                        if (index >= 0)
+                        {
+                            if (col.Column.Type == typeof(Stream))
+                            {
+                                values[index] = "[Binary Data]";
+                            }
+                            else
+                            {
+                                values[index] = resultRec.GetString(j + 1);
+                            }
+                        }
+                    }
+                }
+
+                QRecord result = (QRecord) this.recordTypes[i]
+                    .GetConstructor(Type.EmptyTypes).Invoke(null);
+                result.Database = this.db;
+                result.TableInfo = this.tables[i];
+                result.Values = values;
+                result.Exists = true;
+                results[i] = result;
+            }
+
+            if (this.projectionDelegates.Count > 0)
+            {
+                object resultsProjection = results[0];
+                for (int i = 1; i <= results.Length; i++)
+                {
+                    if (i < results.Length)
+                    {
+                        resultsProjection = this.projectionDelegates[i - 1]
+                            .DynamicInvoke(new object[] { resultsProjection, results[i] });
+                    }
+                    else
+                    {
+                        resultsProjection = this.projectionDelegates[i - 1]
+                            .DynamicInvoke(resultsProjection);
+                    }
+                }
+
+                return (T) resultsProjection;
+            }
+            else
+            {
+                return (T) (object) results[0];
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((IEnumerable<T>) this).GetEnumerator();
+        }
+
+        public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
+        {
+            if (expression == null)
+            {
+                throw new ArgumentNullException("expression");
+            }
+
+            Query<TElement> q = new Query<TElement>(this.db, expression);
+            q.tables.AddRange(this.tables);
+            q.recordTypes.AddRange(this.recordTypes);
+            q.selectors.AddRange(this.selectors);
+            q.where = this.where;
+            q.whereParameters.AddRange(this.whereParameters);
+            q.orderbyColumns.AddRange(this.orderbyColumns);
+            q.selectColumns.AddRange(this.selectColumns);
+            q.joinColumns.AddRange(this.joinColumns);
+            q.projectionDelegates.AddRange(this.projectionDelegates);
+
+            MethodCallExpression methodCallExpression = (MethodCallExpression) expression;
+            string methodName = methodCallExpression.Method.Name;
+            if (methodName == "Select")
+            {
+                LambdaExpression argumentExpression = (LambdaExpression)
+                    ((UnaryExpression) methodCallExpression.Arguments[1]).Operand;
+                q.BuildProjection(null, argumentExpression);
+            }
+            else if (methodName == "Where")
+            {
+                LambdaExpression argumentExpression = (LambdaExpression)
+                    ((UnaryExpression) methodCallExpression.Arguments[1]).Operand;
+                q.BuildQuery(null, argumentExpression);
+            }
+            else if (methodName == "ThenBy")
+            {
+                LambdaExpression argumentExpression = (LambdaExpression)
+                    ((UnaryExpression) methodCallExpression.Arguments[1]).Operand;
+                q.BuildSequence(null, argumentExpression);
+            }
+            else if (methodName == "Join")
+            {
+                ConstantExpression constantExpression = (ConstantExpression)
+                    methodCallExpression.Arguments[1];
+                IQueryable inner = (IQueryable) constantExpression.Value;
+                q.PerformJoin(
+                    null,
+                    null,
+                    inner,
+                    GetJoinLambda(methodCallExpression.Arguments[2]),
+                    GetJoinLambda(methodCallExpression.Arguments[3]),
+                    GetJoinLambda(methodCallExpression.Arguments[4]));
+            }
+            else
+            {
+                throw new NotSupportedException(
+                    "Query operation not supported: " + methodName);
+            }
+
+            return q;
+        }
+
+        public IQueryable CreateQuery(Expression expression)
+        {
+            return this.CreateQuery<T>(expression);
+        }
+
+        private static LambdaExpression GetJoinLambda(Expression expresion)
+        {
+            UnaryExpression unaryExpression = (UnaryExpression) expresion;
+            return (LambdaExpression) unaryExpression.Operand;
+        }
+
+        public TResult Execute<TResult>(Expression expression)
+        {
+            throw new NotSupportedException(
+                "Direct method calls not supported -- use AsEnumerable() instead.");
+        }
+
+        object IQueryProvider.Execute(Expression expression)
+        {
+            throw new NotSupportedException(
+                "Direct method calls not supported -- use AsEnumerable() instead.");
+        }
+
+        public IQueryProvider Provider
+        {
+            get
+            {
+                return this;
+            }
+        }
+
+        public Type ElementType
+        {
+            get
+            {
+                return typeof(T);
+            }
+        }
+
+        public Expression Expression
+        {
+            get
+            {
+                return this.queryableExpression;
+            }
+        }
+
+        internal void BuildQuery(TableInfo tableInfo, LambdaExpression expression)
+        {
+            if (tableInfo != null)
+            {
+                this.tables.Add(tableInfo);
+                this.recordTypes.Add(typeof(T));
+                this.selectors.Add(expression.Parameters[0].Name);
+            }
+
+            StringBuilder queryBuilder = new StringBuilder();
+
+            this.ParseQuery(expression.Body, queryBuilder);
+
+            this.where = queryBuilder.ToString();
+        }
+
+        internal void BuildNullQuery(TableInfo tableInfo, Type recordType, LambdaExpression expression)
+        {
+            this.tables.Add(tableInfo);
+            this.recordTypes.Add(recordType);
+            this.selectors.Add(expression.Parameters[0].Name);
+        }
+
+        private void ParseQuery(Expression expression, StringBuilder queryBuilder)
+        {
+            queryBuilder.Append("(");
+
+            BinaryExpression binaryExpression;
+            UnaryExpression unaryExpression;
+            MethodCallExpression methodCallExpression;
+
+            if ((binaryExpression = expression as BinaryExpression) != null)
+            {
+                switch (binaryExpression.NodeType)
+                {
+                    case ExpressionType.AndAlso:
+                        this.ParseQuery(binaryExpression.Left, queryBuilder);
+                        queryBuilder.Append(" AND ");
+                        this.ParseQuery(binaryExpression.Right, queryBuilder);
+                        break;
+
+                    case ExpressionType.OrElse:
+                        this.ParseQuery(binaryExpression.Left, queryBuilder);
+                        queryBuilder.Append(" OR ");
+                        this.ParseQuery(binaryExpression.Right, queryBuilder);
+                        break;
+
+                    case ExpressionType.Equal:
+                    case ExpressionType.NotEqual:
+                    case ExpressionType.GreaterThan:
+                    case ExpressionType.LessThan:
+                    case ExpressionType.GreaterThanOrEqual:
+                    case ExpressionType.LessThanOrEqual:
+                        this.ParseQueryCondition(binaryExpression, queryBuilder);
+                        break;
+
+                    default:
+                        throw new NotSupportedException(
+                                  "Expression type not supported: " + binaryExpression.NodeType );
+                }
+            }
+            else if ((unaryExpression = expression as UnaryExpression) != null)
+            {
+                throw new NotSupportedException(
+                    "Expression type not supported: " + unaryExpression.NodeType);
+            }
+            else if ((methodCallExpression = expression as MethodCallExpression) != null)
+            {
+                throw new NotSupportedException(
+                    "Method call not supported: " + methodCallExpression.Method.Name + "()");
+            }
+            else
+            {
+                throw new NotSupportedException(
+                    "Query filter expression not supported: " + expression);
+            }
+
+            queryBuilder.Append(")");
+        }
+
+        private static ExpressionType OppositeExpression(ExpressionType e)
+        {
+            switch (e)
+            {
+                case ExpressionType.LessThan:
+                    return ExpressionType.GreaterThan;
+                case ExpressionType.LessThanOrEqual:
+                    return ExpressionType.GreaterThanOrEqual;
+                case ExpressionType.GreaterThan:
+                    return ExpressionType.LessThan;
+                case ExpressionType.GreaterThanOrEqual:
+                    return ExpressionType.LessThanOrEqual;
+                default:
+                    return e;
+            }
+        }
+
+        private static bool IsIntegerType(Type t)
+        {
+            return
+                t == typeof(sbyte) ||
+                t == typeof(byte) ||
+                t == typeof(short) ||
+                t == typeof(ushort) ||
+                t == typeof(int) ||
+                t == typeof(uint) ||
+                t == typeof(long) ||
+                t == typeof(ulong);
+        }
+
+        private void ParseQueryCondition(
+            BinaryExpression binaryExpression, StringBuilder queryBuilder)
+        {
+            bool swap;
+            string column = this.GetConditionColumn(binaryExpression, out swap);
+            queryBuilder.Append(column);
+
+            ExpressionType expressionType = binaryExpression.NodeType;
+            if (swap)
+            {
+                expressionType = OppositeExpression(expressionType);
+            }
+
+            LambdaExpression valueExpression = Expression.Lambda(
+                swap ? binaryExpression.Left : binaryExpression.Right);
+            object value = valueExpression.Compile().DynamicInvoke();
+
+            bool valueIsInt = false;
+            if (value != null)
+            {
+                if (IsIntegerType(value.GetType()))
+                {
+                    valueIsInt = true;
+                }
+                else
+                {
+                    value = value.ToString();
+                }
+            }
+
+            switch (expressionType)
+            {
+                case ExpressionType.Equal:
+                    if (value == null)
+                    {
+                        queryBuilder.Append(" IS NULL");
+                    }
+                    else if (valueIsInt)
+                    {
+                        queryBuilder.Append(" = ");
+                        queryBuilder.Append(value);
+                    }
+                    else
+                    {
+                        queryBuilder.Append(" = ?");
+                        this.whereParameters.Add(value);
+                    }
+                    return;
+
+                case ExpressionType.NotEqual:
+                    if (value == null)
+                    {
+                        queryBuilder.Append(" IS NOT NULL");
+                    }
+                    else if (valueIsInt)
+                    {
+                        queryBuilder.Append(" <> ");
+                        queryBuilder.Append(value);
+                    }
+                    else
+                    {
+                        queryBuilder.Append(" <> ?");
+                        this.whereParameters.Add(value);
+                    }
+                    return;
+            }
+
+            if (value == null)
+            {
+                throw new InvalidOperationException(
+                    "A null value was used in a greater-than/less-than operation.");
+            }
+
+            if (!valueIsInt)
+            {
+                throw new NotSupportedException(
+                    "Greater-than/less-than operators not supported on strings.");
+            }
+
+            switch (expressionType)
+            {
+                case ExpressionType.LessThan:
+                    queryBuilder.Append(" < ");
+                    break;
+
+                case ExpressionType.LessThanOrEqual:
+                    queryBuilder.Append(" <= ");
+                    break;
+
+                case ExpressionType.GreaterThan:
+                    queryBuilder.Append(" > ");
+                    break;
+
+                case ExpressionType.GreaterThanOrEqual:
+                    queryBuilder.Append(" >= ");
+                    break;
+                
+                default:
+                    throw new NotSupportedException(
+                        "Unsupported query expression type: " + expressionType);
+            }
+
+            queryBuilder.Append(value);
+        }
+
+        private string GetConditionColumn(
+            BinaryExpression binaryExpression, out bool swap)
+        {
+            MemberExpression memberExpression;
+            MethodCallExpression methodCallExpression;
+
+            if (((memberExpression = binaryExpression.Left as MemberExpression) != null) ||
+                ((binaryExpression.Left.NodeType == ExpressionType.Convert ||
+                  binaryExpression.Left.NodeType == ExpressionType.ConvertChecked) &&
+                 (memberExpression = ((UnaryExpression) binaryExpression.Left).Operand
+                  as MemberExpression) != null))
+            {
+                string column = this.GetConditionColumn(memberExpression);
+                if (column != null)
+                {
+                    swap = false;
+                    return column;
+                }
+            }
+            else if (((memberExpression = binaryExpression.Right as MemberExpression) != null) ||
+                     ((binaryExpression.Right.NodeType == ExpressionType.Convert ||
+                       binaryExpression.Right.NodeType == ExpressionType.ConvertChecked) &&
+                      (memberExpression = ((UnaryExpression) binaryExpression.Right).Operand
+                       as MemberExpression) != null))
+            {
+                string column = this.GetConditionColumn(memberExpression);
+                if (column != null)
+                {
+                    swap = true;
+                    return column;
+                }
+            }
+            else if ((methodCallExpression = binaryExpression.Left as MethodCallExpression) != null)
+            {
+                string column = this.GetConditionColumn(methodCallExpression);
+                if (column != null)
+                {
+                    swap = false;
+                    return column;
+                }
+            }
+            else if ((methodCallExpression = binaryExpression.Right as MethodCallExpression) != null)
+            {
+                string column = this.GetConditionColumn(methodCallExpression);
+                if (column != null)
+                {
+                    swap = true;
+                    return column;
+                }
+            }
+
+            throw new NotSupportedException(
+                "Unsupported binary expression: " + binaryExpression);
+        }
+
+        private string GetConditionColumn(MemberExpression memberExpression)
+        {
+            string columnName = GetColumnName(memberExpression.Member);
+            string selectorName = GetConditionSelectorName(memberExpression.Expression);
+            string tableName = this.GetConditionTable(selectorName, columnName);
+            return this.FormatColumn(tableName, columnName);
+        }
+
+        private string GetConditionColumn(MethodCallExpression methodCallExpression)
+        {
+            LambdaExpression argumentExpression =
+                Expression.Lambda(methodCallExpression.Arguments[0]);
+            string columnName = (string) argumentExpression.Compile().DynamicInvoke();
+            string selectorName = GetConditionSelectorName(methodCallExpression.Object);
+            string tableName = this.GetConditionTable(selectorName, columnName);
+            return this.FormatColumn(tableName, columnName);
+        }
+
+        private static string GetConditionSelectorName(Expression expression)
+        {
+            ParameterExpression parameterExpression;
+            MemberExpression memberExpression;
+            if ((parameterExpression = expression as ParameterExpression) != null)
+            {
+                return parameterExpression.Name;
+            }
+            else if ((memberExpression = expression as MemberExpression) != null)
+            {
+                return memberExpression.Member.Name;
+            }
+            else
+            {
+                throw new NotSupportedException(
+                    "Unsupported conditional selector expression: " + expression);
+            }
+        }
+
+        private string GetConditionTable(string selectorName, string columnName)
+        {
+            string tableName = null;
+
+            for (int i = 0; i < this.tables.Count; i++)
+            {
+                if (this.selectors[i] == selectorName)
+                {
+                    tableName = this.tables[i].Name;
+                    break;
+                }
+            }
+
+            if (tableName == null)
+            {
+                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
+                    "Conditional expression contains column {0}.{1} " +
+                    "from a table that is not in the query.",
+                    selectorName,
+                    columnName));
+            }
+
+            return tableName;
+        }
+
+        private string FormatColumn(string tableName, string columnName)
+        {
+            if (tableName != null && this.tables.Count > 1)
+            {
+                return String.Format(CultureInfo.InvariantCulture, "`{0}`.`{1}`", tableName, columnName);
+            }
+            else
+            {
+                return String.Format(CultureInfo.InvariantCulture, "`{0}`", columnName);
+            }
+        }
+
+        private static string GetColumnName(MemberInfo memberInfo)
+        {
+            foreach (var attr in memberInfo.GetCustomAttributes(
+                typeof(DatabaseColumnAttribute), false))
+            {
+                return ((DatabaseColumnAttribute) attr).Column;
+            }
+
+            return memberInfo.Name;
+        }
+
+        internal void BuildProjection(TableInfo tableInfo, LambdaExpression expression)
+        {
+            if (tableInfo != null)
+            {
+                this.tables.Add(tableInfo);
+                this.recordTypes.Add(typeof(T));
+                this.selectors.Add(expression.Parameters[0].Name);
+            }
+
+            this.FindColumns(expression, this.selectColumns);
+            this.projectionDelegates.Add(expression.Compile());
+        }
+
+        internal void BuildSequence(TableInfo tableInfo, LambdaExpression expression)
+        {
+            if (tableInfo != null)
+            {
+                this.tables.Add(tableInfo);
+                this.recordTypes.Add(typeof(T));
+                this.selectors.Add(expression.Parameters[0].Name);
+            }
+
+            this.FindColumns(expression.Body, this.orderbyColumns);
+        }
+
+        private static void AddAllColumns(TableInfo tableInfo, IList<TableColumn> columnList)
+        {
+            foreach (ColumnInfo column in tableInfo.Columns)
+            {
+                columnList.Add(new TableColumn(tableInfo, column));
+            }
+        }
+
+        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private void FindColumns(Expression expression, IList<TableColumn> columnList)
+        {
+            if (expression is ParameterExpression)
+            {
+                ParameterExpression e = expression as ParameterExpression;
+                string selector = e.Name;
+                for (int i = 0; i < this.tables.Count; i++)
+                {
+                    if (this.selectors[i] == selector)
+                    {
+                        AddAllColumns(this.tables[i], columnList);
+                        break;
+                    }
+                }
+            }
+            else if (expression.NodeType == ExpressionType.MemberAccess)
+            {
+                this.FindColumns(expression as MemberExpression, columnList);
+            }
+            else if (expression is MethodCallExpression)
+            {
+                this.FindColumns(expression as MethodCallExpression, columnList);
+            }
+            else if (expression is BinaryExpression)
+            {
+                BinaryExpression e = expression as BinaryExpression;
+                this.FindColumns(e.Left, columnList);
+                this.FindColumns(e.Right, columnList);
+            }
+            else if (expression is UnaryExpression)
+            {
+                UnaryExpression e = expression as UnaryExpression;
+                this.FindColumns(e.Operand, columnList);
+            }
+            else if (expression is ConditionalExpression)
+            {
+                ConditionalExpression e = expression as ConditionalExpression;
+                this.FindColumns(e.Test, columnList);
+                this.FindColumns(e.IfTrue, columnList);
+                this.FindColumns(e.IfFalse, columnList);
+            }
+            else if (expression is InvocationExpression)
+            {
+                InvocationExpression e = expression as InvocationExpression;
+                this.FindColumns(e.Expression, columnList);
+                this.FindColumns(e.Arguments, columnList);
+            }
+            else if (expression is LambdaExpression)
+            {
+                LambdaExpression e = expression as LambdaExpression;
+                this.FindColumns(e.Body, columnList);
+            }
+            else if (expression is ListInitExpression)
+            {
+                ListInitExpression e = expression as ListInitExpression;
+                this.FindColumns(e.NewExpression, columnList);
+                foreach (ElementInit ei in e.Initializers)
+                {
+                    this.FindColumns(ei.Arguments, columnList);
+                }
+            }
+            else if (expression is MemberInitExpression)
+            {
+                MemberInitExpression e = expression as MemberInitExpression;
+                this.FindColumns(e.NewExpression, columnList);
+                foreach (MemberAssignment b in e.Bindings)
+                {
+                    this.FindColumns(b.Expression, columnList);
+                }
+            }
+            else if (expression is NewExpression)
+            {
+                NewExpression e = expression as NewExpression;
+                this.FindColumns(e.Arguments, columnList);
+            }
+            else if (expression is NewArrayExpression)
+            {
+                NewArrayExpression e = expression as NewArrayExpression;
+                this.FindColumns(e.Expressions, columnList);
+            }
+            else if (expression is TypeBinaryExpression)
+            {
+                TypeBinaryExpression e = expression as TypeBinaryExpression;
+                this.FindColumns(e.Expression, columnList);
+            }
+        }
+
+        private void FindColumns(IEnumerable<Expression> expressions, IList<TableColumn> columnList)
+        {
+            foreach (Expression expression in expressions)
+            {
+                this.FindColumns(expression, columnList);
+            }
+        }
+
+        private void FindColumns(MemberExpression memberExpression, IList<TableColumn> columnList)
+        {
+            string selector = null;
+            MemberExpression objectMemberExpression;
+            ParameterExpression objectParameterExpression;
+            if ((objectParameterExpression = memberExpression.Expression as
+                ParameterExpression) != null)
+            {
+                selector = objectParameterExpression.Name;
+            }
+            else if ((objectMemberExpression = memberExpression.Expression as
+                MemberExpression) != null)
+            {
+                selector = objectMemberExpression.Member.Name;
+            }
+
+            if (selector != null)
+            {
+                for (int i = 0; i < this.tables.Count; i++)
+                {
+                    if (this.selectors[i] == selector)
+                    {
+                        string columnName = GetColumnName(memberExpression.Member);
+                        ColumnInfo column = this.tables[i].Columns[columnName];
+                        columnList.Add(new TableColumn(this.tables[i], column));
+                        break;
+                    }
+                }
+            }
+
+            selector = memberExpression.Member.Name;
+            for (int i = 0; i < this.tables.Count; i++)
+            {
+                if (this.selectors[i] == selector)
+                {
+                    AddAllColumns(this.tables[i], columnList);
+                    break;
+                }
+            }
+        }
+
+        private void FindColumns(MethodCallExpression methodCallExpression, IList<TableColumn> columnList)
+        {
+            if (methodCallExpression.Method.Name == "get_Item" &&
+                methodCallExpression.Arguments.Count == 1 &&
+                methodCallExpression.Arguments[0].Type == typeof(string))
+            {
+                string selector = null;
+                MemberExpression objectMemberExpression;
+                ParameterExpression objectParameterExpression;
+                if ((objectParameterExpression = methodCallExpression.Object as ParameterExpression) != null)
+                {
+                    selector = objectParameterExpression.Name;
+                }
+                else if ((objectMemberExpression = methodCallExpression.Object as MemberExpression) != null)
+                {
+                    selector = objectMemberExpression.Member.Name;
+                }
+
+                if (selector != null)
+                {
+                    for (int i = 0; i < this.tables.Count; i++)
+                    {
+                        if (this.selectors[i] == selector)
+                        {
+                            LambdaExpression argumentExpression =
+                                Expression.Lambda(methodCallExpression.Arguments[0]);
+                            string columnName = (string)
+                                argumentExpression.Compile().DynamicInvoke();
+                            ColumnInfo column = this.tables[i].Columns[columnName];
+                            columnList.Add(new TableColumn(this.tables[i], column));
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if (methodCallExpression.Object != null && methodCallExpression.Object.NodeType != ExpressionType.Parameter)
+            {
+                this.FindColumns(methodCallExpression.Object, columnList);
+            }
+        }
+
+        internal void PerformJoin(
+            TableInfo tableInfo,
+            Type recordType,
+            IQueryable joinTable,
+            LambdaExpression outerKeySelector,
+            LambdaExpression innerKeySelector,
+            LambdaExpression resultSelector)
+        {
+            if (joinTable == null)
+            {
+                throw new ArgumentNullException("joinTable");
+            }
+
+            if (tableInfo != null)
+            {
+                this.tables.Add(tableInfo);
+                this.recordTypes.Add(recordType);
+                this.selectors.Add(outerKeySelector.Parameters[0].Name);
+            }
+
+            PropertyInfo tableInfoProp = joinTable.GetType().GetProperty("TableInfo");
+            if (tableInfoProp == null)
+            {
+                throw new NotSupportedException(
+                    "Cannot join with object: " + joinTable.GetType().Name +
+                    "; join is only supported on another QTable.");
+            }
+
+            TableInfo joinTableInfo = (TableInfo) tableInfoProp.GetValue(joinTable, null);
+            if (joinTableInfo == null)
+            {
+                throw new InvalidOperationException("Missing join table info.");
+            }
+
+            this.tables.Add(joinTableInfo);
+            this.recordTypes.Add(joinTable.ElementType);
+            this.selectors.Add(innerKeySelector.Parameters[0].Name);
+            this.projectionDelegates.Add(resultSelector.Compile());
+
+            int joinColumnCount = this.joinColumns.Count;
+            this.FindColumns(outerKeySelector.Body, this.joinColumns);
+            if (this.joinColumns.Count > joinColumnCount + 1)
+            {
+                throw new NotSupportedException("Join operations involving " +
+                  "multiple columns are not supported.");
+            }
+            else if (this.joinColumns.Count != joinColumnCount + 1)
+            {
+                throw new InvalidOperationException("Bad outer key selector for join.");
+            }
+
+            this.FindColumns(innerKeySelector.Body, this.joinColumns);
+            if (this.joinColumns.Count > joinColumnCount + 2)
+            {
+                throw new NotSupportedException("Join operations involving " +
+                  "multiple columns not are supported.");
+            }
+            if (this.joinColumns.Count != joinColumnCount + 2)
+            {
+                throw new InvalidOperationException("Bad inner key selector for join.");
+            }
+        }
+    }
+
+    internal class TableColumn
+    {
+        public TableColumn(TableInfo table, ColumnInfo column)
+        {
+            this.Table = table;
+            this.Column = column;
+        }
+
+        public TableInfo Table { get; set; }
+        public ColumnInfo Column { get; set; }
+    }
+}
diff --git a/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/WixToolset.Dtf.WindowsInstaller.Linq.csproj b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/WixToolset.Dtf.WindowsInstaller.Linq.csproj
new file mode 100644
index 00000000..b4587071
--- /dev/null
+++ b/src/dtf/WixToolset.Dtf.WindowsInstaller.Linq/WixToolset.Dtf.WindowsInstaller.Linq.csproj
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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. -->
+
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <RootNamespace>WixToolset.Dtf.WindowsInstaller.Linq</RootNamespace>
+    <AssemblyName>WixToolset.Dtf.WindowsInstaller.Linq</AssemblyName>
+    <TargetFrameworks>netstandard2.0;net35</TargetFrameworks>
+    <Description>LINQ extensions for Windows Installer classes</Description>
+    <CreateDocumentationFile>true</CreateDocumentationFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WixToolset.Dtf.WindowsInstaller\WixToolset.Dtf.WindowsInstaller.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+    <PackageReference Include="Nerdbank.GitVersioning" Version="3.3.37" PrivateAssets="All" />
+  </ItemGroup>
+</Project>