Move Sql.wixext into ext

15 files changed, 1982 insertions, 0 deletions

diff --git a/src/ext/Sql/wixext/SqlCompiler.cs b/src/ext/Sql/wixext/SqlCompiler.cs
new file mode 100644
index 00000000..46196e95
--- /dev/null
+++ b/src/ext/Sql/wixext/SqlCompiler.cs
@@ -0,0 +1,804 @@
+// 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.Sql
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Extensibility.Data;
+    using WixToolset.Sql.Symbols;
+
+    /// <summary>
+    /// The compiler for the WiX Toolset SQL Server Extension.
+    /// </summary>
+    public sealed class SqlCompiler : BaseCompilerExtension
+    {
+        // sql database attributes definitions (from sca.h)
+        internal const int DbCreateOnInstall = 0x00000001;
+        internal const int DbDropOnUninstall = 0x00000002;
+        internal const int DbContinueOnError = 0x00000004;
+        internal const int DbDropOnInstall = 0x00000008;
+        internal const int DbCreateOnUninstall = 0x00000010;
+        internal const int DbConfirmOverwrite = 0x00000020;
+        internal const int DbCreateOnReinstall = 0x00000040;
+        internal const int DbDropOnReinstall = 0x00000080;
+
+        // sql string/script attributes definitions (from sca.h)
+        internal const int SqlExecuteOnInstall = 0x00000001;
+        internal const int SqlExecuteOnUninstall = 0x00000002;
+        internal const int SqlContinueOnError = 0x00000004;
+        internal const int SqlRollback = 0x00000008;
+        internal const int SqlExecuteOnReinstall = 0x00000010;
+
+        public override XNamespace Namespace => "http://wixtoolset.org/schemas/v4/wxs/sql";
+
+        /// <summary>
+        /// Processes an element for the Compiler.
+        /// </summary>
+        /// <param name="intermediate"></param>
+        /// <param name="section"></param>
+        /// <param name="parentElement">Parent element of element to process.</param>
+        /// <param name="element">Element to process.</param>
+        /// <param name="context">Extra information about the context in which this element is being parsed.</param>
+        public override void ParseElement(Intermediate intermediate, IntermediateSection section, XElement parentElement, XElement element, IDictionary<string, string> context)
+        {
+            switch (parentElement.Name.LocalName)
+            {
+                case "Component":
+                    var componentId = context["ComponentId"];
+
+                    switch (element.Name.LocalName)
+                    {
+                        case "SqlDatabase":
+                            this.ParseSqlDatabaseElement(intermediate, section, element, componentId);
+                            break;
+                        case "SqlScript":
+                            this.ParseSqlScriptElement(intermediate, section, element, componentId, null);
+                            break;
+                        case "SqlString":
+                            this.ParseSqlStringElement(intermediate, section, element, componentId, null);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(parentElement, element);
+                            break;
+                    }
+                    break;
+                case "Fragment":
+                case "Module":
+                case "Package":
+                    switch (element.Name.LocalName)
+                    {
+                        case "SqlDatabase":
+                            this.ParseSqlDatabaseElement(intermediate, section, element, null);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(parentElement, element);
+                            break;
+                    }
+                    break;
+                default:
+                    this.ParseHelper.UnexpectedElement(parentElement, element);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Parses a sql database element
+        /// </summary>
+        /// <param name="intermediate"></param>
+        /// <param name="section"></param>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier for parent component.</param>
+        private void ParseSqlDatabaseElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            int attributes = 0;
+            string database = null;
+            Identifier fileSpec = null;
+            string instance = null;
+            Identifier logFileSpec = null;
+            string server = null;
+            string user = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "ConfirmOverwrite":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= DbConfirmOverwrite;
+                            }
+                            break;
+                        case "ContinueOnError":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= DbContinueOnError;
+                            }
+                            break;
+                        case "CreateOnInstall":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= DbCreateOnInstall;
+                            }
+                            break;
+                        case "CreateOnReinstall":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= DbCreateOnReinstall;
+                            }
+                            break;
+                        case "CreateOnUninstall":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= DbCreateOnUninstall;
+                            }
+                            break;
+                        case "Database":
+                            database = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DropOnInstall":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= DbDropOnInstall;
+                            }
+                            break;
+                        case "DropOnReinstall":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= DbDropOnReinstall;
+                            }
+                            break;
+
+                        case "DropOnUninstall":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= DbDropOnUninstall;
+                            }
+                            break;
+                        case "Instance":
+                            instance = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Server":
+                            server = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "User":
+                            user = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (!this.ParseHelper.ContainsProperty(user))
+                            {
+                                user = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                                this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, "User", user);
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("sdb", componentId, server, database);
+            }
+
+            if (null == database)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Database"));
+            }
+            else if (128 < database.Length)
+            {
+                this.Messaging.Write(ErrorMessages.IdentifierTooLongError(sourceLineNumbers, element.Name.LocalName, "Database", database, 128));
+            }
+
+            if (null == server)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Server"));
+            }
+
+            if (0 == attributes && null != componentId)
+            {
+                this.Messaging.Write(SqlErrors.OneOfAttributesRequiredUnderComponent(sourceLineNumbers, element.Name.LocalName, "CreateOnInstall", "CreateOnUninstall", "DropOnInstall", "DropOnUninstall"));
+            }
+
+            foreach (var child in element.Elements())
+            {
+                if (this.Namespace == child.Name.Namespace)
+                {
+                    var childSourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(child);
+                    switch (child.Name.LocalName)
+                    {
+                        case "SqlScript":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalElementWithoutComponent(childSourceLineNumbers, child.Name.LocalName));
+                            }
+
+                            this.ParseSqlScriptElement(intermediate, section, child, componentId, id?.Id);
+                            break;
+                        case "SqlString":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalElementWithoutComponent(childSourceLineNumbers, child.Name.LocalName));
+                            }
+
+                            this.ParseSqlStringElement(intermediate, section, child, componentId, id?.Id);
+                            break;
+                        case "SqlFileSpec":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalElementWithoutComponent(childSourceLineNumbers, child.Name.LocalName));
+                            }
+                            else if (null != fileSpec)
+                            {
+                                this.Messaging.Write(ErrorMessages.TooManyElements(sourceLineNumbers, element.Name.LocalName, child.Name.LocalName, 1));
+                            }
+
+                            fileSpec = this.ParseSqlFileSpecElement(intermediate, section, child, id?.Id);
+                            break;
+                        case "SqlLogFileSpec":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(SqlErrors.IllegalElementWithoutComponent(childSourceLineNumbers, child.Name.LocalName));
+                            }
+                            else if (null != logFileSpec)
+                            {
+                                this.Messaging.Write(ErrorMessages.TooManyElements(sourceLineNumbers, element.Name.LocalName, child.Name.LocalName, 1));
+                            }
+
+                            logFileSpec = this.ParseSqlFileSpecElement(intermediate, section, child, id?.Id);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(element, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionElement(this.Context.Extensions, intermediate, section, element, child);
+                }
+            }
+
+            if (null != componentId)
+            {
+                // Reference InstallSqlData and UninstallSqlData since nothing will happen without it
+                this.AddReferenceToInstallSqlData(section, sourceLineNumbers);
+            }
+
+            if (!this.Messaging.EncounteredError)
+            {
+                var symbol = section.AddSymbol(new SqlDatabaseSymbol(sourceLineNumbers, id)
+                {
+                    Server = server,
+                    Instance = instance,
+                    Database = database,
+                    ComponentRef = componentId,
+                    UserRef = user,
+                    FileSpecRef = fileSpec?.Id,
+                    LogFileSpecRef = logFileSpec?.Id,
+                });
+
+                if (0 != attributes)
+                {
+                    symbol.Attributes = attributes;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a sql file specification element.
+        /// </summary>
+        /// <param name="intermediate"></param>
+        /// <param name="section"></param>
+        /// <param name="element">Element to parse.</param>
+        /// <returns>Identifier of sql file specification.</returns>
+        private Identifier ParseSqlFileSpecElement(Intermediate intermediate, IntermediateSection section, XElement element, string parentId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string fileName = null;
+            string growthSize = null;
+            string maxSize = null;
+            string name = null;
+            string size = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Filename":
+                            fileName = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Size":
+                            size = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MaxSize":
+                            maxSize = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "GrowthSize":
+                            growthSize = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("sfs", parentId, name, fileName);
+            }
+
+            if (null == name)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Name"));
+            }
+
+            if (null == fileName)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Filename"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                var symbol = section.AddSymbol(new SqlFileSpecSymbol(sourceLineNumbers, id)
+                {
+                    Name = name,
+                    Filename = fileName,
+                });
+
+                if (null != size)
+                {
+                    symbol.Size = size;
+                }
+
+                if (null != maxSize)
+                {
+                    symbol.MaxSize = maxSize;
+                }
+
+                if (null != growthSize)
+                {
+                    symbol.GrowthSize = growthSize;
+                }
+            }
+
+            return id;
+        }
+
+        /// <summary>
+        /// Parses a sql script element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier for parent component.</param>
+        /// <param name="sqlDb">Optional database to execute script against.</param>
+        private void ParseSqlScriptElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, string sqlDb)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            int attributes = 0;
+            var rollbackAttribute = false;
+            var nonRollbackAttribute = false;
+            string binaryRef = null;
+            var sequence = CompilerConstants.IntegerNotSet;
+            string user = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "BinaryRef":
+                            binaryRef = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.Binary, binaryRef);
+                            break;
+                        case "Sequence":
+                            sequence = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, short.MaxValue);
+                            break;
+                        case "SqlDb":
+                            if (null != sqlDb)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWhenNested(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, element.Parent.Name.LocalName));
+                            }
+                            sqlDb = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SqlSymbolDefinitions.SqlDatabase, sqlDb);
+                            break;
+                        case "User":
+                            user = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, "User", user);
+                            break;
+
+                        // Flag-setting attributes
+                        case "ContinueOnError":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlContinueOnError;
+                            }
+                            break;
+                        case "ExecuteOnInstall":
+                            if (rollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "RollbackOnInstall", "RollbackOnReinstall", "RollbackOnUninstall"));
+                            }
+                            nonRollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnInstall;
+                            }
+                            break;
+                        case "ExecuteOnReinstall":
+                            if (rollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "RollbackOnInstall", "RollbackOnReinstall", "RollbackOnUninstall"));
+                            }
+                            nonRollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnReinstall;
+                            }
+                            break;
+                        case "ExecuteOnUninstall":
+                            if (rollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "RollbackOnInstall", "RollbackOnReinstall", "RollbackOnUninstall"));
+                            }
+                            nonRollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnUninstall;
+                            }
+                            break;
+                        case "RollbackOnInstall":
+                            if (nonRollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "ExecuteOnInstall", "ExecuteOnReinstall", "ExecuteOnUninstall"));
+                            }
+                            rollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnInstall;
+                                attributes |= SqlRollback;
+                            }
+                            break;
+                        case "RollbackOnReinstall":
+                            if (nonRollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "ExecuteOnInstall", "ExecuteOnReinstall", "ExecuteOnUninstall"));
+                            }
+                            rollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnReinstall;
+                                attributes |= SqlRollback;
+                            }
+                            break;
+                        case "RollbackOnUninstall":
+                            if (nonRollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "ExecuteOnInstall", "ExecuteOnReinstall", "ExecuteOnUninstall"));
+                            }
+                            rollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnUninstall;
+                                attributes |= SqlRollback;
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("ssc", componentId, binaryRef, sqlDb);
+            }
+
+            if (null == binaryRef)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "BinaryRef"));
+            }
+
+            if (null == sqlDb)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "SqlDb"));
+            }
+
+            if (0 == attributes)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttributes(sourceLineNumbers, element.Name.LocalName, "ExecuteOnInstall", "ExecuteOnReinstall", "ExecuteOnUninstall", "RollbackOnInstall", "RollbackOnReinstall", "RollbackOnUninstall"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            // Reference InstallSqlData and UninstallSqlData since nothing will happen without it
+            this.AddReferenceToInstallSqlData(section, sourceLineNumbers);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                var symbol = section.AddSymbol(new SqlScriptSymbol(sourceLineNumbers, id)
+                {
+                    SqlDbRef = sqlDb,
+                    ComponentRef = componentId,
+                    ScriptBinaryRef = binaryRef,
+                    UserRef = user,
+                    Attributes = attributes,
+                });
+
+                if (CompilerConstants.IntegerNotSet != sequence)
+                {
+                    symbol.Sequence = sequence;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a sql string element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier for parent component.</param>
+        /// <param name="sqlDb">Optional database to execute string against.</param>
+        private void ParseSqlStringElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, string sqlDb)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            int attributes = 0;
+            var rollbackAttribute = false;
+            var nonRollbackAttribute = false;
+            var sequence = CompilerConstants.IntegerNotSet;
+            string sql = null;
+            string user = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "ContinueOnError":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlContinueOnError;
+                            }
+                            break;
+                        case "ExecuteOnInstall":
+                            if (rollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "RollbackOnInstall", "RollbackOnReinstall", "RollbackOnUninstall"));
+                            }
+                            nonRollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnInstall;
+                            }
+                            break;
+                        case "ExecuteOnReinstall":
+                            if (rollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "RollbackOnInstall", "RollbackOnReinstall", "RollbackOnUninstall"));
+                            }
+                            nonRollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnReinstall;
+                            }
+                            break;
+                        case "ExecuteOnUninstall":
+                            if (rollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "RollbackOnInstall", "RollbackOnReinstall", "RollbackOnUninstall"));
+                            }
+                            nonRollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnUninstall;
+                            }
+                            break;
+                        case "RollbackOnInstall":
+                            if (nonRollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "ExecuteOnInstall", "ExecuteOnReinstall", "ExecuteOnUninstall"));
+                            }
+                            rollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnInstall;
+                                attributes |= SqlRollback;
+                            }
+                            break;
+                        case "RollbackOnReinstall":
+                            if (nonRollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "ExecuteOnInstall", "ExecuteOnReinstall", "ExecuteOnUninstall"));
+                            }
+                            rollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnReinstall;
+                                attributes |= SqlRollback;
+                            }
+                            break;
+                        case "RollbackOnUninstall":
+                            if (nonRollbackAttribute)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, "ExecuteOnInstall", "ExecuteOnReinstall", "ExecuteOnUninstall"));
+                            }
+                            rollbackAttribute = true;
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= SqlExecuteOnUninstall;
+                                attributes |= SqlRollback;
+                            }
+                            break;
+                        case "Sequence":
+                            sequence = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, short.MaxValue);
+                            break;
+                        case "SQL":
+                            sql = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SqlDb":
+                            if (null != sqlDb)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWhenNested(sourceLineNumbers, element.Name.LocalName, "SqlDb", "SqlDatabase"));
+                            }
+
+                            sqlDb = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SqlSymbolDefinitions.SqlDatabase, sqlDb);
+                            break;
+                        case "User":
+                            user = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, "User", user);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("sst", componentId, sql, sqlDb);
+            }
+
+            if (null == sql)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "SQL"));
+            }
+
+            if (null == sqlDb)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "SqlDb"));
+            }
+
+            if (0 == attributes)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttributes(sourceLineNumbers, element.Name.LocalName, "ExecuteOnInstall", "ExecuteOnReinstall", "ExecuteOnUninstall", "RollbackOnInstall", "RollbackOnReinstall", "RollbackOnUninstall"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            // Reference InstallSqlData and UninstallSqlData since nothing will happen without it
+            this.AddReferenceToInstallSqlData(section, sourceLineNumbers);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                var symbol = section.AddSymbol(new SqlStringSymbol(sourceLineNumbers, id)
+                {
+                    SqlDbRef = sqlDb,
+                    ComponentRef = componentId,
+                    SQL = sql,
+                    UserRef = user,
+                    Attributes = attributes,
+                });
+
+                if (CompilerConstants.IntegerNotSet != sequence)
+                {
+                    symbol.Sequence = sequence;
+                }
+            }
+        }
+
+        private void AddReferenceToInstallSqlData(IntermediateSection section, SourceLineNumber sourceLineNumbers)
+        {
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4InstallSqlData", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4UninstallSqlData", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+        }
+    }
+}
diff --git a/src/ext/Sql/wixext/SqlDecompiler.cs b/src/ext/Sql/wixext/SqlDecompiler.cs
new file mode 100644
index 00000000..52436b87
--- /dev/null
+++ b/src/ext/Sql/wixext/SqlDecompiler.cs
@@ -0,0 +1,514 @@
+// 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.Sql
+{
+#if TODO_CONSIDER_DECOMPILER
+    using System.Collections;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using Sql = WixToolset.Extensions.Serialize.Sql;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The decompiler for the WiX Toolset SQL Server Extension.
+    /// </summary>
+    public sealed class SqlDecompiler : DecompilerExtension
+    {
+        /// <summary>
+        /// Creates a decompiler for SQL Extension.
+        /// </summary>
+        public SqlDecompiler()
+        {
+            this.TableDefinitions = SqlExtensionData.GetExtensionTableDefinitions();
+        }
+
+        /// <summary>
+        /// Get the extensions library to be removed.
+        /// </summary>
+        /// <param name="tableDefinitions">Table definitions for library.</param>
+        /// <returns>Library to remove from decompiled output.</returns>
+        public override Library GetLibraryToRemove(TableDefinitionCollection tableDefinitions)
+        {
+            return SqlExtensionData.GetExtensionLibrary(tableDefinitions);
+        }
+
+        /// <summary>
+        /// Decompiles an extension table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        public override void DecompileTable(Table table)
+        {
+            switch (table.Name)
+            {
+                case "SqlDatabase":
+                    this.DecompileSqlDatabaseTable(table);
+                    break;
+                case "SqlFileSpec":
+                    // handled in FinalizeSqlFileSpecTable
+                    break;
+                case "SqlScript":
+                    this.DecompileSqlScriptTable(table);
+                    break;
+                case "SqlString":
+                    this.DecompileSqlStringTable(table);
+                    break;
+                default:
+                    base.DecompileTable(table);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Finalize decompilation.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        public override void Finish(TableIndexedCollection tables)
+        {
+            this.FinalizeSqlFileSpecTable(tables);
+            this.FinalizeSqlScriptAndSqlStringTables(tables);
+        }
+
+        /// <summary>
+        /// Decompile the SqlDatabase table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileSqlDatabaseTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Sql.SqlDatabase sqlDatabase = new Sql.SqlDatabase();
+
+                sqlDatabase.Id = (string)row[0];
+
+                if (null != row[1])
+                {
+                    sqlDatabase.Server = (string)row[1];
+                }
+
+                if (null != row[2])
+                {
+                    sqlDatabase.Instance = (string)row[2];
+                }
+
+                sqlDatabase.Database = (string)row[3];
+
+                if (null != row[5])
+                {
+                    sqlDatabase.User = (string)row[5];
+                }
+
+                // the FileSpec_ and FileSpec_Log columns will be handled in FinalizeSqlFileSpecTable
+
+                if (null != row[8])
+                {
+                    int attributes = (int)row[8];
+
+                    if (SqlCompiler.DbCreateOnInstall == (attributes & SqlCompiler.DbCreateOnInstall))
+                    {
+                        sqlDatabase.CreateOnInstall = Sql.YesNoType.yes;
+                    }
+
+                    if (SqlCompiler.DbDropOnUninstall == (attributes & SqlCompiler.DbDropOnUninstall))
+                    {
+                        sqlDatabase.DropOnUninstall = Sql.YesNoType.yes;
+                    }
+
+                    if (SqlCompiler.DbContinueOnError == (attributes & SqlCompiler.DbContinueOnError))
+                    {
+                        sqlDatabase.ContinueOnError = Sql.YesNoType.yes;
+                    }
+
+                    if (SqlCompiler.DbDropOnInstall == (attributes & SqlCompiler.DbDropOnInstall))
+                    {
+                        sqlDatabase.DropOnInstall = Sql.YesNoType.yes;
+                    }
+
+                    if (SqlCompiler.DbCreateOnUninstall == (attributes & SqlCompiler.DbCreateOnUninstall))
+                    {
+                        sqlDatabase.CreateOnUninstall = Sql.YesNoType.yes;
+                    }
+
+                    if (SqlCompiler.DbConfirmOverwrite == (attributes & SqlCompiler.DbConfirmOverwrite))
+                    {
+                        sqlDatabase.ConfirmOverwrite = Sql.YesNoType.yes;
+                    }
+
+                    if (SqlCompiler.DbCreateOnReinstall == (attributes & SqlCompiler.DbCreateOnReinstall))
+                    {
+                        sqlDatabase.CreateOnReinstall = Sql.YesNoType.yes;
+                    }
+
+                    if (SqlCompiler.DbDropOnReinstall == (attributes & SqlCompiler.DbDropOnReinstall))
+                    {
+                        sqlDatabase.DropOnReinstall = Sql.YesNoType.yes;
+                    }
+                }
+
+                if (null != row[4])
+                {
+                    Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[4]);
+
+                    if (null != component)
+                    {
+                        component.AddChild(sqlDatabase);
+                    }
+                    else
+                    {
+                        this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[4], "Component"));
+                    }
+                }
+                else
+                {
+                    this.Core.RootElement.AddChild(sqlDatabase);
+                }
+                this.Core.IndexElement(row, sqlDatabase);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the SqlScript table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileSqlScriptTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Sql.SqlScript sqlScript = new Sql.SqlScript();
+
+                sqlScript.Id = (string)row[0];
+
+                // the Db_ and Component_ columns are handled in FinalizeSqlScriptAndSqlStringTables
+
+                sqlScript.BinaryKey = (string)row[3];
+
+                if (null != row[4])
+                {
+                    sqlScript.User = (string)row[4];
+                }
+
+                int attributes = (int)row[5];
+
+                if (SqlCompiler.SqlContinueOnError == (attributes & SqlCompiler.SqlContinueOnError))
+                {
+                    sqlScript.ContinueOnError = Sql.YesNoType.yes;
+                }
+
+                if (SqlCompiler.SqlExecuteOnInstall == (attributes & SqlCompiler.SqlExecuteOnInstall))
+                {
+                    sqlScript.ExecuteOnInstall = Sql.YesNoType.yes;
+                }
+
+                if (SqlCompiler.SqlExecuteOnReinstall == (attributes & SqlCompiler.SqlExecuteOnReinstall))
+                {
+                    sqlScript.ExecuteOnReinstall = Sql.YesNoType.yes;
+                }
+
+                if (SqlCompiler.SqlExecuteOnUninstall == (attributes & SqlCompiler.SqlExecuteOnUninstall))
+                {
+                    sqlScript.ExecuteOnUninstall = Sql.YesNoType.yes;
+                }
+
+                if ((SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnInstall) == (attributes & (SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnInstall)))
+                {
+                    sqlScript.RollbackOnInstall = Sql.YesNoType.yes;
+                }
+
+                if ((SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnReinstall) == (attributes & (SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnReinstall)))
+                {
+                    sqlScript.RollbackOnReinstall = Sql.YesNoType.yes;
+                }
+
+                if ((SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnUninstall) == (attributes & (SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnUninstall)))
+                {
+                    sqlScript.RollbackOnUninstall = Sql.YesNoType.yes;
+                }
+
+                if (null != row[6])
+                {
+                    sqlScript.Sequence = (int)row[6];
+                }
+
+                this.Core.IndexElement(row, sqlScript);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the SqlString table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileSqlStringTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Sql.SqlString sqlString = new Sql.SqlString();
+
+                sqlString.Id = (string)row[0];
+
+                // the Db_ and Component_ columns are handled in FinalizeSqlScriptAndSqlStringTables
+
+                sqlString.SQL = (string)row[3];
+
+                if (null != row[4])
+                {
+                    sqlString.User = (string)row[4];
+                }
+
+                int attributes = (int)row[5];
+
+                if (SqlCompiler.SqlContinueOnError == (attributes & SqlCompiler.SqlContinueOnError))
+                {
+                    sqlString.ContinueOnError = Sql.YesNoType.yes;
+                }
+
+                if (SqlCompiler.SqlExecuteOnInstall == (attributes & SqlCompiler.SqlExecuteOnInstall))
+                {
+                    sqlString.ExecuteOnInstall = Sql.YesNoType.yes;
+                }
+
+                if (SqlCompiler.SqlExecuteOnReinstall == (attributes & SqlCompiler.SqlExecuteOnReinstall))
+                {
+                    sqlString.ExecuteOnReinstall = Sql.YesNoType.yes;
+                }
+
+                if (SqlCompiler.SqlExecuteOnUninstall == (attributes & SqlCompiler.SqlExecuteOnUninstall))
+                {
+                    sqlString.ExecuteOnUninstall = Sql.YesNoType.yes;
+                }
+
+                if ((SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnInstall) == (attributes & (SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnInstall)))
+                {
+                    sqlString.RollbackOnInstall = Sql.YesNoType.yes;
+                }
+
+                if ((SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnReinstall) == (attributes & (SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnReinstall)))
+                {
+                    sqlString.RollbackOnReinstall = Sql.YesNoType.yes;
+                }
+
+                if ((SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnUninstall) == (attributes & (SqlCompiler.SqlRollback | SqlCompiler.SqlExecuteOnUninstall)))
+                {
+                    sqlString.RollbackOnUninstall = Sql.YesNoType.yes;
+                }
+
+                if (null != row[6])
+                {
+                    sqlString.Sequence = (int)row[6];
+                }
+
+                this.Core.IndexElement(row, sqlString);
+            }
+        }
+
+        /// <summary>
+        /// Finalize the SqlFileSpec table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Since rows of the SqlFileSpec table are represented by either
+        /// the SqlFileSpec or SqlLogFileSpec depending upon the context in
+        /// which they are used in the SqlDatabase table, decompilation of this
+        /// table must occur after the SqlDatbase parents are decompiled.
+        /// </remarks>
+        private void FinalizeSqlFileSpecTable(TableIndexedCollection tables)
+        {
+            Table sqlDatabaseTable = tables["SqlDatabase"];
+            Table sqlFileSpecTable = tables["SqlFileSpec"];
+
+            if (null != sqlDatabaseTable && null != sqlFileSpecTable)
+            {
+                Hashtable sqlFileSpecRows = new Hashtable();
+
+                // index each SqlFileSpec row by its primary key
+                foreach (Row row in sqlFileSpecTable.Rows)
+                {
+                    sqlFileSpecRows.Add(row[0], row);
+                }
+
+                // create the necessary SqlFileSpec and SqlLogFileSpec elements for each row
+                foreach (Row row in sqlDatabaseTable.Rows)
+                {
+                    Sql.SqlDatabase sqlDatabase = (Sql.SqlDatabase)this.Core.GetIndexedElement(row);
+
+                    if (null != row[6])
+                    {
+                        Row sqlFileSpecRow = (Row)sqlFileSpecRows[row[6]];
+
+                        if (null != sqlFileSpecRow)
+                        {
+                            Sql.SqlFileSpec sqlFileSpec = new Sql.SqlFileSpec();
+
+                            sqlFileSpec.Id = (string)sqlFileSpecRow[0];
+
+                            if (null != sqlFileSpecRow[1])
+                            {
+                                sqlFileSpec.Name = (string)sqlFileSpecRow[1];
+                            }
+
+                            sqlFileSpec.Filename = (string)sqlFileSpecRow[2];
+
+                            if (null != sqlFileSpecRow[3])
+                            {
+                                sqlFileSpec.Size = (string)sqlFileSpecRow[3];
+                            }
+
+                            if (null != sqlFileSpecRow[4])
+                            {
+                                sqlFileSpec.MaxSize = (string)sqlFileSpecRow[4];
+                            }
+
+                            if (null != sqlFileSpecRow[5])
+                            {
+                                sqlFileSpec.GrowthSize = (string)sqlFileSpecRow[5];
+                            }
+
+                            sqlDatabase.AddChild(sqlFileSpec);
+                        }
+                        else
+                        {
+                            this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, sqlDatabaseTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "FileSpec_", (string)row[6], "SqlFileSpec"));
+                        }
+                    }
+
+                    if (null != row[7])
+                    {
+                        Row sqlFileSpecRow = (Row)sqlFileSpecRows[row[7]];
+
+                        if (null != sqlFileSpecRow)
+                        {
+                            Sql.SqlLogFileSpec sqlLogFileSpec = new Sql.SqlLogFileSpec();
+
+                            sqlLogFileSpec.Id = (string)sqlFileSpecRow[0];
+
+                            if (null != sqlFileSpecRow[1])
+                            {
+                                sqlLogFileSpec.Name = (string)sqlFileSpecRow[1];
+                            }
+
+                            sqlLogFileSpec.Filename = (string)sqlFileSpecRow[2];
+
+                            if (null != sqlFileSpecRow[3])
+                            {
+                                sqlLogFileSpec.Size = (string)sqlFileSpecRow[3];
+                            }
+
+                            if (null != sqlFileSpecRow[4])
+                            {
+                                sqlLogFileSpec.MaxSize = (string)sqlFileSpecRow[4];
+                            }
+
+                            if (null != sqlFileSpecRow[5])
+                            {
+                                sqlLogFileSpec.GrowthSize = (string)sqlFileSpecRow[5];
+                            }
+
+                            sqlDatabase.AddChild(sqlLogFileSpec);
+                        }
+                        else
+                        {
+                            this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, sqlDatabaseTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "FileSpec_Log", (string)row[7], "SqlFileSpec"));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the SqlScript table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// The SqlScript and SqlString tables contain a foreign key into the SqlDatabase
+        /// and Component tables.  Depending upon the parent of the SqlDatabase
+        /// element, the SqlScript and SqlString elements are nested under either the
+        /// SqlDatabase or the Component element.
+        /// </remarks>
+        private void FinalizeSqlScriptAndSqlStringTables(TableIndexedCollection tables)
+        {
+            Table sqlDatabaseTable = tables["SqlDatabase"];
+            Table sqlScriptTable = tables["SqlScript"];
+            Table sqlStringTable = tables["SqlString"];
+
+            Hashtable sqlDatabaseRows = new Hashtable();
+
+            // index each SqlDatabase row by its primary key
+            if (null != sqlDatabaseTable)
+            {
+                foreach (Row row in sqlDatabaseTable.Rows)
+                {
+                    sqlDatabaseRows.Add(row[0], row);
+                }
+            }
+
+            if (null != sqlScriptTable)
+            {
+                foreach (Row row in sqlScriptTable.Rows)
+                {
+                    Sql.SqlScript sqlScript = (Sql.SqlScript)this.Core.GetIndexedElement(row);
+
+                    Row sqlDatabaseRow = (Row)sqlDatabaseRows[row[1]];
+                    string databaseComponent = (string)sqlDatabaseRow[4];
+
+                    // determine if the SqlScript element should be nested under the database or another component
+                    if (null != databaseComponent && databaseComponent == (string)row[2])
+                    {
+                        Sql.SqlDatabase sqlDatabase = (Sql.SqlDatabase)this.Core.GetIndexedElement(sqlDatabaseRow);
+
+                        sqlDatabase.AddChild(sqlScript);
+                    }
+                    else // nest under the component of the SqlDatabase row
+                    {
+                        Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[2]);
+
+                        // set the Database value
+                        sqlScript.SqlDb = (string)row[1];
+
+                        if (null != component)
+                        {
+                            component.AddChild(sqlScript);
+                        }
+                        else
+                        {
+                            this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, sqlScriptTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[2], "Component"));
+                        }
+                    }
+                }
+            }
+
+            if (null != sqlStringTable)
+            {
+                foreach (Row row in sqlStringTable.Rows)
+                {
+                    Sql.SqlString sqlString = (Sql.SqlString)this.Core.GetIndexedElement(row);
+
+                    Row sqlDatabaseRow = (Row)sqlDatabaseRows[row[1]];
+                    string databaseComponent = (string)sqlDatabaseRow[4];
+
+                    // determine if the SqlScript element should be nested under the database or another component
+                    if (null != databaseComponent && databaseComponent == (string)row[2])
+                    {
+                        Sql.SqlDatabase sqlDatabase = (Sql.SqlDatabase)this.Core.GetIndexedElement(sqlDatabaseRow);
+
+                        sqlDatabase.AddChild(sqlString);
+                    }
+                    else // nest under the component of the SqlDatabase row
+                    {
+                        Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[2]);
+
+                        // set the Database value
+                        sqlString.SqlDb = (string)row[1];
+
+                        if (null != component)
+                        {
+                            component.AddChild(sqlString);
+                        }
+                        else
+                        {
+                            this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, sqlStringTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[2], "Component"));
+                        }
+                    }
+                }
+            }
+        }
+    }
+#endif
+}
diff --git a/src/ext/Sql/wixext/SqlErrors.cs b/src/ext/Sql/wixext/SqlErrors.cs
new file mode 100644
index 00000000..f25728bd
--- /dev/null
+++ b/src/ext/Sql/wixext/SqlErrors.cs
@@ -0,0 +1,48 @@
+// 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.Sql
+{
+    using System.Resources;
+    using WixToolset.Data;
+
+    public static class SqlErrors
+    {
+        public static Message IllegalAttributeWithoutComponent(SourceLineNumber sourceLineNumbers, string elementName, string attributeName)
+        {
+            return Message(sourceLineNumbers, Ids.IllegalAttributeWithoutComponent, "The {0}/@{1} attribute cannot be specified unless the element has a Component as an ancestor. A {0} that does not have a Component ancestor is not installed.", elementName, attributeName);
+        }
+        
+        public static Message IllegalElementWithoutComponent(SourceLineNumber sourceLineNumbers, string elementName)
+        {
+            return Message(sourceLineNumbers, Ids.IllegalElementWithoutComponent, "The {0} element cannot be specified unless the element has a Component as an ancestor. A {0} that does not have a Component ancestor is not installed.", elementName);
+        }
+        
+        public static Message OneOfAttributesRequiredUnderComponent(SourceLineNumber sourceLineNumbers, string elementName, string attributeName1, string attributeName2, string attributeName3, string attributeName4)
+        {
+            return Message(sourceLineNumbers, Ids.OneOfAttributesRequiredUnderComponent, "When nested under a Component, the {0} element must have one of the following attributes specified: {1}, {2}, {3} or {4}.", elementName, attributeName1, attributeName2, attributeName3, attributeName4);
+        }
+        
+        public static Message DeprecatedBinaryChildElement(SourceLineNumber sourceLineNumbers, string elementName)
+        {
+            return Message(sourceLineNumbers, Ids.DeprecatedBinaryChildElement, "The {0} element contains a deprecated child Binary element.  Please move the Binary element under a Fragment, Module, or Product element and set the {0}/@BinaryKey attribute to the value of the Binary/@Id attribute.", elementName);
+        }
+
+        private static Message Message(SourceLineNumber sourceLineNumber, Ids id, string format, params object[] args)
+        {
+            return new Message(sourceLineNumber, MessageLevel.Error, (int)id, format, args);
+        }
+
+        private static Message Message(SourceLineNumber sourceLineNumber, Ids id, ResourceManager resourceManager, string resourceName, params object[] args)
+        {
+            return new Message(sourceLineNumber, MessageLevel.Error, (int)id, resourceManager, resourceName, args);
+        }
+
+        public enum Ids
+        {
+            IllegalAttributeWithoutComponent = 5100,
+            IllegalElementWithoutComponent = 5101,
+            OneOfAttributesRequiredUnderComponent = 5102,
+            DeprecatedBinaryChildElement = 5103,
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Sql/wixext/SqlExtensionData.cs b/src/ext/Sql/wixext/SqlExtensionData.cs
new file mode 100644
index 00000000..60de94fe
--- /dev/null
+++ b/src/ext/Sql/wixext/SqlExtensionData.cs
@@ -0,0 +1,30 @@
+// 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.Sql
+{
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// The WiX Toolset SQL Server Extension.
+    /// </summary>
+    public sealed class SqlExtensionData : BaseExtensionData
+    {
+        /// <summary>
+        /// Gets the default culture.
+        /// </summary>
+        /// <value>The default culture.</value>
+        public override string DefaultCulture => "en-US";
+
+        public override bool TryGetSymbolDefinitionByName(string name, out IntermediateSymbolDefinition symbolDefinition)
+        {
+            symbolDefinition = SqlSymbolDefinitions.ByName(name);
+            return symbolDefinition != null;
+        }
+
+        public override Intermediate GetLibrary(ISymbolDefinitionCreator symbolDefinitions)
+        {
+            return Intermediate.Load(typeof(SqlExtensionData).Assembly, "WixToolset.Sql.sql.wixlib", symbolDefinitions);
+        }
+    }
+}
diff --git a/src/ext/Sql/wixext/SqlExtensionFactory.cs b/src/ext/Sql/wixext/SqlExtensionFactory.cs
new file mode 100644
index 00000000..279106d3
--- /dev/null
+++ b/src/ext/Sql/wixext/SqlExtensionFactory.cs
@@ -0,0 +1,18 @@
+// 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.Sql
+{
+    using System;
+    using System.Collections.Generic;
+    using WixToolset.Extensibility;
+
+    public class SqlExtensionFactory : BaseExtensionFactory
+    {
+        protected override IReadOnlyCollection<Type> ExtensionTypes => new[]
+        {
+            typeof(SqlCompiler),
+            typeof(SqlExtensionData),
+            typeof(SqlWindowsInstallerBackendBinderExtension),
+        };
+    }
+}
diff --git a/src/ext/Sql/wixext/SqlTableDefinitions.cs b/src/ext/Sql/wixext/SqlTableDefinitions.cs
new file mode 100644
index 00000000..029a092e
--- /dev/null
+++ b/src/ext/Sql/wixext/SqlTableDefinitions.cs
@@ -0,0 +1,82 @@
+// 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.Sql
+{
+    using WixToolset.Data.WindowsInstaller;
+
+    public static class SqlTableDefinitions
+    {
+        public static readonly TableDefinition SqlDatabase = new TableDefinition(
+            "Wix4SqlDatabase",
+            SqlSymbolDefinitions.SqlDatabase,
+            new[]
+            {
+                new ColumnDefinition("SqlDb", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Server", ColumnType.String, 255, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "Primary key, name of server running SQL Server"),
+                new ColumnDefinition("Instance", ColumnType.String, 255, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "Primary key, name of SQL Server instance"),
+                new ColumnDefinition("Database", ColumnType.String, 255, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "Primary key, name of database in a SQL Server"),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key, Component used to determine install state ", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("User_", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "User", keyColumn: 1, description: "Foreign key, User used to log into database", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("FileSpec_", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "Wix4SqlFileSpec", keyColumn: 1, description: "Foreign key referencing SqlFileSpec.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("FileSpec_Log", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "Wix4SqlFileSpec", keyColumn: 1, description: "Foreign key referencing SqlFileSpec.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Attributes", ColumnType.Number, 2, primaryKey: false, nullable: true, ColumnCategory.Unknown, minValue: 0, maxValue: 255, description: "1 == create on install, 2 == drop on uninstall, 4 == continue on error, 8 == drop on install, 16 == create on uninstall, 32 == confirm update existing table, 64 == create on reinstall, 128 == drop on reinstall"),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition SqlFileSpec = new TableDefinition(
+            "Wix4SqlFileSpec",
+            SqlSymbolDefinitions.SqlFileSpec,
+            new[]
+            {
+                new ColumnDefinition("FileSpec", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Name", ColumnType.String, 255, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "Logical name of filespec", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Filename", ColumnType.String, 255, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "Filename to use (path must exist)", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Size", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "Initial size for file", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("MaxSize", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "Maximum size for file", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("GrowthSize", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "Size file should grow when necessary", modularizeType: ColumnModularizeType.Property),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition SqlScript = new TableDefinition(
+            "Wix4SqlScript",
+            SqlSymbolDefinitions.SqlScript,
+            new[]
+            {
+                new ColumnDefinition("Script", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token"),
+                new ColumnDefinition("SqlDb_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Wix4SqlDatabase", keyColumn: 1, description: "Foreign key, SQL Server key", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key, Component used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("ScriptBinary_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Binary", keyColumn: 1, description: "Foreign key, Binary stream that contains SQL Script to execute", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("User_", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "User", keyColumn: 1, description: "Foreign key, User used to log into database", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Attributes", ColumnType.Number, 2, primaryKey: false, nullable: false, ColumnCategory.Unknown, possibilities: "1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20;21;22;23;24;25;26;27;28;29;30;31", description: "1 == execute on install, 2 == execute on uninstall, 4 == continue on error, 8 == rollback on install, 16 == rollback on uninstall"),
+                new ColumnDefinition("Sequence", ColumnType.Number, 2, primaryKey: false, nullable: true, ColumnCategory.Unknown, description: "Order to execute SQL Queries in"),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition SqlString = new TableDefinition(
+            "Wix4SqlString",
+            SqlSymbolDefinitions.SqlString,
+            new[]
+            {
+                new ColumnDefinition("String", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Id for the Wix4SqlString", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("SqlDb_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Wix4SqlDatabase", keyColumn: 1, description: "Foreign key, SQL Server key", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key, Component used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("SQL", ColumnType.String, 0, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "SQL query to execute"),
+                new ColumnDefinition("User_", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "User", keyColumn: 1, description: "Foreign key, User used to log into database", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Attributes", ColumnType.Number, 2, primaryKey: false, nullable: false, ColumnCategory.Unknown, possibilities: "1;2;3;4;5;6;7;8;9;10;11;12;13;14;15;16;17;18;19;20;21;22;23;24;25;26;27;28;29;30;31", description: "1 == execute on install, 2 == execute on uninstall, 4 == continue on error, 8 == rollback on install, 16 == rollback on uninstall"),
+                new ColumnDefinition("Sequence", ColumnType.Number, 2, primaryKey: false, nullable: true, ColumnCategory.Unknown, description: "Order to execute SQL Queries in"),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition[] All = new[]
+        {
+            SqlDatabase,
+            SqlFileSpec,
+            SqlScript,
+            SqlString,
+        };
+    }
+}
diff --git a/src/ext/Sql/wixext/SqlWindowsInstallerBackendExtension.cs b/src/ext/Sql/wixext/SqlWindowsInstallerBackendExtension.cs
new file mode 100644
index 00000000..2ccdcc56
--- /dev/null
+++ b/src/ext/Sql/wixext/SqlWindowsInstallerBackendExtension.cs
@@ -0,0 +1,13 @@
+// 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.Sql
+{
+    using System.Collections.Generic;
+    using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Extensibility;
+
+    public class SqlWindowsInstallerBackendBinderExtension : BaseWindowsInstallerBackendBinderExtension
+    {
+        public override IReadOnlyCollection<TableDefinition> TableDefinitions => SqlTableDefinitions.All;
+    }
+}
diff --git a/src/ext/Sql/wixext/Symbols/SqlDatabaseSymbol.cs b/src/ext/Sql/wixext/Symbols/SqlDatabaseSymbol.cs
new file mode 100644
index 00000000..6f0820ac
--- /dev/null
+++ b/src/ext/Sql/wixext/Symbols/SqlDatabaseSymbol.cs
@@ -0,0 +1,103 @@
+// 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.Sql
+{
+    using WixToolset.Data;
+    using WixToolset.Sql.Symbols;
+
+    public static partial class SqlSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition SqlDatabase = new IntermediateSymbolDefinition(
+            SqlSymbolDefinitionType.SqlDatabase.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(SqlDatabaseSymbolFields.Server), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlDatabaseSymbolFields.Instance), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlDatabaseSymbolFields.Database), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlDatabaseSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlDatabaseSymbolFields.UserRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlDatabaseSymbolFields.FileSpecRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlDatabaseSymbolFields.LogFileSpecRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlDatabaseSymbolFields.Attributes), IntermediateFieldType.Number),
+            },
+            typeof(SqlDatabaseSymbol));
+    }
+}
+
+namespace WixToolset.Sql.Symbols
+{
+    using WixToolset.Data;
+
+    public enum SqlDatabaseSymbolFields
+    {
+        Server,
+        Instance,
+        Database,
+        ComponentRef,
+        UserRef,
+        FileSpecRef,
+        LogFileSpecRef,
+        Attributes,
+    }
+
+    public class SqlDatabaseSymbol : IntermediateSymbol
+    {
+        public SqlDatabaseSymbol() : base(SqlSymbolDefinitions.SqlDatabase, null, null)
+        {
+        }
+
+        public SqlDatabaseSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(SqlSymbolDefinitions.SqlDatabase, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[SqlDatabaseSymbolFields index] => this.Fields[(int)index];
+
+        public string Server
+        {
+            get => this.Fields[(int)SqlDatabaseSymbolFields.Server].AsString();
+            set => this.Set((int)SqlDatabaseSymbolFields.Server, value);
+        }
+
+        public string Instance
+        {
+            get => this.Fields[(int)SqlDatabaseSymbolFields.Instance].AsString();
+            set => this.Set((int)SqlDatabaseSymbolFields.Instance, value);
+        }
+
+        public string Database
+        {
+            get => this.Fields[(int)SqlDatabaseSymbolFields.Database].AsString();
+            set => this.Set((int)SqlDatabaseSymbolFields.Database, value);
+        }
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)SqlDatabaseSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)SqlDatabaseSymbolFields.ComponentRef, value);
+        }
+
+        public string UserRef
+        {
+            get => this.Fields[(int)SqlDatabaseSymbolFields.UserRef].AsString();
+            set => this.Set((int)SqlDatabaseSymbolFields.UserRef, value);
+        }
+
+        public string FileSpecRef
+        {
+            get => this.Fields[(int)SqlDatabaseSymbolFields.FileSpecRef].AsString();
+            set => this.Set((int)SqlDatabaseSymbolFields.FileSpecRef, value);
+        }
+
+        public string LogFileSpecRef
+        {
+            get => this.Fields[(int)SqlDatabaseSymbolFields.LogFileSpecRef].AsString();
+            set => this.Set((int)SqlDatabaseSymbolFields.LogFileSpecRef, value);
+        }
+
+        public int Attributes
+        {
+            get => this.Fields[(int)SqlDatabaseSymbolFields.Attributes].AsNumber();
+            set => this.Set((int)SqlDatabaseSymbolFields.Attributes, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Sql/wixext/Symbols/SqlFileSpecSymbol.cs b/src/ext/Sql/wixext/Symbols/SqlFileSpecSymbol.cs
new file mode 100644
index 00000000..d9eecc62
--- /dev/null
+++ b/src/ext/Sql/wixext/Symbols/SqlFileSpecSymbol.cs
@@ -0,0 +1,79 @@
+// 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.Sql
+{
+    using WixToolset.Data;
+    using WixToolset.Sql.Symbols;
+
+    public static partial class SqlSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition SqlFileSpec = new IntermediateSymbolDefinition(
+            SqlSymbolDefinitionType.SqlFileSpec.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(SqlFileSpecSymbolFields.Name), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlFileSpecSymbolFields.Filename), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlFileSpecSymbolFields.Size), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlFileSpecSymbolFields.MaxSize), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlFileSpecSymbolFields.GrowthSize), IntermediateFieldType.String),
+            },
+            typeof(SqlFileSpecSymbol));
+    }
+}
+
+namespace WixToolset.Sql.Symbols
+{
+    using WixToolset.Data;
+
+    public enum SqlFileSpecSymbolFields
+    {
+        Name,
+        Filename,
+        Size,
+        MaxSize,
+        GrowthSize,
+    }
+
+    public class SqlFileSpecSymbol : IntermediateSymbol
+    {
+        public SqlFileSpecSymbol() : base(SqlSymbolDefinitions.SqlFileSpec, null, null)
+        {
+        }
+
+        public SqlFileSpecSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(SqlSymbolDefinitions.SqlFileSpec, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[SqlFileSpecSymbolFields index] => this.Fields[(int)index];
+
+        public string Name
+        {
+            get => this.Fields[(int)SqlFileSpecSymbolFields.Name].AsString();
+            set => this.Set((int)SqlFileSpecSymbolFields.Name, value);
+        }
+
+        public string Filename
+        {
+            get => this.Fields[(int)SqlFileSpecSymbolFields.Filename].AsString();
+            set => this.Set((int)SqlFileSpecSymbolFields.Filename, value);
+        }
+
+        public string Size
+        {
+            get => this.Fields[(int)SqlFileSpecSymbolFields.Size].AsString();
+            set => this.Set((int)SqlFileSpecSymbolFields.Size, value);
+        }
+
+        public string MaxSize
+        {
+            get => this.Fields[(int)SqlFileSpecSymbolFields.MaxSize].AsString();
+            set => this.Set((int)SqlFileSpecSymbolFields.MaxSize, value);
+        }
+
+        public string GrowthSize
+        {
+            get => this.Fields[(int)SqlFileSpecSymbolFields.GrowthSize].AsString();
+            set => this.Set((int)SqlFileSpecSymbolFields.GrowthSize, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Sql/wixext/Symbols/SqlScriptSymbol.cs b/src/ext/Sql/wixext/Symbols/SqlScriptSymbol.cs
new file mode 100644
index 00000000..94c70390
--- /dev/null
+++ b/src/ext/Sql/wixext/Symbols/SqlScriptSymbol.cs
@@ -0,0 +1,87 @@
+// 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.Sql
+{
+    using WixToolset.Data;
+    using WixToolset.Sql.Symbols;
+
+    public static partial class SqlSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition SqlScript = new IntermediateSymbolDefinition(
+            SqlSymbolDefinitionType.SqlScript.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(SqlScriptSymbolFields.SqlDbRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlScriptSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlScriptSymbolFields.ScriptBinaryRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlScriptSymbolFields.UserRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlScriptSymbolFields.Attributes), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(SqlScriptSymbolFields.Sequence), IntermediateFieldType.Number),
+            },
+            typeof(SqlScriptSymbol));
+    }
+}
+
+namespace WixToolset.Sql.Symbols
+{
+    using WixToolset.Data;
+
+    public enum SqlScriptSymbolFields
+    {
+        SqlDbRef,
+        ComponentRef,
+        ScriptBinaryRef,
+        UserRef,
+        Attributes,
+        Sequence,
+    }
+
+    public class SqlScriptSymbol : IntermediateSymbol
+    {
+        public SqlScriptSymbol() : base(SqlSymbolDefinitions.SqlScript, null, null)
+        {
+        }
+
+        public SqlScriptSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(SqlSymbolDefinitions.SqlScript, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[SqlScriptSymbolFields index] => this.Fields[(int)index];
+
+        public string SqlDbRef
+        {
+            get => this.Fields[(int)SqlScriptSymbolFields.SqlDbRef].AsString();
+            set => this.Set((int)SqlScriptSymbolFields.SqlDbRef, value);
+        }
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)SqlScriptSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)SqlScriptSymbolFields.ComponentRef, value);
+        }
+
+        public string ScriptBinaryRef
+        {
+            get => this.Fields[(int)SqlScriptSymbolFields.ScriptBinaryRef].AsString();
+            set => this.Set((int)SqlScriptSymbolFields.ScriptBinaryRef, value);
+        }
+
+        public string UserRef
+        {
+            get => this.Fields[(int)SqlScriptSymbolFields.UserRef].AsString();
+            set => this.Set((int)SqlScriptSymbolFields.UserRef, value);
+        }
+
+        public int Attributes
+        {
+            get => this.Fields[(int)SqlScriptSymbolFields.Attributes].AsNumber();
+            set => this.Set((int)SqlScriptSymbolFields.Attributes, value);
+        }
+
+        public int? Sequence
+        {
+            get => this.Fields[(int)SqlScriptSymbolFields.Sequence].AsNullableNumber();
+            set => this.Set((int)SqlScriptSymbolFields.Sequence, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Sql/wixext/Symbols/SqlStringSymbol.cs b/src/ext/Sql/wixext/Symbols/SqlStringSymbol.cs
new file mode 100644
index 00000000..73a8206e
--- /dev/null
+++ b/src/ext/Sql/wixext/Symbols/SqlStringSymbol.cs
@@ -0,0 +1,87 @@
+// 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.Sql
+{
+    using WixToolset.Data;
+    using WixToolset.Sql.Symbols;
+
+    public static partial class SqlSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition SqlString = new IntermediateSymbolDefinition(
+            SqlSymbolDefinitionType.SqlString.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(SqlStringSymbolFields.SqlDbRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlStringSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlStringSymbolFields.SQL), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlStringSymbolFields.UserRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SqlStringSymbolFields.Attributes), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(SqlStringSymbolFields.Sequence), IntermediateFieldType.Number),
+            },
+            typeof(SqlStringSymbol));
+    }
+}
+
+namespace WixToolset.Sql.Symbols
+{
+    using WixToolset.Data;
+
+    public enum SqlStringSymbolFields
+    {
+        SqlDbRef,
+        ComponentRef,
+        SQL,
+        UserRef,
+        Attributes,
+        Sequence,
+    }
+
+    public class SqlStringSymbol : IntermediateSymbol
+    {
+        public SqlStringSymbol() : base(SqlSymbolDefinitions.SqlString, null, null)
+        {
+        }
+
+        public SqlStringSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(SqlSymbolDefinitions.SqlString, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[SqlStringSymbolFields index] => this.Fields[(int)index];
+
+        public string SqlDbRef
+        {
+            get => this.Fields[(int)SqlStringSymbolFields.SqlDbRef].AsString();
+            set => this.Set((int)SqlStringSymbolFields.SqlDbRef, value);
+        }
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)SqlStringSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)SqlStringSymbolFields.ComponentRef, value);
+        }
+
+        public string SQL
+        {
+            get => this.Fields[(int)SqlStringSymbolFields.SQL].AsString();
+            set => this.Set((int)SqlStringSymbolFields.SQL, value);
+        }
+
+        public string UserRef
+        {
+            get => this.Fields[(int)SqlStringSymbolFields.UserRef].AsString();
+            set => this.Set((int)SqlStringSymbolFields.UserRef, value);
+        }
+
+        public int Attributes
+        {
+            get => this.Fields[(int)SqlStringSymbolFields.Attributes].AsNumber();
+            set => this.Set((int)SqlStringSymbolFields.Attributes, value);
+        }
+
+        public int? Sequence
+        {
+            get => this.Fields[(int)SqlStringSymbolFields.Sequence].AsNullableNumber();
+            set => this.Set((int)SqlStringSymbolFields.Sequence, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Sql/wixext/Symbols/SqlSymbolDefinitions.cs b/src/ext/Sql/wixext/Symbols/SqlSymbolDefinitions.cs
new file mode 100644
index 00000000..336f1546
--- /dev/null
+++ b/src/ext/Sql/wixext/Symbols/SqlSymbolDefinitions.cs
@@ -0,0 +1,51 @@
+// 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.Sql
+{
+    using System;
+    using WixToolset.Data;
+
+    public enum SqlSymbolDefinitionType
+    {
+        SqlDatabase,
+        SqlFileSpec,
+        SqlScript,
+        SqlString,
+    }
+
+    public static partial class SqlSymbolDefinitions
+    {
+        public static readonly Version Version = new Version("4.0.0");
+
+        public static IntermediateSymbolDefinition ByName(string name)
+        {
+            if (!Enum.TryParse(name, out SqlSymbolDefinitionType type))
+            {
+                return null;
+            }
+
+            return ByType(type);
+        }
+
+        public static IntermediateSymbolDefinition ByType(SqlSymbolDefinitionType type)
+        {
+            switch (type)
+            {
+                case SqlSymbolDefinitionType.SqlDatabase:
+                    return SqlSymbolDefinitions.SqlDatabase;
+
+                case SqlSymbolDefinitionType.SqlFileSpec:
+                    return SqlSymbolDefinitions.SqlFileSpec;
+
+                case SqlSymbolDefinitionType.SqlScript:
+                    return SqlSymbolDefinitions.SqlScript;
+
+                case SqlSymbolDefinitionType.SqlString:
+                    return SqlSymbolDefinitions.SqlString;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(type));
+            }
+        }
+    }
+}
diff --git a/src/ext/Sql/wixext/WixToolset.Sql.wixext.csproj b/src/ext/Sql/wixext/WixToolset.Sql.wixext.csproj
new file mode 100644
index 00000000..5a1ebeb0
--- /dev/null
+++ b/src/ext/Sql/wixext/WixToolset.Sql.wixext.csproj
@@ -0,0 +1,30 @@
+<?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>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <RootNamespace>WixToolset.Sql</RootNamespace>
+    <Description>WiX Toolset Sql Extension</Description>
+    <Title>WiX Toolset Sql Extension</Title>
+    <DebugType>embedded</DebugType>
+    <IncludeSymbols>true</IncludeSymbols>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="$(OutputPath)..\sql.wixlib" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\wixlib\sql.wixproj" ReferenceOutputAssembly="false" Condition=" '$(NCrunch)'=='' " />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="WixToolset.Extensibility" Version="4.0.*" PrivateAssets="All" />
+  </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>
diff --git a/src/ext/Sql/wixext/WixToolset.Sql.wixext.nuspec b/src/ext/Sql/wixext/WixToolset.Sql.wixext.nuspec
new file mode 100644
index 00000000..ba3eaade
--- /dev/null
+++ b/src/ext/Sql/wixext/WixToolset.Sql.wixext.nuspec
@@ -0,0 +1,25 @@
+<?xml version="1.0"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+  <metadata minClientVersion="4.0">
+    <id>$id$</id>
+    <version>$version$</version>
+    <title>$title$</title>
+    <description>$description$</description>
+    <authors>$authors$</authors>
+    <license type="expression">MS-RL</license>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <copyright>$copyright$</copyright>
+    <projectUrl>$projectUrl$</projectUrl>
+    <repository type="$repositorytype$" url="$repositoryurl$" commit="$repositorycommit$" />
+  </metadata>
+
+  <files>
+    <file src="$projectFolder$$id$.targets" target="build" />
+
+    <file src="netstandard2.0\$id$.dll" target="tools" />
+
+    <file src="ARM64\*.pdb" target="pdbs\ARM64" />
+    <file src="x86\*.pdb" target="pdbs\x86" />
+    <file src="x64\*.pdb" target="pdbs\x64" />
+  </files>
+</package>
diff --git a/src/ext/Sql/wixext/WixToolset.Sql.wixext.targets b/src/ext/Sql/wixext/WixToolset.Sql.wixext.targets
new file mode 100644
index 00000000..4950e119
--- /dev/null
+++ b/src/ext/Sql/wixext/WixToolset.Sql.wixext.targets
@@ -0,0 +1,11 @@
+<?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 xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <WixToolsetSqlWixextPath Condition=" '$(WixToolsetSqlWixextPath)' == '' ">$(MSBuildThisFileDirectory)..\tools\WixToolset.Sql.wixext.dll</WixToolsetSqlWixextPath>
+  </PropertyGroup>
+  <ItemGroup>
+    <WixExtension Include="$(WixToolsetSqlWixextPath)" />
+  </ItemGroup>
+</Project>