public virtual void SetOtherKey(string literalOtherKey, MetaTable thisTable, MetaTable otherTable, MetaDataMember otherAssociationMember)
{
var comma = new[] { ',' };
var otherKeysList = new List<MetaDataMember>();
if (literalOtherKey != null)
{
foreach (var otherKeyRaw in literalOtherKey.Split(comma, StringSplitOptions.RemoveEmptyEntries))
{
var otherKey = otherKeyRaw.Trim();
//we need to revisit this code - it has caused problems on both MySql and Pgsql
MemberInfo[] otherKeyFields = otherTable.RowType.Type.GetMember(otherKey);
if (otherKeyFields.Length == 0)
{
string msg = "ERROR L57 Database contains broken join information."
+ " thisTable=" + thisTable.TableName
+ " otherTable=" + otherTable.TableName
+ " orphanKey=" + literalOtherKey;
throw new InvalidOperationException(msg);
}
var keyMember = otherKeyFields[0];
otherKeysList.Add(new AttributedColumnMetaDataMember(keyMember, GetColumnAttribute(keyMember),
thisTable.RowType));
}
}
otherKeys = new ReadOnlyCollection<MetaDataMember>(otherKeysList);
otherMember = otherAssociationMember;
}
public string CreateTableSQL(
MetaTable table)
{
StringBuilder sqlText = new StringBuilder();
sqlText.AppendFormat("CREATE TABLE {0}(\r\n", table.TableName);
for (int memberIndex = 0; memberIndex < table.RowType.DataMembers.Count; memberIndex++)
{
MetaDataMember member = table.RowType.DataMembers[memberIndex];
bool isLastColomn = memberIndex >= table.RowType.DataMembers.Count - 1;
if (!member.IsAssociation)
{
sqlText.AppendFormat("\t{0}{1}\r\n",
CreateColomnSQL(table, member),
isLastColomn ? "" : ",");
}
}
// TODO: Foreign key associations
sqlText.Append(");\r\n");
return sqlText.ToString();
}
internal SqlTable(MetaTable table, MetaType rowType, ProviderType sqlRowType, Expression sourceExpression)
: base(SqlNodeType.Table, sourceExpression) {
this.table = table;
this.rowType = rowType;
this.sqlRowType = sqlRowType;
this.columns = new List<SqlColumn>();
}
public RepositoryMetaTable(string workspace, MetaTable orig, MetaModel model)
{
this.Workspace = workspace;
this.Original = orig;
this.RepositoryMetaModel = model;
this.RepositoryMetaType = new RepositoryMetaType(workspace, orig.RowType, this, model);
}
public RepositoryMetaType(string workspace, MetaType original, MetaTable table, MetaModel metaModel)
{
this.Workspace = workspace;
this.Original = original;
this.RepositoryMetaTable = table;
this.RepositoryMetaModel = metaModel;
}
public CustomMetaTable(MetaTable table, MetaModel model)
{
_table = table;
_model = model;
_tableName = (_table.TableName.Contains(".") ? "" : "dbo.") + _table.TableName;
var tableNameField = table.GetType().GetField("tableName", BindingFlags.NonPublic | BindingFlags.Instance);
tableNameField.SetValue(_table, _tableName);
}
public string DeleteTableSQL(
MetaTable table)
{
StringBuilder sqlText = new StringBuilder();
sqlText.AppendFormat("IF OBJECT_ID('{0}', 'U') IS NOT NULL\r\n", table.TableName);
sqlText.AppendFormat("DROP TABLE {0};\r\n", table.TableName);
return sqlText.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 object locktarget = new object(); // Hold locks on private object rather than public MetaType.
#endregion
internal MappedType(MetaModel model, MetaTable table, TypeMapping typeMapping, Type type, MetaType inheritanceRoot)
{
this.model = model;
this.table = table;
this.typeMapping = typeMapping;
this.type = type;
this.inheritanceRoot = inheritanceRoot != null ? inheritanceRoot : this;
this.InitDataMembers();
this.identities = this.dataMembers.Where(m => m.IsPrimaryKey).ToList().AsReadOnly();
this.persistentDataMembers = this.dataMembers.Where(m => m.IsPersistent).ToList().AsReadOnly();
}
object locktarget = new object(); // Hold locks on private object rather than public MetaType.
internal AttributedMetaType(MetaModel model, MetaTable table, Type type, MetaType inheritanceRoot)
{
this.model = model;
this.table = table;
this.type = type;
this.inheritanceRoot = (inheritanceRoot != null) ? inheritanceRoot : this;
// Not lazy-loading to simplify locking and enhance performance
// (because no lock will be required for the common read scenario).
this.InitDataMembers();
this.identities = this.dataMembers.Where(m => m.IsPrimaryKey).ToList().AsReadOnly();
this.persistentMembers = this.dataMembers.Where(m => m.IsPersistent).ToList().AsReadOnly();
}
public DLinqTableProvider (DataModelProvider owner, DMetaTable meta)
: base (owner)
{
EntityType = meta.RowType.Type;
Name = meta.TableName;
int idx = Name.LastIndexOf ('.');
Name = idx < 0 ? Name : Name.Substring (idx + 1);
var l = new List<ColumnProvider> ();
foreach (var c in meta.RowType.DataMembers)
l.Add (new DLinqColumnProvider (this, c));
columns = new ReadOnlyCollection<ColumnProvider> (l);
}
public DataBossRowType(MetaTable table, Type type) {
this.table = table;
this.type = type;
foreach(var item in type.GetFields()) {
var linqColumn = item.GetCustomAttributes(typeof(System.Data.Linq.Mapping.ColumnAttribute)).Cast<System.Data.Linq.Mapping.ColumnAttribute>().SingleOrDefault();
if(linqColumn != null) {
members.Add(new DataBossDataMember(this, item, item.FieldType, linqColumn.Name));
}
var column = item.GetCustomAttributes(typeof(System.ComponentModel.DataAnnotations.Schema.ColumnAttribute)).Cast<System.ComponentModel.DataAnnotations.Schema.ColumnAttribute>().SingleOrDefault();
if(column != null) {
members.Add(new DataBossDataMember(this, item, item.FieldType, item.Name));
}
}
}
public DLinqTableProvider(DataModelProvider owner, DMetaTable meta)
: base(owner)
{
EntityType = meta.RowType.Type;
Name = meta.TableName;
int idx = Name.LastIndexOf('.');
Name = idx < 0 ? Name : Name.Substring(idx + 1);
var l = new List <ColumnProvider> ();
foreach (var c in meta.RowType.DataMembers)
{
l.Add(new DLinqColumnProvider(this, c));
}
columns = new ReadOnlyCollection <ColumnProvider> (l);
}
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 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();
}
public string CreateColomnSQL(
MetaTable table,
MetaDataMember member)
{
StringBuilder sqlText = new StringBuilder();
if (member.IsPrimaryKey)
{
sqlText.AppendFormat("{0} INTEGER PRIMARY KEY AUTOINCREMENT ", member.MappedName);
}
else
{
sqlText.AppendFormat("{0} {1} ", member.MappedName, member.DbType);
}
if (!member.CanBeNull)
{
sqlText.Append("NOT NULL");
}
return sqlText.ToString();
}
public string CreateColomnSQL(
MetaTable table,
MetaDataMember member)
{
StringBuilder sqlText = new StringBuilder();
sqlText.AppendFormat("{0} {1} ", member.MappedName, FilterDBType(member.DbType));
if (member.IsPrimaryKey)
{
sqlText.AppendFormat("IDENTITY(1,1) CONSTRAINT PK_{0} PRIMARY KEY CLUSTERED ", table.TableName);
}
// TODO: Foreign key associations
if (!member.CanBeNull)
{
sqlText.Append("NOT NULL");
}
return sqlText.ToString();
}
/// <summary>
/// Retrieves the table creation SQL command.
/// </summary>
/// <param name="metaTable">The meta table.</param>
/// <returns></returns>
private static string retrieveTableCreationSQL(MetaTable metaTable)
{
var typeName = "System.Data.Linq.SqlClient.SqlBuilder";
var type = typeof(System.Data.Linq.DataContext).Assembly.GetType(typeName);
var bf = BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.InvokeMethod;
var sql = type.InvokeMember("GetCreateTableCommand", bf, null, null, new[] { metaTable });
var sqlAsString = sql.ToString();
return sqlAsString;
}
protected virtual IList<MemberInfo> GetAssociationKeys(MetaTable description, ReadOnlyCollection<MetaDataMember> keys,
DataContext dataContext)
{
var sourceKeys = keys;
if (sourceKeys.Count == 0)
sourceKeys = description.RowType.IdentityMembers;
var members = (from key in sourceKeys select key.Member).ToList();
return members;
}
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 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));
}
}
public string DeleteTableSQL(
MetaTable table)
{
return string.Format("DROP TABLE IF EXISTS {0};", table.TableName);
}
/// <summary>
/// Enumerates Keys for a given table.
/// Keys can be provided as input. If none provided, PKs are taken from table
/// </summary>
/// <param name="description"></param>
/// <param name="keys">Keys to be used, leave empty to use PKs instead</param>
/// <param name="dataContext"></param>
/// <param name="hasNullableKeys">returned as true if some keys can be null (we then have an outer join)</param>
/// <returns></returns>
protected virtual IList<MemberInfo> GetAssociationKeys(MetaTable description, ReadOnlyCollection<MetaDataMember> keys,
DataContext dataContext, out bool hasNullableKeys)
{
var sourceKeys = keys;
if (sourceKeys.Count == 0)
sourceKeys = description.RowType.IdentityMembers;
hasNullableKeys = false;
var members = new List<MemberInfo>();
foreach (var sourceKey in sourceKeys)
{
members.Add(sourceKey.Member);
if (sourceKey.CanBeNull)
hasNullableKeys = true;
}
return members;
}
public virtual IList<MemberInfo> GetPrimaryKeys(MetaTable tableDescription)
{
return (from column in tableDescription.RowType.IdentityMembers select column.Member).ToList();
}
internal SqlTable Table(MetaTable table, MetaType rowType, Expression sourceExpression) {
return new SqlTable(table, rowType, this.typeProvider.GetApplicationType((int)ConverterSpecialTypes.Row), sourceExpression);
}
internal void SetMetaTable(MetaTable metaTable)
{
table = metaTable;
}
/// <summary>
/// Lists table mapped columns
/// </summary>
/// <param name="tableDescription"></param>
/// <returns></returns>
public IList<MemberInfo> GetColumns(MetaTable tableDescription)
{
return (from column in tableDescription.RowType.PersistentDataMembers select column.Member).ToList();
}
