public void BlogPlainFields()
{
Kernel.AddComponent("plainfields", typeof(IPlainFieldInferenceService), typeof(PlainFieldInferenceService));
Kernel.AddComponent("nameService", typeof(INamingService), typeof(NamingService));
Kernel.AddComponent("typeinf", typeof(ITypeInferenceService), typeof(TypeInferenceService));
IPlainFieldInferenceService plainService = Kernel[typeof(IPlainFieldInferenceService)] as IPlainFieldInferenceService;
TableDefinition table = new TableDefinition("blogs", new DatabaseDefinition("alias"));
table.AddColumn(new ColumnDefinition("id", true, false, true, false, OleDbType.Integer));
table.AddColumn(new ColumnDefinition("name", false, false, false, false, OleDbType.VarChar));
table.AddColumn(new ColumnDefinition("authorid", false, true, false, false, OleDbType.VarChar));
ActiveRecordPropertyDescriptor[] descs = plainService.InferProperties(table);
Assert.IsNotNull(descs);
Assert.AreEqual(2, descs.Length);
ActiveRecordPropertyDescriptor desc1 = descs[0];
ActiveRecordPropertyDescriptor desc2 = descs[1];
Assert.AreEqual("id", desc1.ColumnName);
Assert.AreEqual("Integer", desc1.ColumnTypeName);
Assert.AreEqual("Id", desc1.PropertyName);
Assert.AreEqual(typeof(int), desc1.PropertyType);
Assert.AreEqual("name", desc2.ColumnName);
Assert.AreEqual("VarChar", desc2.ColumnTypeName);
Assert.AreEqual("Name", desc2.PropertyName);
Assert.AreEqual(typeof(String), desc2.PropertyType);
}
public static void CreateDatabase()
{
var tbd = new TableDefinition();
tbd.AddColumn("RequestId", "guid").AsPrimaryKey().DefaultValue(DefaultValues.Guid.New);
tbd.AddColumn("Reference", "string").CanBeNull();
tbd.AddColumn("JobName", "string").CanNotBeNull();
tbd.AddColumn("Data", "object").CanBeNull();
tbd.AddColumn("Response", "object").CanBeNull();
tbd.AddColumn("Status", "string").CanNotBeNull();
tbd.AddColumn("CreatedAt", "datetime").CanNotBeNull();
tbd.AddColumn("UpdatedAt", "datetime").CanBeNull();
var conn = ConnectionString.Build()
.WithCredential("postgres", "postgres")
.WithDatabase("TestScripting")
.WithSchema("Test");
var tbl = new Schema(conn).CreateIfNotExists().CreateTable("Table", tbd, false);
var dict = new Dictionary <string, object>();
dict.Add("RequestId", null);
dict.Add("Reference", null);
dict.Add("JobName", "test");
dict.Add("Data", null);
dict.Add("Response", null);
dict.Add("Status", "New");
dict.Add("CreatedAt", DateTime.Now);
dict.Add("UpdatedAt", null);
var id = tbl.Insert(dict);
}
public void GetPrimaryKeyColumns()
{
TableDefinition table = new TableDefinition();
table.AddColumn(new ColumnDefinition("Foo"));
table.AddColumn(new ColumnDefinition("ID"));
table.AddColumn(new ColumnDefinition("Bar"));
Assert.IsNull(table.GetPrimaryKeyColumns());
table.Columns[1].PrimaryKey = true;
Assert.AreSame(table.Columns[1], table.GetPrimaryKeyColumns()[0]);
}
public void GetColumn()
{
TableDefinition table = new TableDefinition("Qux");
table.AddColumn(new ColumnDefinition("Foo"));
table.AddColumn(new ColumnDefinition("bAr"));
Assert.AreSame(table.Columns[0], table.GetColumn("Foo"));
Assert.AreSame(table.Columns[0], table.GetColumn("foo"));
Assert.AreSame(table.Columns[1], table.GetColumn("Bar"));
Assert.AreSame(table.Columns[1], table.GetColumn("BAR"));
Assert.IsNull(table.GetColumn("ID"));
}
public void CreateOrUpdateStore_LateAddEntity_ShouldUpdateDb()
{
DataStore.AddType<LateAddItem>();
DataStore.CreateOrUpdateStore();
var expected = new TableDefinition("LateAddItem");
expected.AddColumn("Id", 0, false, "INTEGER");
expected.AddColumn("Name", 1, true, "TEXT");
var schemaChecker = new SqliteSchemaChecker(DataStore);
var current = schemaChecker.GetTableFormat("LateAddItem");
Assert.AreEqual(expected, current);
}
private void BuildBlogPostsStructure(out TableDefinition blogTable, out TableDefinition postTable)
{
DatabaseDefinition dbdef = new DatabaseDefinition("alias");
blogTable = new TableDefinition("blogs", dbdef);
blogTable.AddColumn(new ColumnDefinition("id", true, false, true, false, OleDbType.Integer));
blogTable.AddColumn(new ColumnDefinition("name", false, false, false, false, OleDbType.VarChar));
postTable = new TableDefinition("posts", dbdef);
postTable.AddColumn(new ColumnDefinition("id", true, false, true, false, OleDbType.Integer));
postTable.AddColumn(new ColumnDefinition("name", false, false, false, false, OleDbType.VarChar));
postTable.AddColumn(new ColumnDefinition("blog_id", false, true, false, false, OleDbType.VarChar, blogTable));
blogTable.AddManyRelation(postTable);
}
public void RemoveColumn()
{
TableDefinition table = new TableDefinition("Qux");
table.AddColumn(new ColumnDefinition("Foo"));
table.AddColumn(new ColumnDefinition("bAr"));
table.RemoveColumn("foo");
Assert.AreEqual(1, table.Columns.Count);
table.RemoveColumn("baz");
Assert.AreEqual(1, table.Columns.Count);
table.RemoveColumn("BAR");
Assert.AreEqual(0, table.Columns.Count);
}
public void SelfReference()
{
InitKernel();
IRelationshipInferenceService relService = ObtainService();
DatabaseDefinition dbdef = new DatabaseDefinition("alias");
TableDefinition categoryTable = new TableDefinition("categories", dbdef);
categoryTable.AddColumn(new ColumnDefinition("id", true, false, true, false, OleDbType.Integer));
categoryTable.AddColumn(new ColumnDefinition("name", false, false, false, false, OleDbType.VarChar));
categoryTable.AddColumn(new ColumnDefinition("parent_id", false, true, false, false, OleDbType.Integer, categoryTable));
categoryTable.AddManyRelation(categoryTable);
BuildContext context = new BuildContext();
ActiveRecordDescriptor arDesc = new ActiveRecordDescriptor();
ActiveRecordPropertyDescriptor[] descs = relService.InferRelations(arDesc, categoryTable, context);
Assert.IsFalse(context.HasPendents);
Assert.IsNotNull(descs);
Assert.AreEqual(2, descs.Length);
ActiveRecordHasManyDescriptor desc1 = descs[0] as ActiveRecordHasManyDescriptor;
Assert.IsNotNull(desc1);
Assert.IsNotNull(desc1.TargetType);
Assert.IsNotNull(desc1.PropertyType);
Assert.AreEqual("Categories", desc1.PropertyName);
Assert.AreEqual("parent_id", desc1.ColumnName);
Assert.AreEqual(typeof(IList), desc1.PropertyType);
ActiveRecordBelongsToDescriptor desc2 = descs[1] as ActiveRecordBelongsToDescriptor;
Assert.IsNotNull(desc2);
Assert.IsNotNull(desc2.TargetType);
Assert.IsNull(desc2.PropertyType);
Assert.AreEqual("Category", desc2.PropertyName);
Assert.AreEqual("parent_id", desc2.ColumnName);
}
public void AddColumn()
{
ITableDefinition table = new TableDefinition("Foo");
IColumnDefinition column = new ColumnDefinition("ID");
table.AddColumn(column);
Assert.AreSame(column, table.Columns[0]);
Assert.AreEqual(table.Name, column.Table);
}
public void TestFixtureSetUp()
{
schema = new Schema();
TableDefinition barTable = new TableDefinition("Bar");
barTable.AddColumn(new ColumnDefinition("ID", "Bar", DbType.Int32, false, null, null, null, true, false));
barTable.AddColumn(new ColumnDefinition("Name", DbType.String, false, 1000, null, null));
barTable.AddColumn(new ColumnDefinition("ParentID", DbType.Int32, true, null, null, null));
uqNameIndex = new IndexDefinition("UQ_Name", new IndexColumnDefinition("Name", SortDirection.Ascending));
uqNameIndex.Unique = true;
uqNameIndex.Clustered = true;
barTable.AddIndex(uqNameIndex);
ReferenceDefinition fkBarReference = new ReferenceDefinition("FK_Bar", "Bar", "Bar");
fkBarReference.PkColumns.Add("ID");
fkBarReference.FkColumns.Add("ParentID");
schema.AddTable(barTable);
}
public void HasÁndBelongsToMany()
{
InitKernel();
IRelationshipBuilder relService = ObtainService();
DatabaseDefinition dbdef = new DatabaseDefinition("alias");
TableDefinition compTable = new TableDefinition("companies", dbdef);
compTable.AddColumn(new ColumnDefinition("id", true, false, true, false, OleDbType.Integer));
compTable.AddColumn(new ColumnDefinition("name", false, false, false, false, OleDbType.VarChar));
TableDefinition peopleTable = new TableDefinition("people", dbdef);
peopleTable.AddColumn(new ColumnDefinition("id", true, false, true, false, OleDbType.Integer));
peopleTable.AddColumn(new ColumnDefinition("name", false, false, false, false, OleDbType.VarChar));
TableDefinition assocTable = new TableDefinition("companiespeople", dbdef);
assocTable.AddColumn(new ColumnDefinition("comp_id", true, true, true, false, OleDbType.Integer));
assocTable.AddColumn(new ColumnDefinition("person_id", true, true, false, false, OleDbType.Integer));
ActiveRecordDescriptor desc = new ActiveRecordDescriptor("Company");
ActiveRecordDescriptor targetDesc = new ActiveRecordDescriptor("Person");
RelationshipInfo info = new RelationshipInfo(AssociationEnum.HasAndBelongsToMany, desc, targetDesc);
info.AssociationTable = assocTable;
info.ParentCol = new ColumnDefinition("comp_id", false, true, false, true, OleDbType.Integer);
info.ChildCol = new ColumnDefinition("person_id", false, true, false, true, OleDbType.Integer);
ActiveRecordPropertyRelationDescriptor propDesc = relService.Build(info);
Assert.IsNotNull(propDesc as ActiveRecordHasAndBelongsToManyDescriptor);
Assert.IsNotNull(propDesc);
Assert.AreEqual("People", propDesc.PropertyName);
Assert.AreEqual(targetDesc, propDesc.TargetType);
Assert.AreEqual("person_id", propDesc.ColumnName);
Assert.AreEqual("comp_id", (propDesc as ActiveRecordHasAndBelongsToManyDescriptor).ColumnKey);
}
public void Execute(IDbPlatform platform, IRefactorNode refactorNode, Environment environment)
{
string auditTableName = AstNodePropertyUtil.AsString(refactorNode.Properties["audit-table"].Value);
string tableName = AstNodePropertyUtil.AsString(refactorNode.Properties["table"].Value);
//
// We only need columns here
ITableDefinition tableDefinition = environment.Schema.GetTable(tableName);
ITableDefinition auditTable = new TableDefinition(auditTableName);
foreach(ColumnDefinition column in tableDefinition.Columns)
{
//
// Keep name and type only.
IColumnDefinition auditColumn = new ColumnDefinition(column.Name);
//
// Special handling for rowversion
if(column.Type == DbType.Time)
{
auditColumn.Length = 8;
auditColumn.Type = DbType.Binary;
} // if
else
{
auditColumn.Length = column.Length;
auditColumn.Type = column.Type;
} // else
auditColumn.Nullable = true;
auditTable.AddColumn(auditColumn);
} // foreach
environment.Schema.AddTable(auditTable);
//
// Now build an AST
IAddTableNode addAuditTableNode = new AddTableNode(refactorNode.Parent, auditTableName);
foreach(IColumnDefinition auditColumn in auditTable.Columns)
{
IAddColumnNode addAuditColumnNode = new AddColumnNode(addAuditTableNode, auditColumn.Name);
addAuditColumnNode.Type = auditColumn.Type;
addAuditColumnNode.Length = auditColumn.Length;
addAuditColumnNode.Nullable = auditColumn.Nullable;
addAuditTableNode.ChildNodes.Add(addAuditColumnNode);
} // foreach
addAuditTableNode.Parent.ChildNodes.Add(addAuditTableNode);
}
public TableDefinition BuildTable <T>() where T : class
{
var table = new TableDefinition(TypeInfoCache <T> .Name);
for (var i = 0; i < TypeInfoCache <T> .ReadWriteProperties.Length; ++i)
{
var property = TypeInfoCache <T> .ReadWriteProperties[i];
var dbType = property.PropertyType.ToDbType();
var column = table.AddColumn(property.Name, dbType);
var pkAttribute = property.GetCustomAttribute <PrimaryKeyAttribute>();
column.IsPrimaryKey = pkAttribute != null;
if (column.IsPrimaryKey)
{
column.PrimaryKey.Direction = pkAttribute.Direction;
column.PrimaryKey.IsAutoIncrement = pkAttribute.AutoIncrement;
}
else
{
column.IsNullable = property.GetCustomAttribute <RequiredAttribute>() == null;
column.IsUnique = property.GetCustomAttribute <UniqueAttribute>() != null;
var defaultAttribute = property.GetCustomAttribute <DefaultValueAttribute>();
if (defaultAttribute != null)
{
column.Default = defaultAttribute.Value;
}
var commentAttribute = property.GetCustomAttribute <CommentAttribute>();
if (commentAttribute != null)
{
column.AddComment(commentAttribute.Comment);
}
if (dbType.IsSizableType())
{
var maxSizeAttribute = property.GetCustomAttribute <MaxSizeAttribute>();
if (maxSizeAttribute != null)
{
column.MaxLength = maxSizeAttribute.Size;
}
}
}
var fkAttribute = property.GetCustomAttribute <ForeignKeyAttribute>();
column.HasForeignKey = fkAttribute != null;
if (column.HasForeignKey)
{
column.ForeignKey.Schema = fkAttribute.Schema;
column.ForeignKey.Table = fkAttribute.ReferenceTable;
column.ForeignKey.Column = fkAttribute.ReferenceColumn;
}
}
return(table);
}
public void GetCompositePrimaryKeyColumn()
{
TableDefinition table = new TableDefinition();
table.AddColumn(new ColumnDefinition("Foo"));
table.AddColumn(new ColumnDefinition("ID"));
table.AddColumn(new ColumnDefinition("Bar"));
Assert.IsNull(table.GetPrimaryKeyColumns());
table.Columns[1].PrimaryKey = true;
table.Columns[2].PrimaryKey = true;
CollectionAssert.AreEqual(new[] { table.Columns[1], table.Columns[2] }, table.GetPrimaryKeyColumns());
}
/// <summary>
/// Visits the given <paramref name="addTableNode"/>.
/// </summary>
/// <param name="addTableNode"></param>
public override void Visit(IAddTableNode addTableNode)
{
TableDefinition table = new TableDefinition(addTableNode.Name);
Environment.Schema.AddTable(table);
foreach(IAddColumnNode addColumnNode in Filter<IAddColumnNode>(addTableNode.ChildNodes))
{
table.AddColumn(BindAddColumn(addColumnNode));
addColumnNode.Table = table.Name;
addColumnNode.Accept(this);
} // foreach
//
// Now process all but IAddColumnNode
foreach(IAstNode astNode in FilterNot<IAddColumnNode>(addTableNode.ChildNodes))
{
astNode.Accept(this);
} // foreach
}
public PgSqlCommand GetSqlCommand(TableDefinition tableDefinition)
{
var sqlCommand = new PgSqlCommand();
TableDefinition keyDefinition = new TableDefinition();
sqlCommand.AppendCommand($"INSERT INTO {String.Join(", ", _intoDestination.GetSqlCommand(tableDefinition).Command)}");
if (_intoColumns != null)
{
var intoColumnsComm = _intoColumns.GetSqlCommand(tableDefinition);
sqlCommand.AppendCommandLine($"{Environment.NewLine}\t({intoColumnsComm.Command})");
_intoColumns._columns.ForEach(c =>
{
var col = tableDefinition?.GetColumnBuilderByDbName(c._name);
if (col == null)
{
keyDefinition.AddColumn(new ColumnBuilder().SetDbName(c._name));
}
else
{
keyDefinition.AddColumn(col);
}
});
}
if (_valueClauses.Any())
{
sqlCommand.AppendCommandLine($"VALUES");
foreach (var valuesClause in _valueClauses)
{
if (valuesClause is NamedValues namedValues)
{
var valuesComm = namedValues.GetSqlCommand(keyDefinition);
sqlCommand.AppendCommandLine($"\t({valuesComm.Command}),", valuesComm.Parameters);
}
else if (valuesClause is PositionedValues)
{
var valuesComm = valuesClause.GetSqlCommand(keyDefinition);
sqlCommand.AppendCommandLine($"\t({valuesComm.Command}),", valuesComm.Parameters);
}
}
sqlCommand.Command = sqlCommand.Command.TrimEnd($",{Environment.NewLine}".ToCharArray()) + Environment.NewLine;
}
if (_onConflict != null)
{
var onConflict = _onConflict.GetSqlCommand(tableDefinition);
sqlCommand.AppendCommandLine(onConflict.Command, onConflict.Parameters);
}
if (_returningClause != null)
{
sqlCommand.AppendCommand($"RETURNING {_returningClause.GetSqlCommand(tableDefinition).Command}");
}
return(sqlCommand);
}
