Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

318 lines
14 KiB
C#

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Data.SqlClient;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
namespace System.Data.Linq.SqlClient {
using System.Data.Linq.Mapping;
using System.Data.Linq.Provider;
using System.Diagnostics.CodeAnalysis;
/// <summary>
/// Class for building up SQL DDL commands.
/// </summary>
internal static class SqlBuilder {
internal static string GetCreateDatabaseCommand(string catalog, string dataFilename, string logFilename) {
StringBuilder sb = new StringBuilder();
sb.AppendFormat("CREATE DATABASE {0}", SqlIdentifier.QuoteIdentifier(catalog));
if (dataFilename != null) {
sb.AppendFormat(" ON PRIMARY (NAME='{0}', FILENAME='{1}')", Path.GetFileName(dataFilename), dataFilename);
sb.AppendFormat(" LOG ON (NAME='{0}', FILENAME='{1}')", Path.GetFileName(logFilename), logFilename);
}
return sb.ToString();
}
internal static string GetDropDatabaseCommand(string catalog) {
StringBuilder sb = new StringBuilder();
sb.AppendFormat("DROP DATABASE {0}", SqlIdentifier.QuoteIdentifier(catalog));
return sb.ToString();
}
internal static string GetCreateSchemaForTableCommand(MetaTable table) {
StringBuilder sb = new StringBuilder();
List<string> parts = new List<string>(SqlIdentifier.GetCompoundIdentifierParts(table.TableName));
// table names look like this in Yukon (according to MSDN):
// [ database_name . [ schema_name ] . | schema_name . ] table_name
// ... which means that either way, the schema name is the second to last part.
if ((parts.Count) < 2) {
return null;
}
string schema = parts[parts.Count - 2];
if (String.Compare(schema, "DBO", StringComparison.OrdinalIgnoreCase) != 0 &&
String.Compare(schema, "[DBO]", StringComparison.OrdinalIgnoreCase) != 0) {
sb.AppendFormat("CREATE SCHEMA {0}", SqlIdentifier.QuoteIdentifier(schema));
}
return sb.ToString();
}
internal static string GetCreateTableCommand(MetaTable table) {
StringBuilder sb = new StringBuilder();
StringBuilder decl = new StringBuilder();
BuildFieldDeclarations(table, decl);
sb.AppendFormat("CREATE TABLE {0}", SqlIdentifier.QuoteCompoundIdentifier(table.TableName));
sb.Append("(");
sb.Append(decl.ToString());
decl = new StringBuilder();
BuildPrimaryKey(table, decl);
if (decl.Length > 0) {
string name = String.Format(Globalization.CultureInfo.InvariantCulture, "PK_{0}", table.TableName);
sb.Append(", ");
sb.AppendLine();
sb.AppendFormat(" CONSTRAINT {0} PRIMARY KEY ({1})", SqlIdentifier.QuoteIdentifier(name), decl.ToString());
}
sb.AppendLine();
sb.Append(" )");
return sb.ToString();
}
internal static void BuildFieldDeclarations(MetaTable table, StringBuilder sb) {
int n = 0;
Dictionary<object, string> memberNameToMappedName = new Dictionary<object, string>();
foreach (MetaType type in table.RowType.InheritanceTypes) {
n += BuildFieldDeclarations(type, memberNameToMappedName, sb);
}
if (n == 0) {
throw Error.CreateDatabaseFailedBecauseOfClassWithNoMembers(table.RowType.Type);
}
}
private static int BuildFieldDeclarations(MetaType type, Dictionary<object, string> memberNameToMappedName, StringBuilder sb) {
int n = 0;
foreach (MetaDataMember mm in type.DataMembers) {
// Only generate declarations for the current type.
if (mm.IsDeclaredBy(type)) {
if (!mm.IsAssociation) {
if (mm.IsPersistent) {
object dn = InheritanceRules.DistinguishedMemberName(mm.Member);
string mappedName;
if (memberNameToMappedName.TryGetValue(dn, out mappedName)) {
if (mappedName == mm.MappedName) {
continue;
}
}
else {
memberNameToMappedName.Add(dn, mm.MappedName);
}
if (sb.Length > 0) {
sb.Append(", ");
}
sb.AppendLine();
sb.Append(string.Format(Globalization.CultureInfo.InvariantCulture, " {0} ", SqlIdentifier.QuoteCompoundIdentifier(mm.MappedName)));
if (!string.IsNullOrEmpty(mm.Expression)) {
// Generate "AS <expression>" for computed columns
sb.Append("AS " + mm.Expression);
}
else {
sb.Append(GetDbType(mm));
}
n++;
}
}
}
}
return n;
}
private static void BuildPrimaryKey(MetaTable table, StringBuilder sb) {
foreach (MetaDataMember mm in table.RowType.IdentityMembers) {
if (sb.Length > 0) {
sb.Append(", ");
}
sb.Append(SqlIdentifier.QuoteCompoundIdentifier(mm.MappedName));
}
}
private static string BuildKey(IEnumerable<MetaDataMember> members) {
StringBuilder sb = new StringBuilder();
foreach (MetaDataMember mm in members) {
if (sb.Length > 0) {
sb.Append(", ");
}
sb.Append(SqlIdentifier.QuoteCompoundIdentifier(mm.MappedName));
}
return sb.ToString();
}
internal static IEnumerable<String> GetCreateForeignKeyCommands(MetaTable table) {
foreach (MetaType type in table.RowType.InheritanceTypes) {
foreach (string command in GetCreateForeignKeyCommands(type)) {
yield return command;
}
}
}
private static IEnumerable<String> GetCreateForeignKeyCommands(MetaType type) {
string tableName = type.Table.TableName;
foreach (MetaDataMember mm in type.DataMembers) {
if (mm.IsDeclaredBy(type) && mm.IsAssociation) {
MetaAssociation assoc = mm.Association;
if (assoc.IsForeignKey) {
StringBuilder sb = new StringBuilder();
string thisKey = BuildKey(assoc.ThisKey);
string otherKey = BuildKey(assoc.OtherKey);
string otherTable = assoc.OtherType.Table.TableName;
string name;
name = mm.MappedName;
if (name == mm.Name) {
name = String.Format(Globalization.CultureInfo.InvariantCulture, "FK_{0}_{1}", tableName, mm.Name);
}
string cmd = "ALTER TABLE {0}" + Environment.NewLine + " ADD CONSTRAINT {1} FOREIGN KEY ({2}) REFERENCES {3}({4})";
//In DLinq we put the constraint on the child object (which triggers the behavior when deleted),
//but in SQL it is part of the parent constraint (the parent row gets changed / deleted to satisfy the constraint)
MetaDataMember otherMember = mm.Association.OtherMember;
if (otherMember != null) {
string delConstr = otherMember.Association.DeleteRule;
if (delConstr != null) {
cmd += Environment.NewLine + " ON DELETE " + delConstr;
}
}
sb.AppendFormat(cmd,
SqlIdentifier.QuoteCompoundIdentifier(tableName),
SqlIdentifier.QuoteIdentifier(name),
SqlIdentifier.QuoteCompoundIdentifier(thisKey),
SqlIdentifier.QuoteCompoundIdentifier(otherTable),
SqlIdentifier.QuoteCompoundIdentifier(otherKey));
yield return sb.ToString();
}
}
}
}
[SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification="These issues are related to our use of if-then and case statements for node types, which adds to the complexity count however when reviewed they are easy to navigate and understand.")]
private static string GetDbType(MetaDataMember mm) {
string dbType = mm.DbType;
if (dbType != null) return dbType;
StringBuilder sb = new StringBuilder();
Type type = mm.Type;
bool isNullable = mm.CanBeNull;
if (type.IsValueType && IsNullable(type)) {
type = type.GetGenericArguments()[0];
}
if (mm.IsVersion) {
sb.Append("Timestamp");
}
else {
if (mm.IsPrimaryKey && mm.IsDbGenerated) {
switch (Type.GetTypeCode(type)) {
case TypeCode.Byte:
sb.Append("TinyInt");
break;
case TypeCode.SByte:
case TypeCode.Int16:
sb.Append("SmallInt");
break;
case TypeCode.Int32:
case TypeCode.UInt16:
sb.Append("Int");
break;
case TypeCode.Int64:
case TypeCode.UInt32:
sb.Append("BigInt");
break;
case TypeCode.UInt64:
case TypeCode.Decimal:
sb.Append("Decimal(20)");
break;
case TypeCode.Object:
if (type == typeof(Guid)) {
sb.Append("UniqueIdentifier");
} else {
throw Error.CouldNotDetermineDbGeneratedSqlType(type);
}
break;
}
}
else {
switch (Type.GetTypeCode(type)) {
case TypeCode.Boolean:
sb.Append("Bit");
break;
case TypeCode.Byte:
sb.Append("TinyInt");
break;
case TypeCode.SByte:
case TypeCode.Int16:
sb.Append("SmallInt");
break;
case TypeCode.Int32:
case TypeCode.UInt16:
sb.Append("Int");
break;
case TypeCode.Int64:
case TypeCode.UInt32:
sb.Append("BigInt");
break;
case TypeCode.UInt64:
sb.Append("Decimal(20)");
break;
case TypeCode.Decimal:
sb.Append("Decimal(29, 4)");
break;
case TypeCode.Double:
sb.Append("Float");
break;
case TypeCode.Single:
sb.Append("Real");
break;
case TypeCode.Char:
sb.Append("NChar(1)");
break;
case TypeCode.String:
sb.Append("NVarChar(4000)");
break;
case TypeCode.DateTime:
sb.Append("DateTime");
break;
case TypeCode.Object:
if (type == typeof(Guid)) {
sb.Append("UniqueIdentifier");
} else if (type == typeof(byte[])) {
sb.Append("VarBinary(8000)");
} else if (type == typeof(char[])) {
sb.Append("NVarChar(4000)");
} else if (type == typeof(DateTimeOffset)) {
sb.Append("DateTimeOffset");
} else if (type == typeof(TimeSpan)) {
sb.Append("Time");
} else {
throw Error.CouldNotDetermineSqlType(type);
}
break;
}
}
}
if (!isNullable) {
sb.Append(" NOT NULL");
}
if (mm.IsPrimaryKey && mm.IsDbGenerated) {
if (type == typeof(Guid)) {
sb.Append(" DEFAULT NEWID()");
}
else {
sb.Append(" IDENTITY");
}
}
return sb.ToString();
}
internal static bool IsNullable(Type type) {
return type.IsGenericType && typeof(Nullable<>).IsAssignableFrom(type.GetGenericTypeDefinition());
}
}
}