public int SaveDatabase(DatabaseDTO message)
{
using (var projectContext = new DataAccess.MyProjectEntities())
{
var dbDatabase = projectContext.DatabaseInformation.FirstOrDefault(x => x.ID == message.ID);
if (dbDatabase == null)
{
dbDatabase = new DatabaseInformation();
dbDatabase.SecurityObject = new SecurityObject();
dbDatabase.SecurityObject.Type = (int)DatabaseObjectCategory.Database;
}
dbDatabase.DBServerID = message.DBServerID;
dbDatabase.Name = message.Name;
dbDatabase.Title = message.Title;
dbDatabase.DBHasDate = message.DBHasData;
dbDatabase.ConnectionString = message.ConnectionString;
dbDatabase.DBType = message.DBType.ToString();
if (dbDatabase.ID == 0)
{
projectContext.DatabaseInformation.Add(dbDatabase);
}
projectContext.SaveChanges();
return(dbDatabase.ID);
}
}
private async void SetImportedInfo()
{
try
{
if (FormIsBusy != null)
{
FormIsBusy(this, null);
}
DatabaseDTO database = null;
if (Database == null)
{
if (lokDatabase.SelectedItem != null)
{
database = (DatabaseDTO)lokDatabase.SelectedItem;
}
}
else
{
database = Database;
}
if (database != null)
{
var dbObject = await GetDatabaseObjects(database);
if (dbObject.ChildObjects.Any())
{
AddDBObjectsToTree(new List <ObjectDTO>()
{
dbObject
}, treeDBObjects.Items);
}
else
{
treeDBObjects.Items.Clear();
}
}
}
catch (Exception ex)
{
MessageBox.Show("خطا در پردازش اطلاعات" + Environment.NewLine + ex.Message);
}
finally
{
if (treeDBObjects.Items.Count > 0 && (treeDBObjects.Items[0] as RadTreeViewItem).Items.Count > 0)
{
if (FormIsFree != null)
{
FormIsFree(this, null);
}
lblMessage.Visibility = Visibility.Collapsed;
}
else
{
treeDBObjects.Items.Clear();
lblMessage.Text = "موجودیتی به منظور افزودن به درخت منو موجود نمی باشد";
lblMessage.Visibility = Visibility.Visible;
}
}
}
public frmTableProperty_Relation(DatabaseDTO database)
{
InitializeComponent();
Database = database;
dtgRelationship.RowLoaded += DtgNewTables_RowLoaded;
//if (!Database.DBHasData)
// colSearchInitially.IsVisible = false;
}
public frmTableUIComposition(DatabaseDTO database)
{
InitializeComponent();
Database = database;
dtgNewTables.RowLoaded += DtgNewTables_RowLoaded;
//dtgNewTables.CellEditEnded += DtgNewTables_CellEditEnded;
//if (!Database.DBHasData)
// colIsDataReference.IsVisible = false;
}
// LinkedList<ImportWizardStep> WizardSteps = new LinkedList<ImportWizardStep>();
public DatabaseImportWizard(int databaseID)
{
InitializeComponent();
ucSteps.StepClicked += UcSteps_StepClicked;
Database = bizDatabase.GetDatabase(databaseID);
SetWizardSteps();
}
public Task <ObjectDTO> GetDatabaseObjects(DatabaseDTO database)
{
return(Task.Run(() =>
{
ObjectDTO dbObject = new ObjectDTO();
dbObject.ObjectCategory = DatabaseObjectCategory.Database;
dbObject.ObjectIdentity = database.ID;
dbObject.Title = database.Name;
AddChildObjects(dbObject);
return dbObject;
}));
}
public frmEntityIsDataReference(DatabaseDTO database)
{
InitializeComponent();
Database = database;
dtgTables.RowLoaded += DtgNewTables_RowLoaded;
//dtgNewTablesNonSuspicious.RowLoaded += DtgNewTables_RowLoaded;
bizTableDrivedEntity.ItemImportingStarted += BizTableDrivedEntity_ItemImportingStarted;
//dtgNewTables.CellEditEnded += DtgNewTables_CellEditEnded;
//if (!Database.DBHasData)
// colIsDataReference.IsVisible = false;
this.Loaded += FrmTableProperty_BaseTable_Loaded;
}
public List <RelationDTO> ImportRelations(DatabaseDTO database, Dictionary <string, Guid> entityIds, Dictionary <string, Guid> attributeIds, ref int lastTable)
{
var metadataProvider = new MetadataProvider();
try
{
List <RelationDTO> relations = metadataProvider.LoadRelations(database, entityIds, attributeIds, ref lastTable);
return(relations);
}
catch (Exception ex)
{
throw new InvalidOperationException("Metadata provider error", ex);
}
}
public frmDatabaseSetting(int databaseID)
{
InitializeComponent();
Message = bizDatabase.GetDatabase(databaseID);
txtDBName.Text = Message.Name;
txtDBTitle.Text = Message.Title;
if (Message.DatabaseSetting == null)
{
Message.DatabaseSetting = new DatabaseSettingDTO();
}
chkFlowDirectionLTR.IsChecked = Message.DatabaseSetting.FlowDirectionLTR;
chkShowMiladiDateInUI.IsChecked = Message.DatabaseSetting.ShowMiladiDateInUI;
chkStringDateColumnIsMiladi.IsChecked = Message.DatabaseSetting.StringDateColumnIsMiladi;
}
public frmImportTables(DatabaseDTO database)
{
InitializeComponent();
Database = database;
ImportHelper = ModelGenerator.GetDatabaseImportHelper(Database);
ImportHelper.ItemImportingStarted += ImportHelper_ItemImportingStarted;
bizTableDrivedEntity.ItemImportingStarted += ImportHelper_ItemImportingStarted;
dtgNewTables.RowLoaded += DtgNewTables_RowLoaded;
dtgEditTables.RowLoaded += Dtg_RowLoaded;
dtgExistingTables.RowLoaded += Dtg_RowLoaded;
dtgDeletedTables.RowLoaded += Dtg_RowLoaded;
dtgExceptionTables.RowLoaded += Dtg_RowLoaded;
this.Loaded += FrmImportTables_Loaded;
// colDataCountLimit.Header = "تعداد داده کمتر از" + " " + DataCountLimit + " " + "مورد است";
}
public frmImportViews(DatabaseDTO database)
{
InitializeComponent();
Database = database;
ImportHelper = ModelGenerator.GetDatabaseImportHelper(Database);
ImportHelper.ItemImportingStarted += ImportHelper_ItemImportingStarted;
bizTableDrivedEntity.ItemImportingStarted += ImportHelper_ItemImportingStarted;
dtgNewViews.RowLoaded += DtgNewViews_RowLoaded;
dtgEditViews.RowLoaded += DtgNewViews_RowLoaded;
dtgExistingViews.RowLoaded += DtgNewViews_RowLoaded;
dtgDeletedViews.RowLoaded += DtgNewViews_RowLoaded;
dtgExceptionViews.RowLoaded += DtgNewViews_RowLoaded;
this.Loaded += FrmImportViews_Loaded;
}
public List <EntityDTO> ImportObjects(DatabaseDTO database, ref int lastTable)
{
var metadataProvider = new MetadataProvider();
try
{
List <EntityDTO> entities = metadataProvider.LoadEntities(database, ref lastTable);
entities.ForEach(e => e.DatabaseID = database.ID);
return(entities);
}
catch (Exception ex)
{
throw new InvalidOperationException("Metadata provider error", ex);
}
}
public frmImportFunctions(DatabaseDTO database)
{
InitializeComponent();
Database = database;
ImportHelper = ModelGenerator.GetDatabaseImportHelper(Database);
ImportHelper.ItemImportingStarted += ImportHelper_ItemImportingStarted;
bizDatabaseFunction.ItemImportingStarted += ImportHelper_ItemImportingStarted;
dtgNewFunctions.RowLoaded += DtgNewFunctions_RowLoaded;
dtgEditFunctions.RowLoaded += DtgNewFunctions_RowLoaded;
dtgExistingFunctions.RowLoaded += DtgNewFunctions_RowLoaded;
dtgDeletedFunctions.RowLoaded += DtgNewFunctions_RowLoaded;
dtgExceptionFunctions.RowLoaded += DtgNewFunctions_RowLoaded;
this.Loaded += FrmImportFunctions_Loaded;
}
private List <DarwinValidation.ValidationError> DoImport(DatabaseDTO database)
{
var entityIds = new Dictionary <string, Guid>();
var attributeIds = new Dictionary <string, Guid>();
var services = new SqlServerServices();
var dataSource = new ObjectDataSource();
var entities = new List <EntityDTO>();
int lastTable = 0;
var errors = new List <DarwinValidation.ValidationError>();
var validator = new Validator();
do
{
entities = services.ImportObjects(database, ref lastTable);
dataSource.SaveObject(database);
foreach (var entity in entities)
{
var validationError = validator.Validate(entity);
if (validationError != null)
{
errors.Add(validationError);
}
dataSource.SaveObject(entity, bypassValidation: true);
entityIds.Add(entity.EntitySchemaPrefixedName, entity.ID);
foreach (var attribute in entity.Attributes)
{
attributeIds.Add(entity.EntitySchemaPrefixedName + "." + attribute.AttributeName, attribute.ID);
}
}
} while (entities.Count > 0);
List <RelationDTO> relations = new List <RelationDTO>();
lastTable = 0;
do
{
relations = services.ImportRelations(database, entityIds, attributeIds, ref lastTable);
foreach (var relation in relations)
{
dataSource.SaveObject(relation);
}
} while (relations.Count > 0);
return(errors);
}
public frmTableFinalSettings(DatabaseDTO database)
{
InitializeComponent();
var frmTableUIComposition = new frmTableUIComposition(database);
grdMain.Children.Add(frmTableUIComposition);
Grid.SetColumn(frmTableUIComposition, 1);
var frmViews = new frmTableDefaultListView(database);
grdMain.Children.Add(frmViews);
frmTableUIComposition.InfoUpdated += FrmViews_InfoUpdated;
frmViews.InfoUpdated += FrmViews_InfoUpdated;
}
public frmDatabase(int databaseID)
{
InitializeComponent();
cmbType.ItemsSource = Enum.GetValues(typeof(enum_DBType)).Cast <object>();
SetServerLookup();
if (databaseID == 0)
{
Message = new DatabaseDTO();
CheckConnectionStringButton();
btnSetting.Visibility = Visibility.Collapsed;
}
else
{
GetDatabase(databaseID);
}
}
public frmImportRelationships(DatabaseDTO database)
{
InitializeComponent();
Database = database;
ImportHelper = ModelGenerator.GetDatabaseImportHelper(Database);
ImportHelper.ItemImportingStarted += ImportHelper_ItemImportingStarted;
bizTableDrivedEntity.ItemImportingStarted += ImportHelper_ItemImportingStarted;
bizRelationship.ItemImportingStarted += ImportHelper_ItemImportingStarted;
dtgNewRelationships.RowLoaded += DtgNewRelationships_RowLoaded;
dtgExistingRelationships.RowLoaded += DtgNewRelationships_RowLoaded;
dtgDeletedRelationships.RowLoaded += DtgNewRelationships_RowLoaded;
dtgExceptionRelationships.RowLoaded += DtgNewRelationships_RowLoaded;
colRelationshipType.ItemsSource = Enum.GetValues(typeof(Enum_OrginalRelationshipType)).Cast <Enum_OrginalRelationshipType>();
dtgNewRelationships.CellEditEnded += DtgNewRelationships_CellEditEnded;
this.Loaded += FrmImportRelationships_Loaded;
}
public frmImportViewsAndFunctions(DatabaseDTO database)
{
InitializeComponent();
var frmFunctions = new frmImportFunctions(database);
grdMain.Children.Add(frmFunctions);
Grid.SetColumn(frmFunctions, 2);
var frmViews = new frmImportViews(database);
grdMain.Children.Add(frmViews);
frmFunctions.InfoUpdated += Frm_InfoUpdated;
frmFunctions.FormIsBusy += Frm_FormIsBusy;
frmFunctions.FormIsFree += Frm_FormIsFree;
frmViews.InfoUpdated += Frm_InfoUpdated;
frmViews.FormIsBusy += Frm_FormIsBusy;
frmViews.FormIsFree += Frm_FormIsFree;
}
private DatabaseDTO ToDatabaseDTO(DataAccess.DatabaseInformation item, bool withSetting = false)
{
DatabaseDTO result = new DatabaseDTO();
result.ID = item.ID;
result.Name = item.Name;
result.Title = item.Title;
result.DBServerID = item.DBServerID;
result.DBServerName = item.DBServer.Name;
result.DBServerTitle = item.DBServer.Title;
result.DBType = (enum_DBType)Enum.Parse(typeof(enum_DBType), item.DBType, true);
result.DBHasData = item.DBHasDate;
result.ConnectionString = item.ConnectionString;
if (withSetting)
{
result.DatabaseSetting = GetDatabaseSetting(item);
}
return(result);
}
//کلا بروزرسانی مدل باید تست بشه مرحله به مرحله در فرمهای موجودیت و روابط دیسیبل اینیبل و دیتااینتری اینیبل بشن و تست شود
public frmEntityIsIndependent(DatabaseDTO database)
{
InitializeComponent();
Database = database;
dtgTables.RowLoaded += DtgNewTables_RowLoaded;
// dtgNewTablesNonSuspicious.RowLoaded += DtgNewTables_RowLoaded;
//dtgNewTables.CellEditEnded += DtgNewTables_CellEditEnded;
if (!Database.DBHasData)
{
//colSearchInitiallySuspicious.IsVisible = false;
//colSearchInitiallyNonSuspicious.IsVisible = false;
}
bizTableDrivedEntity.ItemImportingStarted += BizTableDrivedEntity_ItemImportingStarted;
bizRelationship.ItemImportingStarted += BizTableDrivedEntity_ItemImportingStarted;
dtgTables.CellEditEnded += DtgRelationship_CellEditEnded;
// dtgNewTablesSuspicious.CellLoaded += DtgRelationship_CellLoaded;
// dtgNewTablesNonSuspicious.CellEditEnded += DtgRelationship_CellEditEnded;
this.Loaded += FrmTableProperty_BaseTable_Loaded;
// dtgNewTablesNonSuspicious.CellLoaded += DtgRelationship_CellLoaded;
}
public frmEntitySettings(DatabaseDTO database)
{
InitializeComponent();
Database = database;
bizEntitySettings.ItemImportingStarted += BizEntityUIComposition_ItemImportingStarted;
//bizEntityUIComposition.ItemImportingStarted += BizEntityUIComposition_ItemImportingStarted;
//bizEntityListView.ItemImportingStarted += BizEntityUIComposition_ItemImportingStarted;
//bizEntitySearch.ItemImportingStarted += BizEntityUIComposition_ItemImportingStarted;
// this.Loaded += FrmTableFinalSettings_Loaded;
//var frmTableUIComposition = new frmTableUIComposition(database);
//grdMain.Children.Add(frmTableUIComposition);
//Grid.SetColumn(frmTableUIComposition, 1);
//var frmViews = new frmTableDefaultListView(database);
//grdMain.Children.Add(frmViews);
//frmTableUIComposition.InfoUpdated += FrmViews_InfoUpdated;
//frmViews.InfoUpdated += FrmViews_InfoUpdated;
this.Loaded += FrmEntitySettings_Loaded;
}
private static DatabaseProvider GetDatabaseProvider(DatabaseDTO databaseDTO)
{
return(DatabaseProvider.SQLServer);
}
public frmNavigationTree(DatabaseDTO database, bool ignoreNotIndependentOrAlreadyInNavigationTree) : this()
{
Database = database;
bizDatabaseToObject.IgnoreNotIndependentOrAlreadyInNavigationTree = ignoreNotIndependentOrAlreadyInNavigationTree;
grdDatabase.Visibility = Visibility.Collapsed;
}
private static bool InsertFromQueryToTargetSQLDB(DatabaseDTO database, string targetTableName, string selectQuery)
{
//}
//}
}
public static I_DatabaseImportHelper GetDatabaseImportHelper(DatabaseDTO database)
{
return(new ModelGenerator_sql(database));
}
//private void btnClose_Click(object sender, RoutedEventArgs e)
//{
// MyProjectManager.GetMyProjectManager.CloseDialog(this);
//}
private void btnNew_Click(object sender, RoutedEventArgs e)
{
Message = new DatabaseDTO();
ShowMessage();
}
public void ProcessCreateNewDatabase()
{
var projectID = new ProjectTreeHelper().GetCurrentProjectID();
if (projectID == Guid.Empty)
{
throw new InvalidOperationException("No active project.");
}
// TODO: move to separate class dedicated to the object creation
var newDatabase = new DatabaseDTO()
{
DBName = "<Enter name>", ProjectID = projectID
};
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "Boolean"
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "Int8"
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "Int16"
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "Int32"
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "Int64"
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "Real32"
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "Real64"
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "Char", HasLength = true
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "NChar", HasLength = true
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "VarChar", HasLength = true
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "NVarChar", HasLength = true
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "Guid"
});
newDatabase.DataTypes.Add(new DataTypeDTO()
{
DatabaseID = newDatabase.ID, TypeName = "DateTime"
});
var view = new DatabaseDetailsView();
view.Object = newDatabase;
var popup = new PopupWindow();
popup.Title = "New Database";
popup.Validate = () => { return(new Validator().Validate(newDatabase)); };
popup.ViewPanel.Children.Add(view);
if (popup.ShowDialog() == true)
{
new ObjectDataSource().SaveObject(newDatabase);
ServiceLocator serviceLocator = ServiceLocator.GetActive();
serviceLocator.BasicController.ProcessProjectTreeRefresh();
}
}
internal List <RelationDTO> LoadRelations(DatabaseDTO database, Dictionary <string, Guid> entityIds, Dictionary <string, Guid> attributeIds, ref int lastTable)
{
const int ExpectedColumnsTotal = 8;
const int TablesPerCall = 4; // TODO: move to config
var relations = new List <RelationDTO>();
var commandText = SqlQueries.GetRelationsQuery;
using (var connection = new SqlConnection(database.ConnectionString))
{
var command = connection.CreateCommand();
command.CommandType = CommandType.Text;
command.CommandText = commandText;
var param1 = new SqlParameter();
param1.ParameterName = "@TABLE_NUMBER";
param1.SqlDbType = SqlDbType.Int;
param1.Direction = ParameterDirection.Input;
param1.Value = lastTable;
command.Parameters.Add(param1);
var param2 = new SqlParameter();
param2.ParameterName = "@TABLES_IN_ONE_CALL";
param2.SqlDbType = SqlDbType.Int;
param2.Direction = ParameterDirection.Input;
param2.Value = TablesPerCall;
command.Parameters.Add(param2);
connection.Open();
var reader = command.ExecuteReader();
{
if (reader.HasRows)
{
if (reader.FieldCount != ExpectedColumnsTotal)
{
throw new InvalidOperationException(String.Format("Query returned less or more than {0} columns ({1})", ExpectedColumnsTotal, commandText));
}
string lastPrimaryTableName = string.Empty;
string lastForeignTableName = string.Empty;
string lastRelationName = string.Empty;
RelationDTO relation = null;
int relationsProcessed = 0;
while (reader.Read())
{
lastTable = Convert.ToInt32(reader["TABLE_NUMBER"]);
string primaryTableName = reader["PrimaryTableName"].ToString();
string foreignTableName = reader["ForeignTableName"].ToString();
string relationName = reader["RelationName"].ToString();
// New relation
if (!primaryTableName.Equals(lastPrimaryTableName, StringComparison.InvariantCultureIgnoreCase) ||
!foreignTableName.Equals(lastForeignTableName, StringComparison.InvariantCultureIgnoreCase) ||
!relationName.Equals(lastRelationName, StringComparison.InvariantCultureIgnoreCase))
{
relation = new RelationDTO()
{
RelationName = relationName,
PrimaryEntityID = entityIds[primaryTableName],
ForeignEntityID = entityIds[foreignTableName],
OneToOne = Convert.ToInt32(reader["IsUnique"]) == 1
};
relations.Add(relation);
relationsProcessed++;
}
string primaryColumnName = reader["PrimaryColumnName"].ToString();
string foreignColumnName = reader["ForeignColumnName"].ToString();
var relationItem = new RelationItemDTO()
{
RelationID = relation.ID,
PrimaryAttributeID = attributeIds[primaryTableName + "." + primaryColumnName],
ForeignAttributeID = attributeIds[foreignTableName + "." + foreignColumnName]
};
relation.Items.Add(relationItem);
lastPrimaryTableName = primaryTableName;
lastForeignTableName = foreignTableName;
lastRelationName = relationName;
}
}
}
reader.Close();
}
return(relations);
}
internal List <EntityDTO> LoadEntities(DatabaseDTO database, ref int lastTable)
{
const int ExpectedColumnsTotal = 9;
const int TablesPerCall = 4;
// TODO: merge entities, attributes, not only data types
var dataTypes = new Dictionary <string, DataTypeDTO>();
var entities = new List <EntityDTO>();
foreach (var dataType in database.DataTypes)
{
dataTypes.Add(dataType.TypeName, dataType);
}
var commandText = SqlQueries.GetColumnsQuery;
using (var connection = new SqlConnection(database.ConnectionString))
{
var command = connection.CreateCommand();
command.CommandType = CommandType.Text;
command.CommandText = commandText;
var param1 = new SqlParameter();
param1.ParameterName = "@TABLE_NUMBER";
param1.SqlDbType = SqlDbType.Int;
param1.Direction = ParameterDirection.Input;
param1.Value = lastTable;
command.Parameters.Add(param1);
var param2 = new SqlParameter();
param2.ParameterName = "@TABLES_IN_ONE_CALL";
param2.SqlDbType = SqlDbType.Int;
param2.Direction = ParameterDirection.Input;
param2.Value = TablesPerCall;
command.Parameters.Add(param2);
connection.Open();
var reader = command.ExecuteReader();
{
if (reader.HasRows)
{
if (reader.FieldCount != ExpectedColumnsTotal)
{
throw new InvalidOperationException(String.Format("Query returned less or more than {0} columns ({1})", ExpectedColumnsTotal, commandText));
}
string lastTableSchema = string.Empty;
string lastTableName = string.Empty;
EntityDTO entity = null;
int tablesProcessed = 0;
while (reader.Read())
{
lastTable = Convert.ToInt32(reader["TABLE_NUMBER"]);
string tableSchema = reader["SchemaName"].ToString();
string tableName = reader["TableName"].ToString();
// New table
if (!tableSchema.Equals(lastTableSchema, StringComparison.InvariantCultureIgnoreCase) ||
!tableName.Equals(lastTableName, StringComparison.InvariantCultureIgnoreCase))
{
entity = new EntityDTO()
{
DatabaseID = database.ID,
SchemaName = tableSchema,
EntityName = tableName
};
entities.Add(entity);
tablesProcessed++;
}
var attribute = new AttributeDTO()
{
EntityID = entity.ID,
AttributeName = reader["ColumnName"].ToString(),
IsRequired = Convert.ToInt32(reader["IsNullable"]) == 0 ? true : false,
IsPrimaryKey = Convert.ToInt32(reader["IsPrimaryKey"]) == 0 ? false : true,
};
var attributeTypeName = reader["DataType"].ToString();
if (!dataTypes.ContainsKey(attributeTypeName))
{
var dataType = new DataTypeDTO()
{
DatabaseID = database.ID,
TypeName = attributeTypeName
};
dataTypes.Add(attributeTypeName, dataType);
database.DataTypes.Add(dataType);
}
var attributeType = dataTypes[attributeTypeName];
attribute.DataTypeID = attributeType.ID;
entity.Attributes.Add(attribute);
lastTableSchema = tableSchema;
lastTableName = tableName;
}
}
}
reader.Close();
}
return(entities);
}
