public override CreateTableStatementBuilder GetCreateTableStatementBuilder()
{
CreateTableStatementBuilder cts = base.GetCreateTableStatementBuilder();
cts.Columns.Add(new ColumnInfo(_columnName, typeof(bool), null));
return(cts);
}
public void CreateCrossTable(Type t2)
{
var ctx2 = ModelContext.GetInstance(t2).Info;
if (!(Info.CrossTables.ContainsKey(t2) && ctx2.CrossTables.ContainsKey(Info.HandleType)))
{
throw new DataException("They are not many to many relationship classes!");
}
if (Info.KeyMembers.Length <= 0 || ctx2.KeyMembers.Length <= 0)
{
throw new DataException("The relation table must have key column!");
}
var mt = Info.CrossTables[t2];
var cs = mt.GetSortedColumns();
var cts = new CreateTableStatementBuilder(mt.Name);
cts.Columns.Add(new ColumnInfo(cs[0].Column, Info.KeyMembers[0].MemberType, cs[0].Table));
cts.Columns.Add(new ColumnInfo(cs[1].Column, Info.KeyMembers[0].MemberType, cs[1].Table));
// add index
cts.Indexes.Add(new DbIndex(null, false, (ASC)cs[0].Column));
cts.Indexes.Add(new DbIndex(null, false, (ASC)cs[1].Column));
// execute
var sql = cts.ToSqlStatement(Provider.Dialect, null, Info.AllowSqlLog);
Provider.ExecuteNonQuery(sql);
Fixer.SetAsProcessed();
}
private IEnumerable <CreateTableStatement> GetCreateTableStatements()
{
foreach (var entityMapping in _model.EntityMappings)
{
var tableStatementBuilder = new CreateTableStatementBuilder(_model, entityMapping);
yield return(tableStatementBuilder.BuildStatement());
}
}
public static void CreateTable(this IQuery query, Action <ICreateTableStatementBuilder> createTable)
{
var builder = new CreateTableStatementBuilder();
createTable(builder);
var statements = builder.Build();
foreach (var statement in statements)
{
Result(query.ExecuteStatement(statement));
}
}
public virtual CreateTableStatementBuilder GetCreateTableStatementBuilder()
{
var builder = new CreateTableStatementBuilder(this.Context.Info.From.MainTableName);
foreach (MemberHandler member in this.Context.Info.Members)
{
if ((!member.Is.HasMany && !member.Is.HasOne) && !member.Is.HasAndBelongsToMany)
{
var item = new ColumnInfo(member);
builder.Columns.Add(item);
}
}
foreach (string key in this.Context.Info.Indexes.Keys)
{
bool unique = this.Context.Info.UniqueIndexes.ContainsKey(key);
builder.Indexes.Add(new DbIndex(key, unique, this.Context.Info.Indexes[key].ToArray()));
}
return(builder);
}
public IRelationalCommand Build <TEntity>(SqlStatementKind statementKind, IEntityModel model, TEntity entity, IEntityMapping entityMapping)
{
switch (statementKind)
{
case SqlStatementKind.CreateTable:
ISqlStatementBuilder <CreateTableStatement> statementBuilder = new CreateTableStatementBuilder(model, entityMapping);
ISqlStatement statement = statementBuilder.BuildStatement();
return(new RelationalCommand(statement.GetText(), null));
case SqlStatementKind.Insert:
ISqlStatementBuilder <InsertStatement> insertStatementBuilder = new InsertStatementBuilder(entity, entityMapping);
InsertStatement insertStatement = insertStatementBuilder.BuildStatement();
return(new RelationalCommand(insertStatement.GetText(), insertStatement.Parameters));
case SqlStatementKind.Update:
ISqlStatementBuilder <UpdateStatement> updateStatementBuilder = new UpdateStatementBuilder(entity, entityMapping);
UpdateStatement updateStatement = updateStatementBuilder.BuildStatement();
return(new RelationalCommand(updateStatement.GetText(), updateStatement.Parameters));
case SqlStatementKind.Delete:
ISqlStatementBuilder <DeleteStatement> deleteStatementBuilder = new DeleteStatementBuilder(entity, entityMapping);
DeleteStatement deleteStatement = deleteStatementBuilder.BuildStatement();
return(new RelationalCommand(deleteStatement.GetText(), deleteStatement.Parameters));
default:
throw new NotImplementedException();
}
}
