public static nHydrate.DataImport.SQLObject ToDatabaseObject(this Entity item)
{
var retval = new DataImport.Entity();
retval.Name = item.Name;
retval.Schema = item.Schema;
retval.AllowCreateAudit = item.AllowCreateAudit;
retval.AllowModifyAudit = item.AllowModifyAudit;
retval.AllowTimestamp = item.AllowTimestamp;
retval.IsTenant = item.IsTenant;
//Fields
foreach (var f in item.Fields)
{
retval.FieldList.Add(new nHydrate.DataImport.Field()
{
DataType = (System.Data.SqlDbType)Enum.Parse(typeof(System.Data.SqlDbType), f.DataType.ToString(), true),
DefaultValue = f.Default,
Identity = (f.Identity == IdentityTypeConstants.Database),
IsIndexed = f.IsIndexed,
IsUnique = f.IsUnique,
Length = f.Length,
Name = f.Name,
Nullable = f.Nullable,
PrimaryKey = f.IsPrimaryKey,
Scale = f.Scale,
SortOrder = f.SortOrder,
});
}
return(retval);
}
public static void PopulateFields(nHydrate.Dsl.nHydrateModel model, DataImport.Entity importItem, Entity targetItem)
{
foreach (var field in importItem.FieldList)
{
var newField = targetItem.Fields.FirstOrDefault(x => x.Name.ToLower() == field.Name.ToLower());
if (newField == null)
{
newField = new nHydrate.Dsl.Field(model.Partition);
}
if (!targetItem.Fields.Contains(newField))
{
targetItem.Fields.Add(newField);
}
newField.SortOrder = field.SortOrder;
newField.Name = field.Name;
newField.DataType = (DataTypeConstants)Enum.Parse(typeof(DataTypeConstants), field.DataType.ToString());
newField.Length = field.Length;
newField.Nullable = field.Nullable;
newField.IsCalculated = field.IsComputed;
newField.Default = field.DefaultValue;
newField.IsUnique = field.IsUnique;
newField.Formula = field.Formula;
newField.Identity = (field.Identity ? IdentityTypeConstants.Database : IdentityTypeConstants.None);
newField.IsPrimaryKey = field.PrimaryKey;
newField.Scale = field.Scale;
newField.ImportedDefaultName = field.ImportedDefaultName;
//DO NOT IMPORT METADATA
//Correct for invalid identifiers
if (!nHydrate.Dsl.ValidationHelper.ValidCodeIdentifier(newField.Name))
{
newField.CodeFacade = nHydrate.Dsl.ValidationHelper.MakeCodeIdentifier(newField.Name, string.Empty);
}
}
var removedFields = targetItem.Fields.Remove(x => !importItem.FieldList.Select(y => y.Name.ToLower()).Contains(x.Name.ToLower()));
}
private int LoadPostgres(string connectionString, List <SpecialField> auditFields)
{
var tlist = DslPackage.Objects.Postgres.ImportDomain.GetTables(connectionString);
var db = new DataImport.Database();
this.NewDatabase = db;
var allIndexes = DslPackage.Objects.Postgres.ImportDomain.GetIndexes(connectionString);
var allRelations = DslPackage.Objects.Postgres.ImportDomain.GetRelations(connectionString);
foreach (var entity in tlist)
{
//Create table
var newEntity = new DataImport.Entity
{
AllowCreateAudit = entity.Columns.Any(x => x.ColumnName == _model.CreatedByColumnName),
AllowModifyAudit = entity.Columns.Any(x => x.ColumnName == _model.ModifiedByColumnName),
AllowTimestamp = entity.Columns.Any(x => x.ColumnName == _model.ConcurrencyCheckColumnName),
IsTenant = entity.Columns.Any(x => x.ColumnName == _model.TenantColumnName),
Name = entity.TableName,
Schema = entity.SchemaName,
};
db.EntityList.Add(newEntity);
//Load fields
foreach (var column in entity.Columns)
{
var isIndexed = allIndexes.Any(x => x.TableName == newEntity.Name && newEntity.FieldList.Any(z => z.Name == column.ColumnName) && newEntity.FieldList.Count == 1);
newEntity.FieldList.Add(new DataImport.Field
{
DataType = SqlDbType.BigInt,
Identity = column.IsIdentity,
IsIndexed = isIndexed,
Name = column.ColumnName,
Nullable = column.AllowNull,
PrimaryKey = false,
});
}
//TODO: Add multi-column indexes
#region Load relations
foreach (var rowRelationship in allRelations)
{
var constraintName = rowRelationship.IndexName;
var parentTableName = rowRelationship.TableName;
var childTableName = rowRelationship.FKTableName;
var parentTable = db.EntityList.FirstOrDefault(x => x.Name == parentTableName);
var childTable = db.EntityList.FirstOrDefault(x => x.Name == childTableName);
if (parentTable != null && childTable != null)
{
Relationship newRelation = null;
var isAdd = false;
if (db.RelationshipList.Count(x => x.ConstraintName == constraintName) == 0)
{
newRelation = new Relationship();
//if (rowRelationship["object_id"] != System.DBNull.Value)
// newRelation.ImportData = rowRelationship["object_id"].ToString();
newRelation.SourceEntity = parentTable;
newRelation.TargetEntity = childTable;
newRelation.ConstraintName = constraintName;
var search = ("_" + childTable.Name + "_" + parentTable.Name).ToLower();
var roleName = constraintName.ToLower().Replace(search, string.Empty);
if (roleName.Length >= 3)
{
roleName = roleName.Remove(0, 3);
}
var v = roleName.ToLower();
if (v != "fk")
{
newRelation.RoleName = v;
}
isAdd = true;
}
else
{
newRelation = db.RelationshipList.First(x => x.ConstraintName == constraintName);
}
//add the column relationship to the relation
var columnRelationship = new RelationshipDetail();
var parentColumnName = rowRelationship.ColumnName;
var childColumnName = rowRelationship.FKColumnName;
if (parentTable.FieldList.Count(x => x.Name == parentColumnName) == 1 && (childTable.FieldList.Count(x => x.Name == childColumnName) == 1))
{
columnRelationship.ParentField = parentTable.FieldList.First(x => x.Name == parentColumnName);
columnRelationship.ChildField = childTable.FieldList.First(x => x.Name == childColumnName);
newRelation.RelationshipColumnList.Add(columnRelationship);
//ONLY ADD THIS RELATION IF ALL WENT WELL
if (isAdd)
{
parentTable.RelationshipList.Add(newRelation);
}
}
}
}
#endregion
this.NewDatabase.CleanUp();
this.NewDatabase.SetupIdMap(this.CurrentDatabase);
//Load the tree
this.Populate();
}
return(0);
}
