@@ -15,7 +15,12 @@ public override void ExplicitVisit(CheckConstraintDefinition node)
 
             MarkAndPushAlignmentPoint(start);
 
-            GenerateConstraintHead(node);
+            GenerateConstraintHead(node, _options.NewlineFormattedCheckConstraint);
+
+            if (_options.NewlineFormattedCheckConstraint)
+            {
+                Indent();
+            }
 
             GenerateKeyword(TSqlTokenType.Check); 
 
 
@@ -411,8 +411,10 @@ protected void GenerateParameters(ParameterizedDataTypeReference node)
         {
             if (node.Parameters.Count > 0)
             {
-                GenerateSpace();
-                GenerateParenthesisedCommaSeparatedList(node.Parameters);
+                if (_options.SpaceBetweenDataTypeAndParameters) {
+                    GenerateSpace();
+                }
+                GenerateParenthesisedCommaSeparatedList(node.Parameters, false, _options.SpaceBetweenParametersInDataType);
             }
         }
 
 
@@ -27,13 +27,13 @@ partial class SqlScriptGeneratorVisitor
                 new KeywordGenerator(TSqlTokenType.Null),}},
         };
 
-        protected void GenerateConstraintHead(ConstraintDefinition node)
+        protected void GenerateConstraintHead(ConstraintDefinition node, bool newline = false)
         {
             if (node.ConstraintIdentifier != null)
             {
                 GenerateKeyword(TSqlTokenType.Constraint); 
                 GenerateSpaceAndFragmentIfNotNull(node.ConstraintIdentifier);
-                GenerateSpace();
+                GenerateNewLineOrSpace(newline);
             }
         }
 
 
@@ -11,6 +11,12 @@ partial class SqlScriptGeneratorVisitor
     {
         public override void ExplicitVisit(IndexDefinition node)
         {
+            if (_options.NewLineFormattedIndexDefinition)
+            {
+                AlignmentPoint start = new AlignmentPoint();
+                MarkAndPushAlignmentPoint(start);
+            }
+
             GenerateKeyword(TSqlTokenType.Index);
 
             if (node.Name != null)
@@ -20,7 +26,15 @@ public override void ExplicitVisit(IndexDefinition node)
 
             if (node.Unique)
             {
-                GenerateSpaceAndKeyword(TSqlTokenType.Unique);
+                if (_options.NewLineFormattedIndexDefinition)
+                {
+                    NewLineAndIndent();
+                }
+                else
+                {
+                    GenerateSpace();
+                }
+                GenerateKeyword(TSqlTokenType.Unique);
             }
 
             if (node.IndexType != null)
@@ -56,16 +70,32 @@ public override void ExplicitVisit(IndexDefinition node)
 
             if (node.IncludeColumns.Count > 0)
             {
-                GenerateSpaceAndIdentifier(CodeGenerationSupporter.Include);
+                if (_options.NewLineFormattedIndexDefinition)
+                {
+                    NewLineAndIndent();
+                }
+                else
+                {
+                    GenerateSpace();
+                }
+                GenerateIdentifier(CodeGenerationSupporter.Include);
                 GenerateSpace();
                 GenerateParenthesisedCommaSeparatedList(node.IncludeColumns);
             }
 
 			if (node.FilterPredicate != null)
 			{
-				GenerateSpaceAndKeyword(TSqlTokenType.Where);
-				GenerateSpaceAndFragmentIfNotNull(node.FilterPredicate);
-			}
+                if (_options.NewLineFormattedIndexDefinition)
+                {
+                    NewLineAndIndent();
+                }
+                else
+                {
+                    GenerateSpace();
+                }
+                GenerateKeyword(TSqlTokenType.Where);
+                GenerateSpaceAndFragmentIfNotNull(node.FilterPredicate);
+            }
 
             if (node.IndexOptions.Count > 0)
             {                            
@@ -81,6 +111,11 @@ public override void ExplicitVisit(IndexDefinition node)
             }
 
             GenerateFileStreamOn(node);
+
+            if (_options.NewLineFormattedIndexDefinition)
+            {
+                PopAlignmentPoint();
+            }
         }
     }
 }
@@ -220,7 +220,7 @@ protected void GenerateCommaSeparatedList<T>(IList<T> list, Boolean insertNewLin
         }
 
         // generate a comma-separated list
-        protected void GenerateCommaSeparatedList<T>(IList<T> list, bool insertNewLine, bool indent) where T : TSqlFragment
+        protected void GenerateCommaSeparatedList<T>(IList<T> list, bool insertNewLine, bool indent, bool generateSpaces = true) where T : TSqlFragment
         {
             GenerateList(list, delegate()
             {
@@ -234,7 +234,7 @@ protected void GenerateCommaSeparatedList<T>(IList<T> list, bool insertNewLine,
                         Indent();
                     }
                 }
-                else
+                else if (generateSpaces)
                 {
                     GenerateSpace();
                 } 
@@ -282,12 +282,12 @@ protected void GenerateParenthesisedCommaSeparatedList<T>(IList<T> list) where T
         }
 
         // generate a parenthsised comma-separated list
-        protected void GenerateParenthesisedCommaSeparatedList<T>(IList<T> list, Boolean alwaysGenerateParenthses) where T : TSqlFragment
+        protected void GenerateParenthesisedCommaSeparatedList<T>(IList<T> list, Boolean alwaysGenerateParenthses, Boolean generateSpaces = true) where T : TSqlFragment
         {
             if (list != null && list.Count > 0)
             {
                 GenerateSymbol(TSqlTokenType.LeftParenthesis);
-                GenerateCommaSeparatedList(list);
+                GenerateCommaSeparatedList(list, false, false, generateSpaces);
                 GenerateSymbol(TSqlTokenType.RightParenthesis);
             }
             else if (alwaysGenerateParenthses)
 
@@ -28,6 +28,18 @@
       <Description>IncludeSemiColons_Description</Description>
       <Summary>Gets or sets a boolean indicating if a semi colon should be included after each statement</Summary>
     </Setting>
+    <Setting name="NewLineFormattedIndexDefinition" type="bool" default="false">
+      <Summary>Gets or sets a boolean indicating if index definitions should have UNIQUE, INCLUDE and WHERE on their own line</Summary>
+    </Setting>
+    <Setting name="NewlineFormattedCheckConstraint" type="bool" default="false">
+      <Summary>Gets or sets a boolean indicating if check constraints should have the CHECK part on it's own line</Summary>
+    </Setting>
+    <Setting name="SpaceBetweenDataTypeAndParameters" type="bool" default="true">
+      <Summary>Gets or sets a boolean indicating if a space should be included between the data type and the parameters in a data type definition</Summary>
+    </Setting>
+    <Setting name="SpaceBetweenParametersInDataType" type="bool" default="true">
+      <Summary>Gets or sets a boolean indicating if a space should be included between parameters in a data type</Summary>
+    </Setting>
     <Setting name="NumNewlinesAfterStatement" type="int" default="1" min="0">
       <Summary>Gets or sets the number of newlines to include after each statement</Summary>
     </Setting>
 
@@ -5,6 +5,7 @@
 //------------------------------------------------------------------------------
 
 using System;
+using System.IO;
 using Microsoft.SqlServer.TransactSql.ScriptDom;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using SqlStudio.Tests.AssemblyTools.TestCategory;
@@ -157,5 +158,181 @@ public void TestNewlinesBetweenStatementsGeneratorOption() {
             generator.GenerateScript(statements, out sql);
             Assert.AreEqual(tableStatementString + Environment.NewLine + Environment.NewLine + tableStatementString, sql);
         }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestNewLineFormattedIndexDefinitionDefault() {
+            Assert.AreEqual(false, new SqlScriptGeneratorOptions().NewLineFormattedIndexDefinition);
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestNewlineFormattedCheckConstraintDefault() {
+            Assert.AreEqual(false, new SqlScriptGeneratorOptions().NewlineFormattedCheckConstraint);
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestSpaceBetweenDataTypeAndParametersDefault() {
+            Assert.AreEqual(true, new SqlScriptGeneratorOptions().SpaceBetweenDataTypeAndParameters);
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestSpaceBetweenParametersInDataTypeDefault() {
+            Assert.AreEqual(true, new SqlScriptGeneratorOptions().SpaceBetweenParametersInDataType);
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestSpaceBetweenDataTypeAndParametersWhenFalse() {
+            var expectedSqlText = @"CREATE TABLE DummyTable (
+    ColumnName VARCHAR(50)
+);";
+
+            ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {
+                SpaceBetweenDataTypeAndParameters = false
+            });
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestSpaceBetweenDataTypeAndParametersWhenTrue() {
+            var expectedSqlText = @"CREATE TABLE DummyTable (
+    ColumnName VARCHAR (50)
+);";
+
+            ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {
+                SpaceBetweenDataTypeAndParameters = true
+            });
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestSpaceBetweenParametersInDataTypeWhenFalse() {
+            var expectedSqlText = @"CREATE TABLE DummyTable (
+    ColumnName DECIMAL (5,2)
+);";
+
+            ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {
+                SpaceBetweenParametersInDataType = false
+            });
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestSpaceBetweenParametersInDataTypeWhenTrue() {
+            var expectedSqlText = @"CREATE TABLE DummyTable (
+    ColumnName DECIMAL (5, 2)
+);";
+
+            ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {
+                SpaceBetweenParametersInDataType = true
+            });
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestNewlineFormattedCheckConstraintWhenFalse() {
+            var expectedSqlText = @"CREATE TABLE DummyTable (
+    CONSTRAINT ComplicatedConstraint CHECK ((Col1 IS NULL
+                                             AND (Col2 <> ''
+                                                  OR Col3 = 0))
+                                            OR (Col1 IS NOT NULL
+                                                AND ((Col2 = ''
+                                                      AND Col3 <> 0)
+                                                     OR (Col4 IN ('', 'ABC', 'JKL', 'XYZ')
+                                                         AND Col3 < 0
+                                                         AND (Col5 <> ''
+                                                              OR Col6 <> '')))))
+);";
+
+            ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {
+                NewlineFormattedCheckConstraint = false
+            });
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestNewlineFormattedCheckConstraintWhenTrue() {
+            var expectedSqlText = @"CREATE TABLE DummyTable (
+    CONSTRAINT ComplicatedConstraint
+        CHECK ((Col1 IS NULL
+                AND (Col2 <> ''
+                     OR Col3 = 0))
+               OR (Col1 IS NOT NULL
+                   AND ((Col2 = ''
+                         AND Col3 <> 0)
+                        OR (Col4 IN ('', 'ABC', 'JKL', 'XYZ')
+                            AND Col3 < 0
+                            AND (Col5 <> ''
+                                 OR Col6 <> '')))))
+);";
+
+            ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {
+                NewlineFormattedCheckConstraint = true
+            });
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestNewLineFormattedIndexDefinitionWhenFalse() {
+            var expectedSqlText = @"CREATE TABLE DummyTable (
+    INDEX ComplicatedIndex UNIQUE (Col1, Col2, Col3) INCLUDE (Col4, Col5, Col6, Col7, Col8) WHERE Col4 = 'AR'
+                                                                                                  AND Col3 IN ('ABC', 'XYZ')
+                                                                                                      AND Col5 = 0
+                                                                                                          AND Col6 = 1
+                                                                                                              AND Col7 = 0
+                                                                                                                  AND Col8 IS NOT NULL
+);";
+
+            ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {
+                NewLineFormattedIndexDefinition = false
+            });
+        }
+
+        [TestMethod]
+        [Priority(0)]
+        [SqlStudioTestCategory(Category.UnitTest)]
+        public void TestNewLineFormattedIndexDefinitionWhenTrue() {
+            var expectedSqlText = @"CREATE TABLE DummyTable (
+    INDEX ComplicatedIndex
+        UNIQUE (Col1, Col2, Col3)
+        INCLUDE (Col4, Col5, Col6, Col7, Col8)
+        WHERE Col4 = 'AR'
+              AND Col3 IN ('ABC', 'XYZ')
+                  AND Col5 = 0
+                      AND Col6 = 1
+                          AND Col7 = 0
+                              AND Col8 IS NOT NULL
+);";
+
+            ParseAndAssertEquality(expectedSqlText, new SqlScriptGeneratorOptions {
+                NewLineFormattedIndexDefinition = true
+            });
+        }
+
+        void ParseAndAssertEquality(string sqlText, SqlScriptGeneratorOptions generatorOptions) {
+            var parser = new TSql160Parser(true);
+            var fragment = parser.ParseStatementList(new StringReader(sqlText), out var errors);
+
+            Assert.AreEqual(0, errors.Count);
+
+            var generator = new Sql160ScriptGenerator(generatorOptions);
+            generator.GenerateScript(fragment, out var generatedSqlText);
+
+            Assert.AreEqual(sqlText, generatedSqlText);
+        }
     }
 }
Original file line number	Diff line number	Diff line change
`@@ -411,8 +411,10 @@ protected void GenerateParameters(ParameterizedDataTypeReference node)`
`411`	`411`	`{`
`412`	`412`	`if (node.Parameters.Count > 0)`
`413`	`413`	`{`
`414`		`- GenerateSpace();`
`415`		`- GenerateParenthesisedCommaSeparatedList(node.Parameters);`
	`414`	`+ if (_options.SpaceBetweenDataTypeAndParameters) {`
	`415`	`+ GenerateSpace();`
	`416`	`+ }`
	`417`	`+ GenerateParenthesisedCommaSeparatedList(node.Parameters, false, _options.SpaceBetweenParametersInDataType);`
`416`	`418`	`}`
`417`	`419`	`}`
`418`	`420`
Original file line number	Diff line number	Diff line change
`@@ -27,13 +27,13 @@ partial class SqlScriptGeneratorVisitor`
`27`	`27`	`new KeywordGenerator(TSqlTokenType.Null),}},`
`28`	`28`	`};`
`29`	`29`
`30`		`- protected void GenerateConstraintHead(ConstraintDefinition node)`
	`30`	`+ protected void GenerateConstraintHead(ConstraintDefinition node, bool newline = false)`
`31`	`31`	`{`
`32`	`32`	`if (node.ConstraintIdentifier != null)`
`33`	`33`	`{`
`34`	`34`	`GenerateKeyword(TSqlTokenType.Constraint);`
`35`	`35`	`GenerateSpaceAndFragmentIfNotNull(node.ConstraintIdentifier);`
`36`		`- GenerateSpace();`
	`36`	`+ GenerateNewLineOrSpace(newline);`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
Original file line number	Diff line number	Diff line change
`@@ -220,7 +220,7 @@ protected void GenerateCommaSeparatedList<T>(IList<T> list, Boolean insertNewLin`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`// generate a comma-separated list`
`223`		`- protected void GenerateCommaSeparatedList<T>(IList<T> list, bool insertNewLine, bool indent) where T : TSqlFragment`
	`223`	`+ protected void GenerateCommaSeparatedList<T>(IList<T> list, bool insertNewLine, bool indent, bool generateSpaces = true) where T : TSqlFragment`
`224`	`224`	`{`
`225`	`225`	`GenerateList(list, delegate()`
`226`	`226`	`{`
`@@ -234,7 +234,7 @@ protected void GenerateCommaSeparatedList<T>(IList<T> list, bool insertNewLine,`
`234`	`234`	`Indent();`
`235`	`235`	`}`
`236`	`236`	`}`
`237`		`- else`
	`237`	`+ else if (generateSpaces)`
`238`	`238`	`{`
`239`	`239`	`GenerateSpace();`
`240`	`240`	`}`
`@@ -282,12 +282,12 @@ protected void GenerateParenthesisedCommaSeparatedList<T>(IList<T> list) where T`
`282`	`282`	`}`
`283`	`283`
`284`	`284`	`// generate a parenthsised comma-separated list`
`285`		`- protected void GenerateParenthesisedCommaSeparatedList<T>(IList<T> list, Boolean alwaysGenerateParenthses) where T : TSqlFragment`
	`285`	`+ protected void GenerateParenthesisedCommaSeparatedList<T>(IList<T> list, Boolean alwaysGenerateParenthses, Boolean generateSpaces = true) where T : TSqlFragment`
`286`	`286`	`{`
`287`	`287`	`if (list != null && list.Count > 0)`
`288`	`288`	`{`
`289`	`289`	`GenerateSymbol(TSqlTokenType.LeftParenthesis);`
`290`		`- GenerateCommaSeparatedList(list);`
	`290`	`+ GenerateCommaSeparatedList(list, false, false, generateSpaces);`
`291`	`291`	`GenerateSymbol(TSqlTokenType.RightParenthesis);`
`292`	`292`	`}`
`293`	`293`	`else if (alwaysGenerateParenthses)`