public static void ExecuteNonQuery(SqlCommand cmd)
{
    try
    {
        using (var conn = GetSqlConnection())
        {
            cmd.Connection = conn;
            cmd.ExecuteNonQuery();
         }
    }
    catch (Exception ex)
    {
       log.Error(ex.Message, ex);
        throw;
    }
}

SELECT
	name
	, type
	, type_desc
 FROM sys.objects
 WHERE object_id IN (693577509)

static readonly object locker = new object();

public static void ExecuteNonQuery(SqlCommand cmd)
{
    try
    {
        lock (locker)
        {
            using (var conn = GetSqlConnection())
            {
                cmd.Connection = conn;
                cmd.ExecuteNonQuery();
            }
        }
    }
    catch (Exception ex)
    {
        log.Error(ex.Message, ex);
        throw;
    }
}

SELECT 
  DB_NAME(DPS.DATABASE_ID) AS [DatabaseName]
  , OBJECT_NAME(DPS.OBJECT_ID) AS TableName
  , SI.NAME AS IndexName
  , DPS.INDEX_TYPE_DESC AS IndexType
  , DPS.AVG_FRAGMENTATION_IN_PERCENT AS AvgPageFragmentation
  , DPS.PAGE_COUNT AS PageCounts
FROM sys.dm_db_index_physical_stats (DB_ID(), NULL, NULL , NULL, NULL) DPS --N'LIMITED') DPS
INNER JOIN sysindexes SI 
    ON DPS.OBJECT_ID = SI.ID 
    AND DPS.INDEX_ID = SI.INDID
ORDER BY AVG_FRAGMENTATION_IN_PERCENT  DESC

-- Index neu erstellen
EXEC sp_MSforeachtable @command1="print 'Erstelle Index für ?' ALTER INDEX ALL ON ? REBUILD WITH (FILLFACTOR = 90)"
GO

-- Index reorganisieren
EXEC sp_MSforeachtable @command1="print 'Reorgansiere Index für ?' ALTER INDEX ALL ON ? REORGANIZE"
GO

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data.Sql;
using System.Data.SqlTypes;
using System.Linq;
using System.Text;
using Microsoft.SqlServer.Server;

namespace Firma.Projekt.TVFStringConvert
{
    public class StringConvertTable
    {
        [SqlFunction(FillRowMethodName = "FillRow")]
        public static IEnumerable Inititalize(string tags)
        {
            return ParseString(tags);
        }

        public static void FillRow(Object obj, out SqlInt32 keyId, out SqlInt32 valueId)
        {
            if (obj == null)
                SqlContext.Pipe.Send("The obj to create a tupel is null.");

            Tag tag = obj as Tag;
            keyId = tag.ParentId;
            valueId = tag.Id;
        }       

        public static ICollection<Tag> ParseString(string tagString)
        {
            if (tagString != null)
            {
                return ExternalLib.Convert(tagString);
            }

            return new List<Tag>(0);
        }       
    }
}

USE TestDatabase
GO

-- Für Permission Set External_Access und Unsafe
-- Bad Practice, besser die DLL mit einem richtigen Zertifikat signieren 
-- ALTER DATABASE TestDatabase SET TRUSTWORTHY ON

IF EXISTS (SELECT name FROM sysobjects WHERE name = 'StringConvertTable')
   DROP FUNCTION StringConvertTable
GO

IF EXISTS (SELECT name FROM sys.assemblies WHERE name = 'TVFStringConvert')
   DROP ASSEMBLY [TVFStringConvert]
GO

CREATE ASSEMBLY [TVFStringConvert] 
FROM 'C:\projects\ Firma.Projekt.TVFStringConvert\Firma.Projekt.TVFStringConvert.dll'
WITH PERMISSION_SET = UNSAFE --SAFE 
GO

CREATE FUNCTION StringConvertTable(@tags nvarchar(max)) 
RETURNS TABLE (
   keyId int,
   valueId int
)
AS EXTERNAL NAME TVFStringConvert.[Firma.Projekt.TVFStringConvert.StringConvertTable].[Inititalize]
GO

-- Test (Weiterverwendung mit CROSS APPLY)
SELECT * FROM StringConvertTable('kreative Datenlogik')
GO

-- Servereinstellungen
EXEC sp_configure 'clr enabled', 1
GO
RECONFIGURE
GO

-- --------------------------------------------------
-- Creating all FOREIGN KEY constraints
-- --------------------------------------------------
 
-- Creating foreign key on [OrderID] in table 'OrderItems'
ALTER TABLE [dbo].[OrderItems]
ADD CONSTRAINT [FK_OrderOrderItem]
    FOREIGN KEY ([OrderID])
    REFERENCES [dbo].[Orders]
        ([ID])
    ON DELETE NO ACTION ON UPDATE NO ACTION;
 
-- Creating non-clustered index for FOREIGN KEY 'FK_OrderOrderItem'
CREATE INDEX [IX_FK_OrderOrderItem]
ON [dbo].[OrderItems]
    ([OrderID]);
GO

SELECT
	*
FROM dbo.Orders o
INNER JOIN dbo.OrderItems oi ON o.Id = oi.OrderId 
WHERE o.id IN (1,5,10,34,80,92,500,897,3456,4567)

DECLARE @table nvarchar(100), 
	@fkName nvarchar(100), 
	@columnName nvarchar(100), 
	@index nvarchar(800)

DECLARE missing_FkIndex_cursor CURSOR FOR SELECT
      t.name as TB_Name
      , fk.name as FK_Name
      , c.name as Column_Name
FROM sys.foreign_key_columns fkc
INNER JOIN sys.tables t ON t.object_id = fkc.parent_object_id
INNER JOIN sys.foreign_keys fk ON fk.parent_object_id =
fkc.parent_object_id
INNER JOIN sys.columns c ON c.object_id = fk.parent_object_id AND
c.column_id = fkc.parent_column_id
LEFT OUTER JOIN sys.index_columns indc ON indc.object_id = c.object_id AND
c.column_id = indc.column_id
LEFT OUTER JOIN sys.indexes ind ON ind.object_id = indc.object_id AND
ind.index_id = indc.index_id
WHERE fk.type = 'F' AND ind.name is null

OPEN missing_FkIndex_cursor;

FETCH NEXT FROM missing_FkIndex_cursor 
INTO  @table, @fkName, @columnName

WHILE @@FETCH_STATUS = 0
BEGIN
	SET @index = 'CREATE INDEX IX_FK_' + @fkName + '_' + @columnName + ' ON ' + @table + ' (' + @columnName + ')'
	EXECUTE sp_executesql @index
	PRINT @index
	
	FETCH NEXT FROM missing_FkIndex_cursor 
		INTO  @table, @fkName, @columnName
END
CLOSE missing_FkIndex_cursor;
DEALLOCATE missing_FkIndex_cursor;

 public class CreateSqlServerDatabaseWithFkIndizesIfNotExists<T> 
    : CreateDatabaseIfNotExists<T> where T : DbContext
  {
    protected override void Seed(T context)
    {
      context.Database.ExecuteSqlCommand(GetFkIndexSqlScript());
      base.Seed(context);
    }

    private string GetFkIndexSqlScript()
    {
      return @"
        DECLARE @table nvarchar(100), 
	        @fkName nvarchar(100), 
	        @columnName nvarchar(100), 
	        @index nvarchar(800)

        DECLARE missing_FkIndex_cursor CURSOR FOR SELECT
              t.name as TB_Name, 
              fk.name as FK_Name
              , c.name as Column_Name
              --, ind.name as Index_Name
              --, fk.type_desc as FK_Type
        FROM sys.foreign_key_columns fkc
        INNER JOIN sys.tables t ON t.object_id = fkc.parent_object_id
        INNER JOIN sys.foreign_keys fk ON fk.parent_object_id =
        fkc.parent_object_id
        INNER JOIN sys.columns c ON c.object_id = fk.parent_object_id AND
        c.column_id = fkc.parent_column_id
        LEFT OUTER JOIN sys.index_columns indc ON indc.object_id = c.object_id AND
        c.column_id = indc.column_id
        LEFT OUTER JOIN sys.indexes ind ON ind.object_id = indc.object_id AND
        ind.index_id = indc.index_id
        WHERE fk.type = 'F' AND ind.name is null

        OPEN missing_FkIndex_cursor;

        FETCH NEXT FROM missing_FkIndex_cursor 
        INTO  @table, @fkName, @columnName

        WHILE @@FETCH_STATUS = 0
        BEGIN
	        SET @index = 'CREATE INDEX IX_FK_' + @fkName + '_' + @columnName + ' ON ' + @table + ' (' + @columnName + ')'
	        EXECUTE sp_executesql @index
	        PRINT @index
	
	        FETCH NEXT FROM missing_FkIndex_cursor 
		        INTO  @table, @fkName, @columnName
        END
        CLOSE missing_FkIndex_cursor;
        DEALLOCATE missing_FkIndex_cursor;      ";
    }
  }

      var initializer = new CreateSqlServerDatabaseWithFkIndizesIfNotExists<TestContext>();
      Database.SetInitializer<TestContext>
        (initializer);
      initializer.InitializeDatabase(new TestContext());

// required for documentation
MetadataLoader loader = new MetadataLoader(this);
MetadataTools ef = new MetadataTools(this);
var ItemCollection = loader.CreateEdmItemCollection(edmxPath, new string[] {});
EntityContainer container = ItemCollection.GetItems<EntityContainer>().FirstOrDefault();
// ----

this.WriteLine("-- EDM Dokumentation");
// EDM-Dokumentation der Entity auf SQL-Server übertragen
		
// get entity from entity set
string entityType = (from c in container.BaseEntitySets
					where c.Name == entitySet.Name
					select c.ElementType.Name).FirstOrDefault();

EntityType entity = (from e in ItemCollection.GetItems<EntityType>()
					where e.Name == entityType
					select e).FirstOrDefault();

string tableDoku = String.Empty;
if (entity.Documentation != null && 
	entity.Documentation.Summary != null)
{
	tableDoku = entity.Documentation.Summary;
}
	
string propertyProcedure = @"
	exec sp_addextendedproperty N'MS_Description', '{0}', N'user', N'dbo', 
		N'table', N'{1}'
	GO";

if (String.IsNullOrEmpty(tableDoku) == false)
	this.WriteLine(propertyProcedure, tableDoku, tableName);
	
foreach (EdmProperty item in entity.Properties)
{
	if (item.Documentation != null && item.Documentation.Summary != null)
	{
		string columnDoku = item.Documentation.Summary;
		string columnPropertyProcedure = @"exec sp_addextendedproperty N'MS_Description', '{0}', N'user', 
				N'dbo', N'table', N'{1}', N'column', N'{2}'
				GO";
		this.WriteLine(columnPropertyProcedure, columnDoku, tableName, item.Name);
	}
}

this.WriteLine("-- End documentation");

<# 
//---------------------------------------------------------------------
// <copyright file="SsdlToSql10.tt" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//---------------------------------------------------------------------
// This T4 template generates T-SQL from an instance of 
// System.Data.Metadata.Edm.StoreItemCollection, an object representation
// of the SSDL. This T-SQL is compatible with SQL 2008, 2005, CE, and Azure databases.
//---------------------------------------------------------------------
// Note: We will resolve all paths in assembly directives at runtime, taking 
// macros into account (e.g. $(DevEnvDir), $(ProjectDir), etc.)
#>
<#@ assembly name="System.Core" #>
<#@ assembly name="System.Data.Entity" #>
<#@ assembly name="System.Data.Entity.Design" #>
<#@ assembly name="$(DevEnvDir)Microsoft.Data.Entity.Design.DatabaseGeneration.dll"#>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Data.Entity.Design" #>
<#@ import namespace="System.Data.Metadata.Edm" #>
<#@ import namespace="Microsoft.Data.Entity.Design.DatabaseGeneration" #>
<#@ import namespace="System.Runtime.Remoting.Messaging" #>
<#@ import namespace="System.Text.RegularExpressions" #>
<#@ template language="C#" debug="true" hostspecific="true" #>
<#@ include file="GenerateTSQL.Utility.ttinclude"#>
<#@ include file="EF.Utility.CS.ttinclude"#> -- Dokumentation
<#@ output extension = ".sql" #>
<#

// +++++++++++++++++++++++++++++++++++++++++++++++++
// Setup for the template (initializing variables, etc.)
// +++++++++++++++++++++++++++++++++++++++++++++++++

    string databaseName = this.GetInput<string>(EdmParameterBag.ParameterName.DatabaseName.ToString());
    string edmxPath = this.GetInput<string>(EdmParameterBag.ParameterName.EdmxPath.ToString());
    Version targetVersion = this.GetInput<Version>(EdmParameterBag.ParameterName.TargetVersion.ToString());
 
	// required for documentation
	MetadataLoader loader = new MetadataLoader(this);
	MetadataTools ef = new MetadataTools(this);
	var ItemCollection = loader.CreateEdmItemCollection(edmxPath, new string[] {});
	EntityContainer container = ItemCollection.GetItems<EntityContainer>().FirstOrDefault();
	// ----
	
    if (false == InitializeAndValidateExistingStore()) 
    {
#>
-- Warning: There were errors validating the existing SSDL. Drop statements
-- will not be generated.
<#
    }
#>
-- --------------------------------------------------
<#
    if (this.IsSQLCE) {
#>
-- Entity Designer DDL Script for SQL Server Compact Edition
<#
    } else {
#>
-- Entity Designer DDL Script for SQL Server 2005, 2008, and Azure
<#
    }
#>
-- --------------------------------------------------
-- Date Created: <#=DateTime.Now#>
<#
    if (!String.IsNullOrEmpty(edmxPath))
    {
#>
-- Generated from EDMX file: <#=Id(edmxPath)#>
<#
    }
#>
-- --------------------------------------------------

<#  if (!this.IsSQLCE) 
    { 
#>
SET QUOTED_IDENTIFIER OFF;
GO
<#  if (!String.IsNullOrEmpty(databaseName))
    {
#>
USE [<#=Id(databaseName)#>];
GO
<#
    }
    foreach (string unescapedSchemaName in (from es in Store.GetAllEntitySets() select es.GetSchemaName()).Distinct())
    {
#>
IF SCHEMA_ID(N'<#=Lit(unescapedSchemaName)#>') IS NULL EXECUTE(N'CREATE SCHEMA [<#=Id(unescapedSchemaName)#>]');
<#
    }
#>
GO
<#  } #>

-- --------------------------------------------------
-- Dropping existing FOREIGN KEY constraints
<#  if (this.IsSQLCE)
    {
#>
-- NOTE: if the constraint does not exist, an ignorable error will be reported.
<#  } #>
-- --------------------------------------------------

<#
    foreach (AssociationSet associationSet in ExistingStore.GetAllAssociationSets())
    {
        ReferentialConstraint constraint = associationSet.ElementType.ReferentialConstraints.Single();
        string constraintName = Id(WriteFKConstraintName(constraint));
        AssociationSetEnd dependentSetEnd = associationSet.AssociationSetEnds.Where(ase => ase.CorrespondingAssociationEndMember == constraint.ToRole).Single();
        string schemaName = Id(dependentSetEnd.EntitySet.GetSchemaName());
        string dependentTableName = Id(dependentSetEnd.EntitySet.GetTableName());
        
        if (!this.IsSQLCE)
        {
#>
IF OBJECT_ID(N'[<#=Lit(schemaName)#>].[<#=Lit(constraintName)#>]', 'F') IS NOT NULL
<#      } #>
    ALTER TABLE <# if (!IsSQLCE) {#>[<#=schemaName#>].<#}#>[<#=dependentTableName#>] DROP CONSTRAINT [<#=constraintName#>];
GO
<#
    }
#>

-- --------------------------------------------------
-- Dropping existing tables
<#  if (this.IsSQLCE)
    {
#>
-- NOTE: if the table does not exist, an ignorable error will be reported.
<#  } #>
-- --------------------------------------------------

<#
    foreach (EntitySet entitySet in ExistingStore.GetAllEntitySets())
    { 
        string schemaName = Id(entitySet.GetSchemaName());
        string tableName = Id(entitySet.GetTableName());
        
        if (!this.IsSQLCE)
        {
#>
IF OBJECT_ID(N'[<#=Lit(schemaName)#>].[<#=Lit(tableName)#>]', 'U') IS NOT NULL
<#      } #>
    DROP TABLE <# if (!IsSQLCE) {#>[<#=schemaName#>].<#}#>[<#=tableName#>];
GO
<#
    }
#>

-- --------------------------------------------------
-- Creating all tables
-- --------------------------------------------------

<#

    foreach (EntitySet entitySet in Store.GetAllEntitySets())
    {
		
        string schemaName = Id(entitySet.GetSchemaName());
        string tableName = Id(entitySet.GetTableName());
#>
-- Creating table '<#=tableName#>'
CREATE TABLE <# if (!IsSQLCE) {#>[<#=schemaName#>].<#}#>[<#=tableName#>] (
<#
        for (int p = 0; p < entitySet.ElementType.Properties.Count; p++)
        {
            EdmProperty prop = entitySet.ElementType.Properties[p];
#>
    [<#=Id(prop.Name)#>] <#=prop.ToStoreType()#> <#=WriteIdentity(prop, targetVersion)#> <#=WriteNullable(prop.Nullable)#><#=(p < entitySet.ElementType.Properties.Count - 1) ? "," : ""#>
<#
        }
	
#>
);
GO

<#
this.WriteLine("-- EDM Dokumentation");
// EDM-Dokumentation der Entity auf SQL-Server übertragen
		
// get entity from entity set
string entityType = (from c in container.BaseEntitySets
					where c.Name == entitySet.Name
					select c.ElementType.Name).FirstOrDefault();

EntityType entity = (from e in ItemCollection.GetItems<EntityType>()
					where e.Name == entityType
					select e).FirstOrDefault();

string tableDoku = String.Empty;
if (entity.Documentation != null && 
	entity.Documentation.Summary != null)
{
	tableDoku = entity.Documentation.Summary;
}
	
string propertyProcedure = @"
	exec sp_addextendedproperty N'MS_Description', '{0}', N'user', N'dbo', 
		N'table', N'{1}'
	GO";

if (String.IsNullOrEmpty(tableDoku) == false)
	this.WriteLine(propertyProcedure, tableDoku, tableName);
	
foreach (EdmProperty item in entity.Properties)
{
	if (item.Documentation != null && item.Documentation.Summary != null)
	{
		string columnDoku = item.Documentation.Summary;
		string columnPropertyProcedure = @"exec sp_addextendedproperty N'MS_Description', '{0}', N'user', 
				N'dbo', N'table', N'{1}', N'column', N'{2}'
				GO";
		this.WriteLine(columnPropertyProcedure, columnDoku, tableName, item.Name);
	}
}

this.WriteLine("-- End documentation");
    } 
#>
-- --------------------------------------------------
-- Creating all PRIMARY KEY constraints
-- --------------------------------------------------

<#
    foreach (EntitySet entitySet in Store.GetAllEntitySets())
    {
        string schemaName = Id(entitySet.GetSchemaName());
        string tableName = Id(entitySet.GetTableName());
#>
-- Creating primary key on <#=WriteColumns(entitySet.ElementType.GetKeyProperties(), ',')#> in table '<#=tableName#>'
ALTER TABLE <# if (!IsSQLCE) {#>[<#=schemaName#>].<#}#>[<#=tableName#>]
ADD CONSTRAINT [PK_<#=tableName#>]
    PRIMARY KEY <# if (!IsSQLCE) {#><#=WriteClustered(Store, entitySet.ElementType)#> <#}#>(<#=WriteColumns(entitySet.ElementType.GetKeyProperties(), ',')#> <# if (!IsSQLCE) {#>ASC<#}#>);
GO

<#
    }
#>
-- --------------------------------------------------
-- Creating all FOREIGN KEY constraints
-- --------------------------------------------------

<#
    foreach (AssociationSet associationSet in Store.GetAllAssociationSets())
    {
        ReferentialConstraint constraint = associationSet.ElementType.ReferentialConstraints.Single();
        AssociationSetEnd dependentSetEnd = associationSet.AssociationSetEnds.Where(ase => ase.CorrespondingAssociationEndMember == constraint.ToRole).Single();
        AssociationSetEnd principalSetEnd = associationSet.AssociationSetEnds.Where(ase => ase.CorrespondingAssociationEndMember == constraint.FromRole).Single();
        string schemaName = Id(dependentSetEnd.EntitySet.GetSchemaName());
        string dependentTableName = Id(dependentSetEnd.EntitySet.GetTableName());
        string principalTableName = Id(principalSetEnd.EntitySet.GetTableName());
#>
-- Creating foreign key on <#=WriteColumns(constraint.ToProperties, ',')#> in table '<#=dependentTableName#>'
ALTER TABLE <#if (!IsSQLCE) {#>[<#=schemaName#>].<#}#>[<#=dependentTableName#>]
ADD CONSTRAINT [<#=WriteFKConstraintName(constraint)#>]
    FOREIGN KEY (<#=WriteColumns(constraint.ToProperties, ',')#>)
    REFERENCES <# if (!IsSQLCE) {#>[<#=schemaName#>].<#}#>[<#=principalTableName#>]
        (<#=WriteColumns(constraint.FromProperties, ',')#>)
    ON DELETE <#=GetDeleteAction(constraint)#> ON UPDATE NO ACTION;
<#      
        // if the foreign keys are part of the primary key on the dependent end, then we should not add a constraint.
        if (!dependentSetEnd.EntitySet.ElementType.GetKeyProperties().Take(constraint.ToProperties.Count()).OrderBy(r => r.Name).SequenceEqual(constraint.ToProperties.OrderBy(r => r.Name)))
        {
#>

-- Creating non-clustered index for FOREIGN KEY '<#=WriteFKConstraintName(constraint)#>'
CREATE INDEX [IX_<#=WriteFKConstraintName(constraint)#>]
ON <#if (!IsSQLCE) {#>[<#=schemaName#>].<#}#>[<#=dependentTableName#>]
    (<#=WriteColumns(constraint.ToProperties, ',')#>);
<#      
        }
#>
GO

<#
    }
#>
-- --------------------------------------------------
-- Script has ended
-- --------------------------------------------------

-- Dokumentation
-- --------------------------------------------------
-- Entity Designer DDL Script for SQL Server 2005, 2008, and Azure
-- --------------------------------------------------
-- Date Created: 05/11/2011 21:35:51
-- Generated from EDMX file: DokuTest.edmx
-- --------------------------------------------------

SET QUOTED_IDENTIFIER OFF;
GO
USE [dbDWHQueryTest];
GO
IF SCHEMA_ID(N'dbo') IS NULL EXECUTE(N'CREATE SCHEMA [dbo]');
GO

-- --------------------------------------------------
-- Dropping existing FOREIGN KEY constraints
-- --------------------------------------------------


-- --------------------------------------------------
-- Dropping existing tables
-- --------------------------------------------------


-- --------------------------------------------------
-- Creating all tables
-- --------------------------------------------------

-- Creating table 'ProductMenge'
CREATE TABLE [dbo].[ProductMenge] (
    [ID] int IDENTITY(1,1) NOT NULL,
    [Name] nvarchar(max)  NOT NULL,
    [CategoryID] int  NOT NULL
);
GO

-- EDM Dokumentation

	exec sp_addextendedproperty N'MS_Description', 'Enthält alle Produkte und dient als Beispiel für die SQL Server Extended Properties', N'user', N'dbo', 
		N'table', N'ProductMenge'
	GO
exec sp_addextendedproperty N'MS_Description', 'Identifiziert das Produkt', N'user', 
				N'dbo', N'table', N'ProductMenge', N'column', N'ID'
				GO
exec sp_addextendedproperty N'MS_Description', 'Name des Produkts', N'user', 
				N'dbo', N'table', N'ProductMenge', N'column', N'Name'
				GO
exec sp_addextendedproperty N'MS_Description', 'Fremdschlüssel auf die Kategorie', N'user', 
				N'dbo', N'table', N'ProductMenge', N'column', N'CategoryID'
				GO
-- End documentation
-- Creating table 'CategoryMenge'
CREATE TABLE [dbo].[CategoryMenge] (
    [ID] int IDENTITY(1,1) NOT NULL,
    [Name] nvarchar(max)  NOT NULL
);
GO

-- EDM Dokumentation

	exec sp_addextendedproperty N'MS_Description', 'Enthält alle Produkte und dient als Beispiel für die SQL Server Extended Properties', N'user', N'dbo', 
		N'table', N'CategoryMenge'
	GO
exec sp_addextendedproperty N'MS_Description', 'Identifiziert die Kategorie', N'user', 
				N'dbo', N'table', N'CategoryMenge', N'column', N'ID'
				GO
exec sp_addextendedproperty N'MS_Description', 'Bezeichnung der Kategorie', N'user', 
				N'dbo', N'table', N'CategoryMenge', N'column', N'Name'
				GO
-- End documentation
-- --------------------------------------------------
-- Creating all PRIMARY KEY constraints
-- --------------------------------------------------

-- Creating primary key on [ID] in table 'ProductMenge'
ALTER TABLE [dbo].[ProductMenge]
ADD CONSTRAINT [PK_ProductMenge]
    PRIMARY KEY CLUSTERED ([ID] ASC);
GO

-- Creating primary key on [ID] in table 'CategoryMenge'
ALTER TABLE [dbo].[CategoryMenge]
ADD CONSTRAINT [PK_CategoryMenge]
    PRIMARY KEY CLUSTERED ([ID] ASC);
GO

-- --------------------------------------------------
-- Creating all FOREIGN KEY constraints
-- --------------------------------------------------

-- Creating foreign key on [CategoryID] in table 'ProductMenge'
ALTER TABLE [dbo].[ProductMenge]
ADD CONSTRAINT [FK_CategoryProduct]
    FOREIGN KEY ([CategoryID])
    REFERENCES [dbo].[CategoryMenge]
        ([ID])
    ON DELETE NO ACTION ON UPDATE NO ACTION;

-- Creating non-clustered index for FOREIGN KEY 'FK_CategoryProduct'
CREATE INDEX [IX_FK_CategoryProduct]
ON [dbo].[ProductMenge]
    ([CategoryID]);
GO

-- --------------------------------------------------
-- Script has ended
-- --------------------------------------------------