SPItemBegin =  Select Clause
10000:{# [
                ForEachVectorReferenceX("Physical Order List")
                {
                        GenerateX
                        SeparatorX(",")
                        [
                                PushReferenceX("Parent Relationship Ref") 
                                [
                                        [ 
                                                PropertyValueX("Alias Name") "." 
                                        ]
                                        [
                                                IsNullX([PropertyValueX("Alias Name")])
                                                PushReferenceX("Parent Entity Ref")
                                                [
                                                        [OwnerX"."] PhysicalNameX "."
                                                
                                                ]
                                                PopX
                                        ]
                                        
                                ]       
                                PopX
                                [
                                        PushReferenceX("Parent Attribute Ref")
                                                [       IsNotNullX(ExecuteX("Is Owner Entity"),"<FALSE>") PhysicalNameX ]
                                                [       IsNotNullX(ExecuteX("Is Owner View"),"<FALSE>") NameX ]
                                        PopX
                                ]
                        ]
                        [Property("View Expression")]
                }
 
                ]
#}SPItemEnd
 
 
SPItemBegin = View Column Has Alias
10000:
{#
    [ 
                ForEachVectorReferenceX("Physical Order List")
                {
                        GenerateX
                        PropertyValueX("Name","<FALSE>")
                }
        ]
#}
SPItemEnd
 
 
SPItemBegin = Is Owner Entity
10000:
{#
    [ PushOwnerX
                [
                        IsObjectTypeX("Entity") "Entity"
                ]
          PopX
        ]
#}
SPItemEnd
 
SPItemBegin = Is Owner View
10000:
{#
    [ PushOwnerX
                [
                        IsObjectTypeX("View") "View"
                ]
          PopX
        ]
#}
SPItemEnd
 
 
SPItemBegin =  From Clause
10000:{# 
                [
                ForEachVectorReferenceX("Child Relations Ref")
                {
                        GenerateX
                        SeparatorX(",")
            [PushReferenceX("Parent Entity Ref")
                                [OwnerX"."]PhysicalNameX
                        PopX]
                        [" " PropertyValueX("Alias Name") ]
                }
                ]
#}SPItemEnd
 
 
SPItemBegin =  Select Statement
10000:{# [
                        "\r\n\t" "SELECT " [DecodePropertyX("Select Type","2"," DISTINCT ")]
                        IsNotNullX(ExecuteX("Select Clause"),"<TRUE>")
                        "\r\n\t\t" "FROM "
                        IsNotNullX(ExecuteX("From Clause"),"<TRUE>")
                        ["\r\n\t\t" "WHERE " PropertyValueX("View Where")]
                        ["\r\n\t\t" "GROUP BY " PropertyValueX("View Group By")]
                        ["\r\n\t\t" "HAVING " PropertyValueX("View Having")]
                        ["\r\n\t\t" "ORDER BY " PropertyValueX("View Order By")]
                ]
#}SPItemEnd
 
 
SPItemBegin =  Column Check Constraints
10000:{# [
                        OptionX("ColumnCheckConstraint")
                        ["CONSTRAINT  " OptionX("ConstraintName") PhysicalNameX]
                        PushObjectX("Check Constraint Usage")
                        [
                                [PushReferenceX("Validation Rule Ref")
                                        [GenerateX
                                        " CHECK ("  ExpandErwinMacroX("Server Value") ")"]
                                PopX]
                        ]
                        PopX
                ]
#}SPItemEnd
 
 
SPItemBegin =  CreateTableCheckConstraint                               
10000: {#[      
                        ForEachChildObjectX("Check Constraint Usage")
                        {
                                SeparatorX(",\r\n\t")
                                ["CONSTRAINT  " OptionX("ConstraintName") PhysicalNameX]  "\r\n\t\t\t"  
                                [PushReferenceX("Validation Rule Ref")
                                        "CHECK (" ExpandErwinMacroX("Server Value")  ")"
                                PopX]
                        }
                ]
#}SPItemEnd
 
 
SPItemBegin =  Index Drop Option
10000:
{# 
        [ CompareStringsX(PropertyValueX("Key Group Type"),"PK","2")     OptionX("DropPKIndex") ]
        [ CompareStringsX(PropertyValueX("Key Group Type"),"AK","2")     OptionX("DropAKIndex") ]
        [ IsNotNullX(CompareStringsX(PropertyValueX("Key Group Type"),"IF","2"),"<FALSE>")                        OptionX("DropFKIndex")
                                        PushReference("Relationship Ref") [  GenerateX  "IF" ] PopX
        ]
        [ CompareStringsX(PropertyValueX("Key Group Type"),"IE","2")     OptionX("DropIEIndex") ]
#}
SPItemEnd
 
SPItemBegin =  Index Create Option
10000:{# [ CompareStringsX(PropertyValueX("Key Group Type"),"PK","2")     OptionX("CreatePKIndex")   ]
                [ CompareStringsX(PropertyValueX("Key Group Type"),"AK","2")     OptionX("CreateAKIndex")   ]
                [ IsNotNullX(CompareStringsX(PropertyValueX("Key Group Type"),"IF","2"),"<FALSE>")                        OptionX("CreateFKIndex")
                                        PushReference("Relationship Ref") [  GenerateX  "IF" ] PopX
                ]
                [ CompareStringsX(PropertyValueX("Key Group Type"),"IE","2")     OptionX("CreateIEIndex")   ]
#}SPItemEnd
 
 
SPItemBegin =  Accumulate Migrating Columns
10000: {#
                [
                        ForEachVectorReferenceX("Migrating Columns")
                        {
                                SeparatorX(",")
                                PhysicalNameX                       
                        }               
                ]
#}SPItemEnd
 
SPItemBegin =  Accumulate FK Columns
10000: {#
                [
                        ForEachVectorReferenceX("FK Columns")
                        {
                                SeparatorX(",")
                                PhysicalNameX                       
                        }               
                ]
#}SPItemEnd
 
SPItemBegin =  Accumulate Columns
10000: {#
                [
                        [       
                                IsObjectTypeX("Entity")
                                [OptionX("ColumnPhysicalOrder")
                                        ForEachVectorReferenceX("Physical Order List")
                                        {
                                                SeparatorX(",")
                                                PhysicalNameX
                                        }
                                ]
                                                    
                                [OptionX("!ColumnPhysicalOrder")
                                        ForEachVectorReferenceX("Column Order List")
                                        {
                                                SeparatorX(",")
                                                PhysicalNameX                    
                                        }
                                ]
                        ]
                        
                        [       
                                IsObjectTypeX("Key Group")
                                ForEachVectorReferenceX("Index Member Order List")
                                {
                                        SeparatorX(",")
                                        PhysicalNameX                    
                                }
                        ]
                ]
                
#}SPItemEnd
 
 
SPItemBegin =  PKConstraint
10000: {#[
                        IsNotNullX(CompareStringsX(PropertyValueX("Key Group Type"),"PK","2"),"<FALSE>")
                        OnceX("Constraint")
                        " PRIMARY KEY "
                        "(" 
                                IsNotNullX(ExecuteX("Accumulate Columns"),"<TRUE>")
                        ")"
                ]
#}SPItemEnd
 
SPItemBegin =  Generate Child Entity
10000: {#[
                        [
                                PushReferenceX("Child Entity Ref")
                                [
                                        GenerateX 
                                        "Generate"
                                ]
                                PopX
                        ]
                ]
#}SPItemEnd
 
SPItemBegin =  Generate Parent Entity
10000: {#[
                        [
                                PushReferenceX("Parent Entity Ref")
                                [                                       
                                        [IsObjectTypeX("Entity")
                                                        GenerateX "Generate"
                                        ]
                                        [IsObjectTypeX("Subtype Symbol")
                                                [
                                                        /* there can be only one of these*/
                                                        ForEachVectorReferenceX("Child Relations Ref")
                                                        {
                                                                [
                                                                        PushReferenceX("Parent Entity Ref")
                                                                                [
                                                                                        GenerateX "Generate"
                                                                                ]
                                                                        PopX
                                                                ]
                                                        }
                                                ]
                                        ]
 
                                ]
                                PopX
                        ]
                ]
#}SPItemEnd
 
 
SPItemBegin =  Generate Relation
10000: {#[
                        [
                                PushReferenceX("Relationship Ref")
                                [
                    GenerateX 
                    IsNotNullX(ExecuteX("Generate Child Entity"),"<FALSE>")
                    PushReferenceX( "Parent Entity Ref" )
                    [
                        @if( FE::FilterDanglingRelationships ){}
                                                @else
                                                {
                                                        "Generate"
                                                }
                    ]
                    PopX
                                        
                                ]
                                PopX
                        ]
                        
                        
                        [IsAlterScriptX
                                /*Generate if the object referenced by the deleted object has also been deleted.*/
                                /*If the object referenced by the deleted object is still active, then check the Generate property on the referenced object*/
                                
                                IsDeletedX 
                                PushOldReferenceX("Relationship Ref")
                                [
                                        /* The relationship referenced by the KeyGroup has been deleted*/
                                        /*FK indexes are maintained as long as the relationship is active*/
                                        [IsDeletedX
                                                PushOldReferenceX("Child Entity Ref")
                                                [
                                                        [/* The Child Entity referenced by the deleted relationship has also been deleted*/
                                                                IsDeletedX
                                                                        "Generate"
                                                        ]
                                                        [
                                                         /* The Child Entity referenced by the deleted relationship is still active*/
                                                                IsNullX([IsDeletedX "Not Deleted"])
                                                                GenerateX
                                                                "Generate"
                                                        ]
                                                ]
                                                PopX                                    
                                        ]
                                ]
                                PopX
                        ]
                ]
#}SPItemEnd
 
 
SPItemBegin =  FKConstraint
10000: {#[
                        IsNotNullX(CompareStringsX(PropertyValueX("Key Group Type"),"IF","2"),"<FALSE>")
                        IsNotNullX(ExecuteX("Generate Relation"),"<FALSE>")
                        OnceX("Constraint")
                        [OptionX("ConstraintName") "CONSTRAINT "
                                [PushReferenceX("Relationship Ref") PhysicalNameX " " PopX]
                        ]
                        " FOREIGN KEY "
                        "(" 
                                IsNotNullX(      ExecuteX("Accumulate FK Columns"), "<TRUE>"     )
                        ")"
                        " REFERENCES "
                        [PushReferenceX("Relationship Ref")
                                [
                                        PushReferenceX("Parent Entity Ref")
                                                [IsObjectTypeX("Entity")
                                                        [OwnerX"."]PhysicalNameX
                                                ]
                                                [IsObjectTypeX("Subtype Symbol")
                                                        [
                                                                /* there can be only one of these*/
                                                                ForEachVectorReferenceX("Child Relations Ref")
                                                                {
                                                                        [
                                                                                PushReferenceX("Parent Entity Ref")
                                                                                        [OwnerX"."]PhysicalNameX
                                                                                PopX
                                                                        ]
                                                                }
                                                        ]
                                                ]
                                        PopX
                                ]
                        PopX
                        ]
                        
                        "("
                                [IsNotNullX(     ExecuteX("Accumulate Migrating Columns"), "<TRUE>"      )]
                        ")"
                        
                        [PushReferenceX("Relationship Ref")
                                [OptionX("OnDeleteFKConstraint")
                        "\r\n\t\t" "ON DELETE "
                        DecodePropertyX("Relationship Parent Delete Rule",
                                                "10005",        "CASCADE")]
                        PopX]
                ]
#}SPItemEnd
 
 
SPItemBegin =  CreatePKConstraint
10000:{#[
                        ForEachChildObjectX("Key Group")
                        {
                                [
                                        IsNotNullX(CompareStringsX(PropertyValueX("Key Group Type"),"PK","2"),"<False>")
                                        SeparatorX(",\r\n\t")
                                        IsNotNullX(ExecuteX("PKConstraint"),"<TRUE>")
                                ]
                        }
                ]
#}SPItemEnd
 
 
SPItemBegin =  CreateAKConstraint
10000:{#[
                        ForEachChildObjectX("Key Group")
                        {
                                [
                                        IsNotNullX(CompareStringsX(PropertyValueX("Key Group Type"),"AK","2"),"<FALSE>")
                                        SeparatorX(",\r\n\t")
                                        IsNotNullX(ExecuteX("AKConstraint"),"<TRUE>")
                                ]
                                
                        }
                ]
#}SPItemEnd
 
 
SPItemBegin =  CreateFKConstraint
10000: {#[
                        ForEachChildObjectX("Key Group")
                        {
                                [
                                        IsNotNullX(CompareStringsX(PropertyValueX("Key Group Type"),"IF","2"),"<FALSE>")
                                        IsNotNullX(ExecuteX("Generate Relation"),"<FALSE>")
                                        SeparatorX(",\r\n\t")
                                        IsNotNullX(ExecuteX("FKConstraint"),"<TRUE>")
                                ]
                        }
                ]
#}SPItemEnd
 
SPItemBegin =  EndOfStatementX
10000:{# [
                        "\r\n"
                        ";"
                        "\r\n\r\n\r\n"
                        EndOfStatementX
                ]
#}SPItemEnd
 
SPItemBegin =  Column Values
10000: {#[
        [OptionX("ColumnPhysicalOrder")
                ForEachVectorReferenceX("Physical Order List")
                {
                        ExecuteX("Column Properties")
                }
        ]
                                
        [OptionX("!ColumnPhysicalOrder")
                ForEachVectorReferenceX("Column Order List")
                {
                        ExecuteX("Column Properties")
                }
        ]
]
#}SPItemEnd
 
 
SPItemBegin =  Column Properties
1:{# [
                SeparatorX(",")
                "\r\n\t" PhysicalNameX "  " DatatypeX
                [" " DecodePropertyX("Null Option","0","NULL","1","NOT NULL")]
                [OptionX("ColumnDefaultValue") 
                        [PushObjectX("Default Constraint Usage")
                                [PushReferenceX("Default Property")
                                        [GenerateX
                                        " DEFAULT " ExpandErwinMacroX("Server Value")]
                                PopX]
                        PopX]
                ]
                ["\r\n\t\t" IsNotNullX(ExecuteX("Column Check Constraints"),"<TRUE>")]                               
]
#}SPItemEnd
 
                                
SPItemBegin =  Generate Model
1:{# [
        OptionX("ModelPreScript")
                ForEachChildObjectX("Script Template","Object Order")
                {
                        [       
                                GenerateX
                                BucketX("1") 
                                DecodePropertyX("Gen As Pre Script","<True>","<Empty>")
                                DecodePropertyX("Type","1","<FALSE>","<TRUE>")
                                ExpandErwinMacroX("Template Code")
                                "\r\n\r\n\r\n"
                                EndOfStatementX
                        ]
                }
    ]
    [   IsForwardEngineeringX
        BucketX("95")
                ForEachChildObjectX("Stored Procedure","Object Order")
                {
                        GenerateX
                        DecodePropertyX("Type","1","<FALSE>","<TRUE>")
                        [OptionX("ModelDropProcedure") ExecuteX("Drop Stored Procedure")]
                        [OptionX("ModelCreateProcedure") ExecuteX("Create Stored Procedure")]
                }
    ]           
    [ 
        OptionX("ModelPostScript") BucketX("120")
                ForEachChildObjectX("Script Template","Object Order")
                {
                        [       
                                GenerateX
                                BucketX("120") 
                                DecodePropertyX("Gen As Pre Script","<TRUE>","<FALSE>","<TRUE>")
                                DecodePropertyX("Type","1","<FALSE>","<TRUE>")
                                ExpandErwinMacroX("Template Code")
                                "\r\n\r\n\r\n"
                                EndOfStatementX
                        ]
                }
    ]
#}SPItemEnd
 
 
SPItemBegin =  Create View
1: {# 
[GenerateX OnceX("Create View") 
        [
        OptionX("CreateView") BucketX("90")
        [
            IsNotNullX([PropertyValueX("View SQL")], "<TRUE>") ExecuteX("EndOfStatementX")
        ]
        [
            IsNullX([PropertyValueX("View SQL")])
            "CREATE VIEW " [OwnerX"."]NameX 
            [IsNotNullX([ExecuteX("View Column Has Alias")],"<FALSE>")
                                " ( "
                                ForEachVectorReferenceX("Physical Order List")
                                {
                                        GenerateX
                                        SeparatorX(",")
                                        NameX
                                }
                                " ) "
                        ]
                        " AS"
            IsNotNullX(ExecuteX("Select Statement"),"<TRUE>")
            ["\r\n\t\t" DecodePropertyX("View With Check","1","WITH CHECK OPTION")]
            ExecuteX("EndOfStatementX")
        ]
        
    ]
    [
        BucketX("95")
                ForEachVectorReferenceX("Stored Procedures")
                {
                        GenerateX
                        DecodePropertyX("Type","1","<TRUE>")
                        [OptionX("ViewDropStoredProcedure") ExecuteX("Drop Stored Procedure")]
                        [OptionX("ViewCreateStoredProcedure") ExecuteX("Create Stored Procedure")]
                }
    ]
    [
        OptionX("ViewPostScript") BucketX("90")
                ForEachVectorReferenceX("Script Templates")
                {
                        [  
                                GenerateX
                                BucketX("90")
                                DecodePropertyX("Gen As Pre Script","<TRUE>","<FALSE>","<TRUE>")
                                ExpandErwinMacroX("Template Code")
                                "\r\n\r\n\r\n"
                                EndOfStatementX
                        ]
                }
    ]
    [IsAlterScriptX IsModifiedX
                ForEachVectorReferenceX("Parent Relations Ref")
                {
                        [
                                PushReferenceX("Child Entity Ref")
                                        [IsObjectTypeX("View")
                                                IsNullX([IsDeletedX "Not Deleted"])
                                                ExecuteX("Create View")
                                        ]
                                PopX
                        ]
                }
        ]
]
#}SPItemEnd
 
 
SPItemBegin =  Drop View
1:{#[GenerateX OnceX("Drop View")
         [
        OptionX("ViewPreScript") 
                ForEachVectorReferenceX("Script Templates")
                {
                        [
                                GenerateX
                                DecodePropertyX("Gen As Pre Script","<TRUE>","<Empty>")
                                BucketX("90") ExpandErwinMacroX("Template Code")
                                "\r\n\r\n\r\n"
                                EndOfStatementX
                        ]
                }
    ]
    [
        OptionX("DropView") 
        [IsAlterScriptX 
                                ForEachVectorReferenceX("Parent Relations Ref")
                                {
                                        [
                                                PushReferenceX("Child Entity Ref")
                                                        [IsObjectTypeX("View")
                                                                ExecuteX("Drop View")
                                                        ]
                                                PopX
                                        ]
                                }
                ]
        BucketX("40")
        [
                        "DROP VIEW " [PrevOwnerX"."] IsNotNullX(PrevPhysicalNameX, "<TRUE>") 
                        ExecuteX("EndOfStatementX")
                ]
    ]
]
#}SPItemEnd
 
 
SPItemBegin =  Generate View
1:{# [
        GenerateX ExecuteX("Drop View")
        GenerateX ExecuteX("Create View") 
    ]
#}SPItemEnd
 
 
SPItemBegin =  Create Entity
1:{#    
[GenerateX OnceX("Create Entity")
        [OptionX("TablePreScript") 
                        ForEachVectorReferenceX("Script Templates")
                        {
                                [
                                        GenerateX
                                        DecodePropertyX("Gen As Pre Script","<TRUE>","<Empty>")
                                        BucketX("90") ExpandErwinMacroX("Template Code")
                                        "\r\n\r\n\r\n"
                                        EndOfStatementX
                                ]
                        }
                ]
        [OptionX("CreateTable") 
                FESetStringX("Create Entity")
                 BucketX("90")
        "CREATE TABLE " [OwnerX"."] PhysicalNameX
                "\r\n("
                IsNotNullX(ExecuteX("Column Values"),"<TRUE>")           
                                
                [ ",\r\n\t" OptionX("PKConstraintInCreate")
                        IsNotNullX(ExecuteX("CreatePKConstraint"),"<TRUE>")
                ]
                [ OptionX("FKConstraintInCreate")
                        IsNotNullX(ExecuteX("CreateFKConstraint"),"<TRUE>")
                ]
                [ ",\r\n\t" OptionX("TableCheckConstraint")
                                IsNotNullX(ExecuteX("CreateTableCheckConstraint"),"<TRUE>")
                ]
                "\r\n" ")"
 
                ExecuteX("EndOfStatementX")
    ]
    
    [/* Generate PK constraint and its corresponding Index*/
                ForEachChildObjectX("Key Group")
                {
                        [       IsNotNullX(CompareStringsX(PropertyValueX("Key Group Type"),"PK","2"),"<FALSE>")
                                [BucketX("90")
                                        ExecuteX("Create Key Group")
                                ]
                                
                                [OptionX("PKConstraintInAlter") BucketX("90")
                                        "ALTER TABLE " 
                                        [PushOwnerX
                                                [OwnerX"."]PhysicalNameX
                                        PopX]
                                        "\r\n\t" "ADD " IsNotNullX(ExecuteX("PKConstraint"),"<TRUE>")
                                        ExecuteX("EndOfStatementX")
                                ]
                        ]
                }
        ]
        
        [/*Generate non-unique & unique indexes (Ak, IE and IF)*/
                ForEachChildObjectX("Key Group","Key Group Type")
                {
                        [
                                IsNullX([CompareStringsX(PropertyValueX("Key Group Type"),"PK","2")])
                                [BucketX("90")
                                        ExecuteX("Create Key Group")
                                ]
                        ]
                }
        ]
 
        [
                OptionX("FKConstraintInAlter") BucketX("91")
                [
                        ForEachChildObjectX("Key Group")
                        {
                                "ALTER TABLE "
                                [PushOwnerX
                                        [OwnerX"."]PhysicalNameX
                                PopX]
                                "\r\n\t" "ADD " IsNotNullX(ExecuteX("FKConstraint"),"<TRUE>")
                                ExecuteX("EndOfStatementX")
                        }
                ]
        ]
    [
        BucketX("105")
                ForEachVectorReferenceX("Stored Procedures")
                {
                        GenerateX
                        DecodePropertyX("Type","1","<TRUE>")
                        [OptionX("TableDropProcedure") ExecuteX("Drop Stored Procedure")]
                        [OptionX("TableCreateProcedure") ExecuteX("Create Stored Procedure")]
                }
    ]  
    [ 
        OptionX("TablePostScript") BucketX("90")
                ForEachVectorReferenceX("Script Templates")
                {
                        [  
                                GenerateX
                                BucketX("90")
                                DecodePropertyX("Gen As Pre Script","<TRUE>","<FALSE>","<TRUE>")
                                ExpandErwinMacroX("Template Code")
                                "\r\n\r\n\r\n"
                                EndOfStatementX
                        ]
                }
    ]
    
    [IsAlterScriptX 
                ForEachVectorReferenceX("Parent Relations Ref")
                {
                        [
                                PushReferenceX("Child Entity Ref")
                                        [IsObjectTypeX("View")
                                                IsNullX([IsDeletedX "Not Deleted"])
                                                ExecuteX("Create View")
                                        ]
                                PopX
                        ]
                }
        ]
        
]
#}SPItemEnd
 
 
SPItemBegin =  Drop Entity
1:{# [OnceX("Drop Entity") GenerateX 
                [BucketX("40")
                        ForEachChildObjectX("Key Group")
                        {
                                BucketX("40")
                                ExecuteX("Drop Key Group")
                        }
                ]
                [OptionX("DropTable")
                        [IsAlterScriptX 
                                        ForEachVectorReferenceX("Parent Relations Ref")
                                        {
                                                [
                                                        PushReferenceX("Child Entity Ref")
                                                                [IsObjectTypeX("View")
                                                                        ExecuteX("Drop View")
                                                                ]
                                                        PopX
                                                ]
                                        }
                        ]
                
                
                        [BucketX("40") "\r\n"
                        "DROP TABLE " [PrevOwnerX"."] IsNotNullX(PrevPhysicalNameX, "<TRUE>") 
                        ExecuteX("EndOfStatementX")]
                ]
        ]
#}SPItemEnd
 
 
SPItemBegin =  Generate Entity
1:{# 
[OnceX("Generate Entity")
 
        [IsForwardEngineeringX      
                [GenerateX ExecuteX("Drop Entity")]                          
                [GenerateX ExecuteX("Create Entity")]
        ]
        
        [IsAlterScriptX
                /* Add this entity in the data preservation list. */
                [ActivateDataPreservationX()]
    
                /*Create the temp table and copy the data into it*/
                [DataPreservationOptionsX("PreserveData")
                        BucketX("20") "\r\n"
                        ExecuteX("Create Temp Table And Copy Data")
                ]
            
                ExecuteX("Drop Entity") 
                ExecuteX("Create Entity") 
            
                /*Insert the data from temp table to the new modified table*/
                [DataPreservationOptionsX("PreserveData") 
                        BucketX("130") "\r\n"
                        ExecuteX("Insert Columns For Data Preservation")
                        DataPreservationOptionsX("RegisterEntity")
                ]
            
                /*Drop the temp table*/
                [DataPreservationOptionsX("DropTempTable") 
                        BucketX("140") "\r\n" 
                        ExecuteX("Drop Temp Table")
                ]
        ]
]
#}
SPItemEnd
 
 
SPItemBegin =  Create Key Group
1:{# [GenerateX IsNotNullX(ExecuteX("Index Create Option")) 
                OnceX("Create Key Group")
                FESetStringX("Create Key Group")
        BucketX("90")
                "CREATE" 
                [DecodePropertyX("Is Unique","<TRUE>"," UNIQUE")]
                " INDEX " PhysicalNameX " ON "
                [PushOwnerX  PhysicalNameX PopX]
                "\r\n("
                ForEachVectorReferenceX("Index Member Order List")
                {
                        SeparatorX(",")
            "\r\n\t" PhysicalNameX
                }
                "\r\n)"
            ExecuteX("EndOfStatementX")
    ]
#}SPItemEnd
 
SPItemBegin =  Key Group Has Members
1:
{#
[
        [IsNotNullX([PropertyValueX("Index Member Order List")],"<FALSE>") "Has Members"]
        [AllObjectsHaveBeenDeletedX("Key Group Member") "Had Members"]
]
#}
SPItemEnd
 
 
SPItemBegin =  Drop Key Group
1:{# [
                IsAlterScriptX
                IsNullX([AllObjectsAreNewlyCreatedX("Key Group Member") "Suppress Statement"])
                IsNotNullX(ExecuteX("Key Group Has Members"),"<FALSE>")
                [ OnceX("Drop Key Group") GenerateX IsNotNullX(ExecuteX("Index Drop Option"),"<FALSE>")
                        [BucketX("38") "DROP INDEX " PrevPhysicalNameX ExecuteX("EndOfStatementX")]
                ]
        ]
        
        [ IsForwardEngineeringX     
                IsNotNullX(ExecuteX("Index Drop Option"))
                OnceX("Drop Key Group") GenerateX IsNotNullX(ExecuteX("Index Drop Option"),"<FALSE>")
                [BucketX("38") "DROP INDEX " PrevPhysicalNameX ExecuteX("EndOfStatementX")]
        ]
#}SPItemEnd
 
 
SPItemBegin =  Generate Key Group
1:{# [
       ExecuteX("Drop Key Group")
         ExecuteX("Create Key Group")
    ]
#}SPItemEnd
 
 
SPItemBegin =  Create Stored Procedure
1:{# [
        ExpandErwinMacroX("Template Code")
        ExecuteX("EndOfStatementX")
    ]
#}SPItemEnd
 
 
SPItemBegin =  Drop Stored Procedure
1:{# [
                BucketX("100")
                "DROP PROCEDURE " PrevPhysicalNameX
        ExecuteX("EndOfStatementX")
    ]
#}SPItemEnd
 
 
SPItemBegin =  Generate Stored Procedure
1:{# [
                ExecuteX("Drop Stored Procedure")
        ExecuteX("Create Stored Procedure")
    ]
#}SPItemEnd
 
 
SPItemBegin = Alter Modify Relationship
1:                             
{#      
 
        [
                /* No Operation*/
        ]
#}
SPItemEnd
 
 
 
SPItemBegin = Alter Allow Modify Key Group Properties
10000: 
{#
[
        IsModifiedListX("Key Group Member Order List")
                "ALTER MODIFY HANDLED"
] 
#}
SPItemEnd
 
 
 
SPItemBegin = Alter Modify Key Group
1: 
{#      
 
        
        [IsNullX(ExecuteX("Alter Allow Modify Key Group Properties"))
                        [
                                [
                                        ExecuteX("Generate Key Group")
                                ]
                        ]
    ]
    
#}
SPItemEnd
 
 
SPItemBegin = Alter Allow Modify Entity Properties
10000: 
{#
[
        IsModifiedListX("Physical Order List", "Column Order List", "Attribute Order List")
                "ALTER MODIFY HANDLED"
] 
#}
SPItemEnd
 
 
SPItemBegin = Alter Modify Entity
1: 
{#      
        /* Process the  (EMXTypes::pPhysicalOrderList) property of the Entity. */
        [IsPropModifiedX("Physical Order List")
                OptionX("ColumnPhysicalOrder")
                [ListRearrangedX("Physical Order List")
        
                        [ExecuteX("Generate Entity")]
                ]
        ]
        
        /* Process the  (EMXTypes::pColumnOrderList) property of the Entity. */
        [IsPropModifiedX("Column Order List")
                [       OptionX("!ColumnPhysicalOrder")
                        ListRearrangedX("Column Order List")
        
                        [ExecuteX("Generate Entity")]
                ]
        ]
        
        
        [IsNullX(ExecuteX("Alter Allow Modify Entity Properties"))
                        [
                                [
                                        ExecuteX("Generate Entity")
                                ]
                        ]
    ]
    
#}
SPItemEnd
 
 
SPItemBegin = Alter Allow Modify Attribute Properties
10000: 
{#
[
        IsModifiedListX
                "ALTER MODIFY HANDLED"
] 
#}
SPItemEnd
 
 
 
SPItemBegin = Alter Modify Attribute
1: 
{#      
 
        
        [IsNullX(ExecuteX("Alter Allow Modify Attribute Properties"))
                PushTopLevelObjectX
                        [
                                [
                                        ExecuteX(ExecuteX("Modify Object"))
                                ]
                        ]
                PopX
    ]
    
#}
SPItemEnd
 
 
SPItemBegin =  Use Alter To Add Column
1:
{#
        [OptionX("AlterStatements") "USE ALTER" ]
        [OptionX("!AlterStatements") 
            IsLastColumnX 
                [DecodePropertyX("Null Option", "1", "<EMPTY>") 
                        [
                                PushObjectX("Default Constraint Usage")
                                        "USE ALTER"
                                PopX
                        ]
                ]
                
                [
                        DecodePropertyX("Null Option", "1", "<FALSE>","<TRUE>") 
                                "USE ALTER"
                ]
        ]
 
 
#}
SPItemEnd
 
 
 
SPItemBegin = Create Attribute
1:
{#
    /* Do not alter if the entire entity was created. */
    [IsNullX(ExecuteX("This Entity Created"))
                IsNotNullX(ExecuteX("Use Alter To Add Column"),"<FALSE>")
        BucketX("85")
        FESetStringX("Create Attribute")
        RecordAlterX
        PushOwnerX 
        "ALTER TABLE " PhysicalNameX PopX        
        " (ADD " PhysicalNameX "  " DatatypeX ")"
        ExecuteX("EndOfStatementX")
    ]
    
    [
                IsNullX(ExecuteX("Use Alter To Add Column"))
                
                PushOwnerX
                        ExecuteX("Generate Entity")
                PopX
    
]
 
#}
SPItemEnd
 
SPItemBegin = Drop Attribute
1:
{# 
        /* Do not alter if the entire entity was deleted. */
    [IsNullX(ExecuteX("This Entity Deleted"))
                FESetStringX("Drop Attribute")
                BucketX("40")
                RecordAlterX
                PushOwnerX 
                "ALTER TABLE " PhysicalNameX PopX
                " DROP " PrevPhysicalNameX
                ExecuteX("EndOfStatementX")    
    ]
#}
SPItemEnd
 
SPItemBegin =  IsObjectEntity
10000: {#[
                        PushOwnerX [ IsObjectTypeX("Entity") "Entity" ]PopX
]
#}SPItemEnd
 
SPItemBegin =  IsObjectView
10000: {#[
                        PushOwnerX [ IsObjectTypeX("View") "View" ]PopX
]
#}SPItemEnd
 
 
SPItemBegin =  This Entity Created
1:
{#
        PushOwnerX
                [IsNotNullX(ExecuteX("If Entity Created")) " CREATED"]
        PopX
 
#}
SPItemEnd
 
SPItemBegin =  This Entity Deleted
1:
{#
        PushOwnerX
                [IsNotNullX(ExecuteX("If Entity Deleted")) " Deleted"]
        PopX
 
#}
SPItemEnd
 
 
SPItemBegin = This Attribute Created
10000:
{#
        PushOwnerX
    [
                /* Evaluates to TRUE if QueryStringX is true. */
                [QueryStringX("Create Attribute") "TRUE"]
                
                ExecuteX("This Entity Created")
    ]
        PopX
#}
SPItemEnd
 
SPItemBegin = This Attribute Deleted
10000:
{#
        PushOwnerX
    [
                /* Evaluates to TRUE if QueryStringX is true. */
                [QueryStringX("Drop Attribute") "TRUE"]
                
                ExecuteX("This Entity Deleted")
        ]
        PopX
#}
SPItemEnd
 
 
SPItemBegin = If Entity Created
10000:
{#
    /* Evaluates to TRUE if QueryStringX is true. */
    [QueryStringX("Create Entity") "TRUE"]
#}
SPItemEnd
 
SPItemBegin = If Entity Deleted
10000:
{#
    /* Evaluates to TRUE if QueryStringX is true. */
    [QueryStringX("Drop Entity") "TRUE"]
#}
SPItemEnd
 
 
 
SPItemBegin = Drop Check Constraint Usage 
1: 
{# 
  [
        /* No Operation*/
  ]
#}
SPItemEnd
 
 
SPItemBegin = Create Check Constraint Usage
1: 
{# 
        [
        /* No Operation*/
        ]
#}
SPItemEnd
 
 
SPItemBegin = Alter Modify Check Constraint Usage 
1: 
{#      [
        /* No Operation*/
        ]
#}
SPItemEnd
 
 
SPItemBegin = Drop Table Check Constraint Usage 
1: 
{# 
        [
        /* No Operation*/
        ]
#}
SPItemEnd
 
 
SPItemBegin = Create Table Check Constraint Usage
1: 
{# 
        [
        /* No Operation*/
        ]    
#}
SPItemEnd
 
 
 
SPItemBegin = Generate Table Check Constraint Usage
1: 
{#
    ExecuteX("Drop Table Check Constraint Usage") 
    ExecuteX("Create Table Check Constraint Usage") 
#}
SPItemEnd
 
 
SPItemBegin = Alter Modify Table Check Constraint Usage
1: 
{#
    ExecuteX("Generate Table Check Constraint Usage") 
#}
SPItemEnd
 
 
SPItemBegin = Create Default Constraint Usage
1: 
{# 
[
        /* No Operation*/
        ]
#}
SPItemEnd
 
 
SPItemBegin = Drop Default Constraint Usage
1: 
{#
        [
        /* No Operation*/
        ]
#}
SPItemEnd
 
 
 
 
 
 
SPItemBegin = Alter Modify Default Constraint Usage
1: 
{#      [
        /* No Operation*/
        ]
#} 
SPItemEnd
 
SPItemBegin = Alter Modify Default
1: 
{# [
    /* For each referring oDefaultConstraintUsage object, 
    *  drop and recreate the entire table. */
    ForEachVectorReferenceX("Dependent Objects Ref")
    {
        [
                        ExecuteX("Alter Modify Default Constraint Usage")       
                ]
    }
  ]  
#}
SPItemEnd
 
SPItemBegin = Alter Modify Validation Rule
1: 
{# [
    /* For each referring oCheckConstraintUsage objec  . */
    ForEachVectorReferenceX("Dependent Objects Ref")
    {   
        [
                        PushOwnerX
                        [  IsObjectTypeX("Attribute")
                                PopX
                                        [ExecuteX("Alter Modify Check Constraint Usage")]
                        ]
                        
                        [  IsObjectTypeX("Entity")
                                PopX
                                        [ExecuteX("Alter Modify Table Check Constraint Usage")]
                        ]
                ]
    }
  ]
#}
SPItemEnd
 
 
SPItemBegin = Table Has Insert Columns For Data Preservation 
10000: 
{#[
 
        ForEachVectorReferenceX("Column Order List")
        {
                [ IsNullX([IsCreatedX "Suppress Column"])
                        SeparatorX(", ")
                        PhysicalNameX
                ]
        }
]
#}
SPItemEnd
 
SPItemBegin = Available For Select
10000: 
{#[  
    ConversionFunctionX 
    "This Column has a Conversion Function"    
]
#}
SPItemEnd
 
SPItemBegin = Insert Columns For Data Preservation
10000: 
{#[
        IsNotNullX(ExecuteX("Table Has Insert Columns For Data Preservation"),"<FALSE>")
        /* Prepare the insert query for the data preservation. */
    "INSERT INTO " [OwnerX"."] PhysicalNameX
    " ("
                ForEachVectorReferenceX("Column Order List")
                {
                        [
                                IsNotNullX(ExecuteX("Available For Select"),"<FALSE>")
                                SeparatorX(", ")
                                PhysicalNameX
                        ]
                }
        ") SELECT "
                        ForEachVectorReferenceX("Column Order List")
                        {
                                [
                                    IsNotNullX(ExecuteX("Available For Select"),"<FALSE>")
                                        SeparatorX(", ")
                                        ConversionFunctionX()
                                ]
                        }
        " FROM "  TempTableX("Temporary")       
                [" WHERE " DataPreservationOptionsX("WhereClause")]    
    ExecuteX("EndOfStatementX")
]
#}
SPItemEnd
 
 
SPItemBegin = Drop Temp Table
10000: 
{#
        [IsNotNullX(ExecuteX("Table Has Insert Columns For Data Preservation"),"<FALSE>")
                "DROP TABLE " [OwnerX"."] IsNotNullX(TempTableX("Temporary"), "<TRUE>") ExecuteX("EndOfStatementX")
        ]
#}
SPItemEnd
 
SPItemBegin = Create Temp Table And Copy Data
10000: 
{#
[IsNotNullX(ExecuteX("Table Has Insert Columns For Data Preservation"),"<FALSE>")
        [
                "CREATE TABLE " [OwnerX"."] TempTableX("Temporary")
                "\r\n" 
                "("
                        ForEachVectorReferenceX("Column Order List")
                        {
                                [
                                        IsNullX([IsCreatedX  "Newly created - Suppress"])
                                        SeparatorX(",\r\n")
                                        PrevPhysicalNameX " " PropertyValueX("Datatype")
                                ]
                        }
                ")"
                ExecuteX("EndOfStatementX")
        ]
 
        [
                "SELECT "
                        
                        ForEachVectorReferenceX("Column Order List")
                        {
                                [
                                        IsNullX([IsCreatedX  "Newly created - Suppress"])
                                        SeparatorX(",\r\n")
                                        PrevPhysicalNameX 
                                ]
                        }
                    
                        " INTO " [OwnerX"."] TempTableX("Temporary")
                        " FROM " [[PrevOwnerX"."][IsNullX([PrevOwnerX]) OwnerX"."]] PrevPhysicalNameX ExecuteX("EndOfStatementX")
        ]
]
#}
SPItemEnd
 
 
 
SPItemBegin = Alter Create Handled
10000: 
{#
[
        IsObjectTypeX("Attribute", "Default Constraint Usage", "Check Constraint Usage")
                "ALTER CREATE HANDLED"
] 
#}
SPItemEnd
 
 
SPItemBegin = Alter Generic Create Object
10000: 
{#
[
    [IsObjectTypeX("Attribute") IsNotNullX(ExecuteX("IsObjectEntity"))
        ExecuteX("Create Attribute")
        ]
        
    [IsObjectTypeX("Check Constraint Usage")
        PushOwnerX
        [IsObjectTypeX("Attribute")
            PopX
            [ExecuteX("Create Check Constraint Usage")]
                ]
        [IsObjectTypeX("Entity")
                        PopX
            [ExecuteX("Create Table Check Constraint Usage")]
                ]
        ]
        
    [IsObjectTypeX("Default Constraint Usage")
        ExecuteX("Create Default Constraint Usage")
    ]
 
    [IsNullX(ExecuteX("Alter Create Handled"))
        PushTopLevelObjectX
                [
            [IsNotNullX(ExecuteX("Object Newly Created"),"<FALSE>")
                [ExecuteX(ExecuteX("Create Object"))]
                        ]
            [IsNullX(ExecuteX("Object Newly Created"))
                [ExecuteX(ExecuteX("Generate Object"))]
                        ]
                ]
                PopX
    ]
]
#}
SPItemEnd
 
 
SPItemBegin = Object Newly Created
10000: 
{#
["Generate " IsCreatedX]
#}
SPItemEnd
 
 
SPItemBegin = Create Object
10000: 
{#
"Create " ObjectNameX
#}
SPItemEnd
 
SPItemBegin = Generate Object
10000: 
{#
"Generate " ObjectNameX
#}
SPItemEnd
 
 
 
SPItemBegin = Alter Drop Handled
10000: 
{#
[
        IsObjectTypeX("Attribute", "Check Constraint Usage", "Default Constraint Usage")
                "ALTER DROP HANDLED"
] 
#}
SPItemEnd
 
 
SPItemBegin = Alter Generic Drop Object
10000: 
{#
[       
    [IsObjectTypeX("Attribute") IsNotNullX(ExecuteX("IsObjectEntity"))
        [ExecuteX("Drop Attribute")]
        ]
        
    [IsObjectTypeX("Default Constraint Usage")
        [ExecuteX("Drop Default Constraint Usage")]
        ]
                
    [IsObjectTypeX("Check Constraint Usage")
        PushOwnerX
        [IsObjectTypeX("Attribute")
            PopX
            [ExecuteX("Drop Check Constraint Usage")]
                ]
        [IsObjectTypeX("Entity")
                        PopX
            [ExecuteX("Drop Table Check Constraint Usage")]
                ]
        ]
        
    [IsNullX(ExecuteX("Alter Drop Handled"))
        PushTopLevelObjectX
        [
            [IsNullX([IsDeletedX "Top Level Object Deleted"])
                [ExecuteX(ExecuteX("Generate Object"))]
                        ]                               
                        [IsNotNullX([IsDeletedX "Top Level Object Deleted"],"<FALSE>")
                            [ExecuteX(ExecuteX("Drop Object"))]
                        ]
                ]
                PopX
    ]   
] 
#}
SPItemEnd
 
SPItemBegin = Drop Object
10000: 
{#
"Drop " ObjectNameX
#}
SPItemEnd
 
 
SPItemBegin = Alter Modify Handled
10000: 
{#
[
        IsObjectTypeX("Entity", "Relationship", "Attribute", "Default", "Validation Rule", "Check Constraint Usage", "Default Constraint Usage", "Key Group", "Redbrick Segment")
        
        "ALTER MODIFY HANDLED"
] 
#}
SPItemEnd
 
 
SPItemBegin = Alter Generic Modify Object
10000: 
{#
[ 
    [IsObjectTypeX("Default")
        ExecuteX("Alter Modify Default")
        ]
        
    [IsObjectTypeX("Validation Rule")
        ExecuteX("Alter Modify Validation Rule")
        ]
 
    [IsObjectTypeX("Check Constraint Usage")
        [ExecuteX("Alter Modify Default Constraint Usage")]
        ]
        
    [IsObjectTypeX("Check Constraint Usage")
        PushOwnerX
        [IsObjectTypeX("Attribute")
            PopX
            [ExecuteX("Alter Modify Check Constraint Usage")]
                ]               
        [IsObjectTypeX("Entity")
                        PopX
            [ExecuteX("Alter Modify Table Check Constraint Usage")]
                ]
        ]
        
    [IsObjectTypeX("Attribute") IsNotNullX(ExecuteX("IsObjectEntity"))
        ExecuteX("Alter Modify Attribute")
        ]
                
    [IsObjectTypeX("Attribute") IsNotNullX(ExecuteX("IsObjectView"))
        ExecuteX("Handle Modify Object")
        ]
        
    [IsObjectTypeX("Entity")
        ExecuteX("Alter Modify Entity")
        ]
 
    [IsObjectTypeX("Key Group")
        ExecuteX("Alter Modify Key Group")
        ]
 
    [IsObjectTypeX("Relationship")
        ExecuteX("Alter Modify Relationship")
        ]
        
    [IsObjectTypeX("Redbrick Segment")
        ExecuteX("Alter Modify Redbrick Segment")
        ]
 
    [IsNullX(ExecuteX("Alter Modify Handled"))
        ExecuteX("Handle Modify Object")
    ]
]
#}
SPItemEnd
 
SPItemBegin = Handle Modify Object
10000: 
{#
        [
                PushTopLevelObjectX
                        [
                                ExecuteX(ExecuteX("Modify Object"))
                        ]
                PopX
        ]
#}
SPItemEnd
 
                
SPItemBegin = Modify Object
10000: 
{#
"Generate " ObjectNameX
#}
SPItemEnd