1 files changed, 992 insertions, 0 deletions

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