1 files changed, 267 insertions, 0 deletions

diff --git a/src/api/wix/WixToolset.Data/WindowsInstaller/TableDefinition.cs b/src/api/wix/WixToolset.Data/WindowsInstaller/TableDefinition.cs
new file mode 100644
index 00000000..a7602d05
--- /dev/null
+++ b/src/api/wix/WixToolset.Data/WindowsInstaller/TableDefinition.cs
@@ -0,0 +1,267 @@
+// 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.Data.WindowsInstaller
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Xml;
+
+    /// <summary>
+    /// Definition of a table in a database.
+    /// </summary>
+    public sealed class TableDefinition : IComparable<TableDefinition>
+    {
+        /// <summary>
+        /// Tracks the maximum number of columns supported in a real table.
+        /// This is a Windows Installer limitation.
+        /// </summary>
+        public const int MaxColumnsInRealTable = 32;
+
+        /// <summary>
+        /// Creates a table definition.
+        /// </summary>
+        /// <param name="name">Name of table to create.</param>
+        /// <param name="symbolDefinition">Optional symbol definition for this table.</param>
+        /// <param name="columns">Column definitions for the table.</param>
+        /// <param name="unreal">Flag if table is unreal.</param>
+        /// <param name="symbolIdIsPrimaryKey">Whether the primary key is the id of the symbol definition associated with this table.</param>
+        /// <param name="strongRowType">The specialized type for the rows.</param>
+        public TableDefinition(string name, IntermediateSymbolDefinition symbolDefinition, IEnumerable<ColumnDefinition> columns, bool unreal = false, bool symbolIdIsPrimaryKey = false, Type strongRowType = null)
+        {
+            this.Name = name;
+            this.SymbolDefinition = symbolDefinition;
+            this.SymbolIdIsPrimaryKey = symbolIdIsPrimaryKey;
+            this.Unreal = unreal;
+            this.Columns = columns?.ToArray();
+            this.StrongRowType = strongRowType ?? typeof(Row);
+
+            if (this.Columns == null || this.Columns.Length == 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(columns));
+            }
+#if DEBUG
+            if (this.StrongRowType != typeof(Row) && !this.StrongRowType.IsSubclassOf(typeof(Row))) { throw new ArgumentException(nameof(strongRowType)); }
+#endif
+        }
+
+        /// <summary>
+        /// Gets the name of the table.
+        /// </summary>
+        /// <value>Name of the table.</value>
+        public string Name { get; }
+
+        /// <summary>
+        /// Gets the symbol definition associated with this table.
+        /// </summary>
+        /// <value>The symbol definition.</value>
+        public IntermediateSymbolDefinition SymbolDefinition { get; }
+
+        /// <summary>
+        /// Gets if the table is unreal.
+        /// </summary>
+        /// <value>Flag if table is unreal.</value>
+        public bool Unreal { get; }
+
+        /// <summary>
+        /// Gets the collection of column definitions for this table.
+        /// </summary>
+        /// <value>Collection of column definitions for this table.</value>
+        public ColumnDefinition[] Columns { get; }
+
+        /// <summary>
+        /// Gets if the primary key is the id of the symbol definition associated with this table.
+        /// </summary>
+        /// <value>Flag if table is unreal.</value>
+        public bool SymbolIdIsPrimaryKey { get; }
+
+        private Type StrongRowType { get; }
+
+        /// <summary>
+        /// Gets the column definition in the table by index.
+        /// </summary>
+        /// <param name="columnIndex">Index of column to locate.</param>
+        /// <value>Column definition in the table by index.</value>
+        public ColumnDefinition this[int columnIndex] => this.Columns[columnIndex];
+
+        /// <summary>
+        /// In general this method shouldn't be used - create rows from a Table instead.
+        /// Creates a new row object of the type specified in this definition.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Original source lines for this row.</param>
+        /// <returns>Created row.</returns>
+        public Row CreateRow(SourceLineNumber sourceLineNumbers)
+        {
+            var result = (Row)Activator.CreateInstance(this.StrongRowType, sourceLineNumbers, this);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new row object of the type specified in this definition for the given table.
+        /// External callers should create the row from the table.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Original source lines for this row.</param>
+        /// <param name="table">The owning table for this row.</param>
+        /// <returns>Created row.</returns>
+        internal Row CreateRow(SourceLineNumber sourceLineNumbers, Table table)
+        {
+            var result = (Row)Activator.CreateInstance(this.StrongRowType, sourceLineNumbers, table);
+            return result;
+        }
+
+        /// <summary>
+        /// Compares this table definition to another table definition.
+        /// </summary>
+        /// <remarks>
+        /// Only Windows Installer traits are compared, allowing for updates to WiX-specific table definitions.
+        /// </remarks>
+        /// <param name="updated">The updated <see cref="TableDefinition"/> to compare with this target definition.</param>
+        /// <returns>0 if the tables' core properties are the same; otherwise, non-0.</returns>
+        public int CompareTo(TableDefinition updated)
+        {
+            // by definition, this object is greater than null
+            if (null == updated)
+            {
+                return 1;
+            }
+
+            // compare the table names
+            var ret = String.Compare(this.Name, updated.Name, StringComparison.Ordinal);
+
+            // compare the column count
+            if (0 == ret)
+            {
+                // transforms can only add columns
+                ret = Math.Min(0, updated.Columns.Length - this.Columns.Length);
+
+                // compare name, type, and length of each column
+                for (var i = 0; 0 == ret && this.Columns.Length > i; i++)
+                {
+                    var thisColumnDef = this.Columns[i];
+                    var updatedColumnDef = updated.Columns[i];
+
+                    // Igmore unreal columns when comparing table definitions.
+                    if (thisColumnDef.Unreal || updatedColumnDef.Unreal)
+                    {
+                        continue;
+                    }
+
+                    ret = thisColumnDef.CompareTo(updatedColumnDef);
+                }
+            }
+
+            return ret;
+        }
+
+        /// <summary>
+        /// Parses table definition from xml reader.
+        /// </summary>
+        /// <param name="reader">Reader to get data from.</param>
+        /// <param name="tableDefinitions">Table definitions to use for strongly-typed rows.</param>
+        /// <returns>The TableDefintion represented by the Xml.</returns>
+        internal static TableDefinition Read(XmlReader reader, TableDefinitionCollection tableDefinitions)
+        {
+            var empty = reader.IsEmptyElement;
+            string name = null;
+            IntermediateSymbolDefinition symbolDefinition = null;
+            var unreal = false;
+            var symbolIdIsPrimaryKey = false;
+            Type strongRowType = null;
+
+            while (reader.MoveToNextAttribute())
+            {
+                switch (reader.LocalName)
+                {
+                    case "name":
+                        name = reader.Value;
+                        break;
+                    case "unreal":
+                        unreal = reader.Value.Equals("yes");
+                        break;
+                }
+            }
+
+            if (null == name)
+            {
+                throw new XmlException();
+            }
+
+            if (tableDefinitions.TryGet(name, out var tableDefinition))
+            {
+                symbolDefinition = tableDefinition.SymbolDefinition;
+                symbolIdIsPrimaryKey = tableDefinition.SymbolIdIsPrimaryKey;
+                strongRowType = tableDefinition.StrongRowType;
+            }
+
+            var columns = new List<ColumnDefinition>();
+            var hasPrimaryKeyColumn = false;
+
+            // parse the child elements
+            if (!empty)
+            {
+                var done = false;
+
+                while (!done && reader.Read())
+                {
+                    switch (reader.NodeType)
+                    {
+                        case XmlNodeType.Element:
+                            switch (reader.LocalName)
+                            {
+                                case "columnDefinition":
+                                    var columnDefinition = ColumnDefinition.Read(reader);
+                                    columns.Add(columnDefinition);
+
+                                    if (columnDefinition.PrimaryKey)
+                                    {
+                                        hasPrimaryKeyColumn = true;
+                                    }
+                                    break;
+                                default:
+                                    throw new XmlException();
+                            }
+                            break;
+                        case XmlNodeType.EndElement:
+                            done = true;
+                            break;
+                    }
+                }
+
+                if (!unreal && !hasPrimaryKeyColumn)
+                {
+                    throw new WixException(ErrorMessages.RealTableMissingPrimaryKeyColumn(SourceLineNumber.CreateFromUri(reader.BaseURI), name));
+                }
+
+                if (!done)
+                {
+                    throw new XmlException();
+                }
+            }
+
+            return new TableDefinition(name, symbolDefinition, columns.ToArray(), unreal, symbolIdIsPrimaryKey, strongRowType);
+        }
+
+        /// <summary>
+        /// Persists an output in an XML format.
+        /// </summary>
+        /// <param name="writer">XmlWriter where the Output should persist itself as XML.</param>
+        internal void Write(XmlWriter writer)
+        {
+            writer.WriteStartElement("tableDefinition", TableDefinitionCollection.XmlNamespaceUri);
+
+            writer.WriteAttributeString("name", this.Name);
+
+            if (this.Unreal)
+            {
+                writer.WriteAttributeString("unreal", "yes");
+            }
+
+            foreach (var columnDefinition in this.Columns)
+            {
+                columnDefinition.Write(writer);
+            }
+
+            writer.WriteEndElement();
+        }
+    }
+}