1 files changed, 296 insertions, 0 deletions

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;
+        }
+    }
+}