public void can_ensure_schema_info()
{
var si = new SchemaInfo(Driver);
si.EnsureSchemaTable();
Assert.IsTrue(Driver.Inspect<ITableExistsOperation>(op => op.TableName = "SchemaInfo"));
}
private SchemaInfo FromPropertyInfo(PropertyInfo pi)
{
if (!this.IsMapped(pi))
return null;
Type propertyType = pi.PropertyType;
bool nullableTypeDetected = propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == CachedTypes.PureNullableType;
SchemaInfo schema = new SchemaInfo(pi.Name, nullableTypeDetected ? propertyType.GetGenericArguments()[0] : propertyType);
//NotMapped gibi bir standart
KeyAttribute keyAtt = pi.GetCustomAttribute<KeyAttribute>();
if (null != keyAtt)
schema.IsKey = true;
if (nullableTypeDetected)
schema.IsNullable = true;
else
{
if (propertyType.IsClass)
schema.IsNullable = true;
else if (propertyType.IsValueType)
schema.IsNullable = false;
}
bool hasSetMethod = pi.GetSetMethod() != null;
if (!hasSetMethod)
schema.ReadOnly = true;
this.SetExtendedSchema(schema, pi);
return schema;
}
public Schema(SchemaInfo schemaInfo)
{
if (schemaInfo == null)
throw new ArgumentNullException("schemaInfo");
SchemaInfo = schemaInfo;
}
public void can_get_most_recent_version()
{
var si = new SchemaInfo(Driver);
si.EnsureSchemaTable();
si.InsertSchemaVersion(10, "assembly", "foo");
si.InsertSchemaVersion(100, "assembly", "bar");
si.InsertSchemaVersion(1, "assembly", "baz");
Assert.AreEqual(100, si.CurrentSchemaVersion("assembly"));
}
private static IEntityMetaData FromEdmx(IObjectContextAdapter contextAdapter, Type entityType)
{
List<SchemaInfo> schemas = new List<SchemaInfo>();
MetadataWorkspace mw = contextAdapter.ObjectContext.MetadataWorkspace;
EntityType et = mw.GetItems<EntityType>(DataSpace.CSpace).FirstOrDefault(e => String.Equals(e.Name, entityType.Name));
if (null != et)
{
foreach (EdmProperty edmProperty in et.Properties)
{
SchemaInfo schema = new SchemaInfo(edmProperty.Name);
schema.DataType = Type.GetType("System." + edmProperty.TypeUsage.EdmType.Name);
ReadOnlyMetadataCollection<Facet> facets = edmProperty.TypeUsage.Facets;
Facet facet;
if (facets.TryGetValue("Nullable", true, out facet))
{
schema.IsNullable = (bool)facet.Value;
}
if (facets.TryGetValue("MaxLength", true, out facet))
{
schema.MaxLength = (int)facet.Value;
}
schemas.Add(schema);
}
foreach (EdmMember keyInfo in et.KeyMembers)
{
schemas.First(s => s.ColumnName == keyInfo.Name).IsKey = true;
}
if (et.KeyMembers.Count == 1)
{
SchemaInfo key = schemas.First(s => s.IsKey);
if (key.DataType != CachedTypes.Guid)
key.DatabaseGeneratedOption = Data.StoreGeneratedPattern.Identity;
}
if (schemas.Count != 0)
{
EntityMetaData ret = new EntityMetaData(entityType, entityType.Name);
foreach (SchemaInfo schema in schemas)
{
ret.Add(schema, entityType.GetProperty(schema.ColumnName));
}
return ret;
}
}
return null;
}
public void can_get_all_version()
{
var si = new SchemaInfo(Driver);
si.EnsureSchemaTable();
si.InsertSchemaVersion(10, "assembly", "foo");
si.InsertSchemaVersion(100, "assembly", "bar");
si.InsertSchemaVersion(1, "assembly", "baz");
IList<long> versions = si.AppliedMigrations("assembly");
Assert.AreEqual(3, versions.Count);
Assert.AreEqual(1, versions[0]);
Assert.AreEqual(100, versions[2]);
}
static void Main(string[] args)
{
SchemaInfo schema = new SchemaInfo("Id", CachedTypes.Int32);
schema.DatabaseGeneratedOption = StoreGeneratedPattern.Identity; ;
schema.DefaultValue = "1";
schema.IsKey = true;
schema.IsNullable = false;
schema.MaxLength = 12;
schema.Order = 1;
schema.ReadOnly = true;
schema.SqlValueType = SqlValueType.Parameterized;
string xml = schema.XmlSerialize();
SchemaInfo copy = SchemaInfo.FromXml(xml);
// ExtTestAsync().Wait();
ExtTest();
ExtTestAsync().Wait();
SelectTest();
SelectSingleTest();
Update_NonIdentity();
Insert_NonIdentity();
UpsertUpdate_NonIdentity();
UpsertInsert_NonIdentity();
Update_Identity();
Insert_Identity();
UpsertUpdate_Identity();
UpsertInsert_Identity();
Delete();
Batch_Update_NonIdentity();
Batch_Insert_NonIdentity();
Batch_Upsert_Update_NonIdentity();
Batch_Upsert_Insert_NonIdentity();
Batch_Update_Identity();
Batch_Insert_Identity();
Batch_Upsert_Update_Identity();
Batch_Upsert_Insert_Identity();
}
public void CreateSchema(SchemaInfo schemaInfo)
{
if (schemaInfo == null)
throw new ArgumentNullException("schemaInfo");
var tableName = SystemSchema.SchemaInfoTableName;
var t = Transaction.GetMutableTable(tableName);
var nameObj = DataObject.String(schemaInfo.Name);
if (t.Exists(1, nameObj))
throw new DatabaseSystemException(String.Format("Schema '{0}' already defined in the database.", schemaInfo.Name));
var row = t.NewRow();
var uniqueId = Transaction.NextTableId(tableName);
row.SetValue(0, DataObject.Number(uniqueId));
row.SetValue(1, DataObject.String(schemaInfo.Name));
row.SetValue(2, DataObject.String(schemaInfo.Type));
row.SetValue(3, DataObject.String(schemaInfo.Culture));
t.AddRow(row);
}
public void XmlTest()
{
SchemaInfo schema = new SchemaInfo("Id", CachedTypes.Guid);
schema.DatabaseGeneratedOption = StoreGeneratedPattern.None;
schema.DefaultValue = Guid.Empty.ToString();
schema.IsKey = true;
schema.IsNullable = false;
schema.MaxLength = 32;
schema.ReadOnly = false;
schema.SqlValueType = SqlValueType.Parameterized;;
string xml = schema.XmlSerialize();
SchemaInfo copy = schema.Copy();
Stopwatch bench = Stopwatch.StartNew();
for (int j = 0; j < 100; ++j)
copy = schema.Copy();
bench.Stop();
Debug.WriteLine("Schema Xml Copy: " + bench.ElapsedMilliseconds);
Assert.IsNotNull(copy);
}
public async Task <string> GenerateDataScriptsAsync(SchemaInfo schemaInfo)
{
return(await this.dbScriptGenerator.GenerateDataScriptsAsync(schemaInfo));
}
public void can_insert_schema_version()
{
var si = new SchemaInfo(Driver);
si.EnsureSchemaTable();
si.InsertSchemaVersion(10, "assembly", "foo");
using (var reader = Driver.Read<IGenericReaderOperation>(op => op.Sql = "SELECT * FROM SchemaInfo WHERE Version=10"))
{
Assert.IsTrue(reader.Read());
}
}
public static List <SqlWord> FindWords(DatabaseType databaseType, string search, SqlWordTokenType tokenType = SqlWordTokenType.None, string parentName = null)
{
List <SqlWord> words = new List <SqlWord>();
//if (IsTypeMatched(tokenType, SqlWordTokenType.Keyword))
//{
// var keywords = KeywordManager.GetKeywords(databaseType).Where(item => Contains(item, search));
// words.AddRange(keywords.Select(item => new SqlWord() { Type = SqlWordTokenType.Keyword, Text = item }));
//}
if (IsTypeMatched(tokenType, SqlWordTokenType.BuiltinFunction))
{
var builtinFunctions = FunctionManager.GetFunctionSpecifications(databaseType).Where(item => ContainsWithNull(item.Name, search));
words.AddRange(builtinFunctions.Select(item => new SqlWord()
{
Type = SqlWordTokenType.BuiltinFunction, Text = item.Name, Source = item
}));
}
SchemaInfo schemaInfo = DataStore.GetSchemaInfo(databaseType);
if (schemaInfo != null)
{
if (IsTypeMatched(tokenType, SqlWordTokenType.Owner))
{
var owners = schemaInfo.Tables.Where(item => ContainsWithNull(item.Owner, search)).Select(item => item.Owner).Distinct();
words.AddRange(owners.Select(item => new SqlWord()
{
Type = SqlWordTokenType.Owner, Text = item, Source = item
}));
}
FilterDbObjects(words, schemaInfo.Functions, SqlWordTokenType.Function, tokenType, search, parentName);
FilterDbObjects(words, schemaInfo.Tables, SqlWordTokenType.Table, tokenType, search, parentName);
FilterDbObjects(words, schemaInfo.Views, SqlWordTokenType.View, tokenType, search, parentName);
if (tokenType == SqlWordTokenType.TableColumn)
{
IEnumerable <TableColumn> columns = schemaInfo.TableColumns;
if (!string.IsNullOrEmpty(parentName))
{
columns = schemaInfo.TableColumns.Where(item => item.TableName.ToUpper() == parentName.ToUpper());
}
if (!string.IsNullOrEmpty(search))
{
columns = columns.Where(item => ContainsWithNull(item.Name, search));
}
words.AddRange(columns.Select(item => new SqlWord()
{
Type = SqlWordTokenType.TableColumn, Text = item.Name, Source = item
}));
}
}
return(words);
}
public IObjectGraphType GetContentResultType(SchemaInfo schemaId)
{
return(contentResultTypes.GetOrDefault(schemaId));
}
public void TestAddAndLookupAndDeleteSchemaInfo()
{
ShardMapManagerFactory.CreateSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerCreateMode.ReplaceExisting);
ShardMapManager shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
#region TestAddAndLookup
SchemaInfoCollection siCollection = shardMapManager.GetSchemaInfoCollection();
SchemaInfo si = new SchemaInfo();
ShardedTableInfo stmd1 = new ShardedTableInfo("ShardedTableName1", "ColumnName");
ShardedTableInfo stmd2 = new ShardedTableInfo("dbo", "ShardedTableName2", "ColumnName");
si.Add(stmd1);
si.Add(stmd2);
Assert.AreEqual(2, si.ShardedTables.Count);
ReferenceTableInfo rtmd1 = new ReferenceTableInfo("ReferenceTableName1");
ReferenceTableInfo rtmd2 = new ReferenceTableInfo("dbo", "ReferenceTableName2");
si.Add(rtmd1);
si.Add(rtmd2);
Assert.AreEqual(2, si.ReferenceTables.Count);
// Add an existing sharded table again. Make sure it doesn't create duplicate entries.
SchemaInfoException siex = AssertExtensions.AssertThrows <SchemaInfoException>(
() => si.Add(new ShardedTableInfo("ShardedTableName1", "ColumnName")));
Assert.AreEqual(SchemaInfoErrorCode.TableInfoAlreadyPresent, siex.ErrorCode);
// Add an existing sharded table with a different key column name. This should fail too.
siex = AssertExtensions.AssertThrows <SchemaInfoException>(
() => si.Add(new ShardedTableInfo("ShardedTableName1", "ColumnName_Different")));
Assert.AreEqual(SchemaInfoErrorCode.TableInfoAlreadyPresent, siex.ErrorCode);
siex = AssertExtensions.AssertThrows <SchemaInfoException>(
() => si.Add(new ShardedTableInfo("dbo", "ShardedTableName2", "ColumnName_Different")));
Assert.AreEqual(SchemaInfoErrorCode.TableInfoAlreadyPresent, siex.ErrorCode);
Assert.AreEqual(2, si.ShardedTables.Count);
// Add an existing reference tables again. Make sure it doesn't create duplicate entries.
siex = AssertExtensions.AssertThrows <SchemaInfoException>(
() => si.Add(new ReferenceTableInfo("dbo", "ReferenceTableName2")));
Assert.AreEqual(SchemaInfoErrorCode.TableInfoAlreadyPresent, siex.ErrorCode);
Assert.AreEqual(2, si.ReferenceTables.Count);
// Now trying adding a reference table as a sharded table and vice versa. Both operations should fail.
siex = AssertExtensions.AssertThrows <SchemaInfoException>(
() => si.Add(new ShardedTableInfo("ReferenceTableName1", "ColumnName")));
Assert.AreEqual(SchemaInfoErrorCode.TableInfoAlreadyPresent, siex.ErrorCode);
Assert.AreEqual(2, si.ShardedTables.Count);
siex = AssertExtensions.AssertThrows <SchemaInfoException>(
() => si.Add(new ReferenceTableInfo("dbo", "ShardedTableName2")));
Assert.AreEqual(SchemaInfoErrorCode.TableInfoAlreadyPresent, siex.ErrorCode);
Assert.AreEqual(2, si.ReferenceTables.Count);
// Try removing an existing table info and adding it back.
si.Remove(stmd1);
si.Add(stmd1);
Assert.AreEqual(2, si.ShardedTables.Count);
si.Remove(rtmd2);
si.Add(rtmd2);
Assert.AreEqual(2, si.ReferenceTables.Count);
// Test with NULL inputs.
ArgumentException arex = AssertExtensions.AssertThrows <ArgumentException>(
() => si.Add((ShardedTableInfo)null));
arex = AssertExtensions.AssertThrows <ArgumentException>(
() => si.Add((ReferenceTableInfo)null));
string mdName = String.Format("TestSI_{0}", Guid.NewGuid());
siCollection.Add(mdName, si);
SchemaInfo sdmdRead = siCollection.Get(mdName);
AssertEqual(si, sdmdRead);
// Trying to add schema info with the same name again will result in a 'name conflict' exception.
siex = AssertExtensions.AssertThrows <SchemaInfoException>(
() => siCollection.Add(mdName, si));
Assert.AreEqual(SchemaInfoErrorCode.SchemaInfoNameConflict, siex.ErrorCode);
#endregion
#region TestLookup
// Try looking up schema info with a non-existent name.
siex = AssertExtensions.AssertThrows <SchemaInfoException>(
() => siCollection.Get(mdName + "Fail"));
Assert.AreEqual(SchemaInfoErrorCode.SchemaInfoNameDoesNotExist, siex.ErrorCode);
#endregion
#region TestDelete
// Try removing any of the recently created schema info.
siCollection.Remove(mdName);
// Lookup should fail on removed data.
siex = AssertExtensions.AssertThrows <SchemaInfoException>(
() => siCollection.Get(mdName));
Assert.AreEqual(SchemaInfoErrorCode.SchemaInfoNameDoesNotExist, siex.ErrorCode);
#endregion
}
public void TestGetAll()
{
ShardMapManagerFactory.CreateSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerCreateMode.ReplaceExisting);
ShardMapManager shardMapManager = ShardMapManagerFactory.GetSqlShardMapManager(
Globals.ShardMapManagerConnectionString,
ShardMapManagerLoadPolicy.Lazy);
SchemaInfoCollection siCollection = shardMapManager.GetSchemaInfoCollection();
SchemaInfo[] si = new SchemaInfo[3]
{
new SchemaInfo(),
new SchemaInfo(),
new SchemaInfo()
};
si[0].Add(new ShardedTableInfo("ShardedTableName1", "ColumnName1"));
si[0].Add(new ShardedTableInfo("dbo", "ShardedTableName2", "ColumnName1"));
si[0].Add(new ReferenceTableInfo("ReferenceTableName1"));
si[0].Add(new ReferenceTableInfo("dbo", "ReferenceTableName2"));
si[1].Add(new ShardedTableInfo("ShardedTableName3", "ColumnName2"));
si[1].Add(new ShardedTableInfo("dbo", "ShardedTableName4", "ColumnName2"));
si[1].Add(new ReferenceTableInfo("ReferenceTableName3"));
si[2].Add(new ShardedTableInfo("dbo", "ShardedTableName3", "ColumnName2"));
si[2].Add(new ReferenceTableInfo("ReferenceTableName4"));
si[2].Add(new ReferenceTableInfo("dbo", "ReferenceTableName5"));
string[] siNames = new string[3]
{
String.Format("TestSI_{0}", Guid.NewGuid()),
String.Format("TestSI_{0}", Guid.NewGuid()),
String.Format("TestSI_{0}", Guid.NewGuid())
};
siCollection.Add(siNames[0], si[0]);
siCollection.Add(siNames[1], si[1]);
siCollection.Add(siNames[2], si[2]);
int i = 0;
bool success = true;
foreach (KeyValuePair <string, SchemaInfo> kvp in siCollection)
{
SchemaInfo sdmdOriginal;
try
{
sdmdOriginal = si[Array.IndexOf(siNames, kvp.Key)];
}
catch
{
success = false;
break;
}
AssertEqual(sdmdOriginal, kvp.Value);
i++;
}
Assert.IsTrue(success);
Assert.AreEqual(3, i);
}
public static void CreateSchema(this ITransaction transaction, SchemaInfo schemaInfo)
{
transaction.CreateObject(schemaInfo);
}
protected void Page_Init(object sender, EventArgs e)
{
schemaInfo = Application["SchemaInfo"] as SchemaInfo;
}
// FIXME: this class should actually be reimplemented to be one
// of the derived classes of DbDataRecord, which should become
// almost abstract.
internal DbDataRecordImpl(SchemaInfo[] schema, object[] values)
{
this.schema = schema;
this.values = values;
this.fieldCount = values.Length;
}
public override async Task <string> GenerateDataScriptsAsync(SchemaInfo schemaInfo)
{
return(await base.GenerateDataScriptsAsync(schemaInfo));
}
public override ScriptBuilder GenerateSchemaScripts(SchemaInfo schemaInfo)
{
ScriptBuilder sb = new ScriptBuilder();
string dbOwner = this.GetDbOwner();
//#region User Defined Type
//List<string> userTypeNames = schemaInfo.UserDefinedTypes.Select(item => item.Name).Distinct().ToList();
//foreach (string userTypeName in userTypeNames)
//{
// IEnumerable<UserDefinedType> userTypes = schemaInfo.UserDefinedTypes.Where(item => item.Name == userTypeName);
// this.FeedbackInfo(OperationState.Begin, userTypes.First());
// string dataTypes = string.Join(",", userTypes.Select(item => $"{item.AttrName} {this.dbInterpreter.ParseDataType(new TableColumn() { MaxLength = item.MaxLength, DataType = item.Type, Precision = item.Precision, Scale = item.Scale })}"));
// string script = $"CREATE TYPE {this.GetQuotedString(userTypeName)} AS OBJECT ({dataTypes})" + this.dbInterpreter.ScriptsDelimiter;
// sb.AppendLine(new CreateDbObjectScript<UserDefinedType>(script));
// this.FeedbackInfo(OperationState.End, userTypes.First());
//}
//#endregion
#region Function
sb.AppendRange(this.GenerateScriptDbObjectScripts <Function>(schemaInfo.Functions));
#endregion
#region Table
foreach (Table table in schemaInfo.Tables)
{
this.FeedbackInfo(OperationState.Begin, table);
IEnumerable <TableColumn> columns = schemaInfo.TableColumns.Where(item => item.TableName == table.Name).OrderBy(item => item.Order);
TablePrimaryKey primaryKey = schemaInfo.TablePrimaryKeys.FirstOrDefault(item => item.TableName == table.Name);
IEnumerable <TableForeignKey> foreignKeys = schemaInfo.TableForeignKeys.Where(item => item.TableName == table.Name);
IEnumerable <TableIndex> indexes = schemaInfo.TableIndexes.Where(item => item.TableName == table.Name).OrderBy(item => item.Order);
IEnumerable <TableConstraint> constraints = schemaInfo.TableConstraints.Where(item => item.Owner == table.Owner && item.TableName == table.Name);
ScriptBuilder sbTable = this.AddTable(table, columns, primaryKey, foreignKeys, indexes, constraints);
sb.AppendRange(sbTable.Scripts);
this.FeedbackInfo(OperationState.End, table);
}
#endregion
#region View
sb.AppendRange(this.GenerateScriptDbObjectScripts <View>(schemaInfo.Views));
#endregion
#region Trigger
sb.AppendRange(this.GenerateScriptDbObjectScripts <TableTrigger>(schemaInfo.TableTriggers));
#endregion
#region Procedure
sb.AppendRange(this.GenerateScriptDbObjectScripts <Procedure>(schemaInfo.Procedures));
#endregion
if (this.option.ScriptOutputMode.HasFlag(GenerateScriptOutputMode.WriteToFile))
{
this.AppendScriptsToFile(sb.ToString(), GenerateScriptMode.Schema, true);
}
return(sb);
}
public void can_remove_schema_version()
{
can_insert_schema_version();
var si = new SchemaInfo(Driver);
si.DeleteSchemaVersion(10, "assembly");
using (var reader = Driver.Read<IGenericReaderOperation>(op => op.Sql = "SELECT * FROM SchemaInfo WHERE Version=10"))
{
Assert.IsFalse(reader.Read());
}
}
protected abstract void SetExtendedSchema(SchemaInfo schema, PropertyInfo pi);
protected override void SetExtendedSchema(SchemaInfo schema, PropertyInfo pi)
{
DbSchemaAttribute att = pi.GetCustomAttribute<DbSchemaAttribute>();
if (null != att)
{
if (!String.IsNullOrEmpty(att.ColumnName))
schema.ColumnName = att.ColumnName;
schema.DatabaseGeneratedOption = att.DatabaseGeneratedOption;
schema.DefaultValue = att.DefaultValue;
schema.IsKey = att.IsKey;
schema.MaxLength = att.MaxLength;
schema.Order = att.Order;
schema.IsNullable = att.IsNullable;
schema.ReadOnly = att.ReadOnly;
}
}
public void Compile(ValidationEventHandler validationEventHandler, XmlResolver resolver) {
SchemaInfo sInfo = new SchemaInfo();
sInfo.SchemaType = SchemaType.XSD;
CompileSchema(null, resolver, sInfo, null, validationEventHandler, NameTable, false);
}
internal void AddCompiledInfo(SchemaInfo schemaInfo) {
XmlQualifiedName itemName;
foreach (XmlSchemaElement element in elements.Values) {
itemName = element.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
if (schemaInfo.ElementDecls[itemName] == null) {
schemaInfo.ElementDecls.Add(itemName, element.ElementDecl);
}
}
foreach (XmlSchemaAttribute attribute in attributes.Values) {
itemName = attribute.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
if (schemaInfo.ElementDecls[itemName] == null) {
schemaInfo.AttributeDecls.Add(itemName, attribute.AttDef);
}
}
foreach (XmlSchemaType type in types.Values) {
itemName = type.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
XmlSchemaComplexType complexType = type as XmlSchemaComplexType;
if ((complexType == null || type != XmlSchemaComplexType.AnyType) && schemaInfo.ElementDeclsByType[itemName] == null) {
schemaInfo.ElementDeclsByType.Add(itemName, type.ElementDecl);
}
}
foreach (XmlSchemaNotation notation in notations.Values) {
itemName = notation.QualifiedName;
schemaInfo.TargetNamespaces[itemName.Namespace] = true;
SchemaNotation no = new SchemaNotation(itemName);
no.SystemLiteral = notation.System;
no.Pubid = notation.Public;
if (schemaInfo.Notations[itemName.Name] == null) {
schemaInfo.Notations.Add(itemName.Name, no);
}
}
}
private void LoadSchemaFromXml(string fileName)
{
schemaInfo = SchemaManager.ReadAndValidateSchema(
new XmlTextReader(fileName),
Path.GetDirectoryName(fileName));
}
private static void GetAssembliesAndTypes(string[] pClassFilenames, string[] pDependencyFilenames, ref SchemaInfo pSchema)
{
// Creates a SchemaExtractor instance on a new domain. This is done
// so that no assembly is loaded on process start, and at the end,
// only needed assemblies are loaded.
AppDomain lDomain = AppDomain.CreateDomain("User assemblies domain.");
SchemaExtractor lExtractor;
lExtractor = (SchemaExtractor)lDomain.CreateInstanceFromAndUnwrap(typeof(SchemaExtractor).Assembly.CodeBase, typeof(SchemaExtractor).FullName);
// Load assemblies and types on the new domain.
List<string> lTypeNames = null;
List<string> lAssemblyNames = null;
List<string> lActualDependencies = null;
lExtractor.GetAssembliesAndTypesHelper(pClassFilenames, pDependencyFilenames, ref lAssemblyNames, ref lTypeNames, ref lActualDependencies);
AppDomain.Unload(lDomain);
// Load assemblies on this domain (to be able to access types).
Assembly l;
foreach (string lDep in lActualDependencies)
{
l = Assembly.LoadFrom(lDep);
}
// Obtain types from names and fill in schema.
pSchema.PersistableTypes = lTypeNames.Select(lTypeName => DataMember.GetTypeFromAnyAssemblyVersion(lTypeName)).ToArray();
pSchema.LoadedAssemblies = lActualDependencies.ToArray();
pSchema.LoadedAssembliesNames = lAssemblyNames.ToArray();
}
private async void GenerateScourceDbScripts()
{
SchemaInfo schemaInfo = this.GetSourceTreeSchemaInfo();
if (!this.ValidateSource(schemaInfo))
{
return;
}
this.btnGenerateSourceScripts.Enabled = false;
DatabaseType sourceDbType = this.GetDatabaseType(this.cboSourceDB.Text);
int dataBatchSize = SettingManager.Setting.DataBatchSize;
DbInterpreterOption sourceScriptOption = new DbInterpreterOption()
{
ScriptOutputMode = GenerateScriptOutputMode.WriteToFile, DataBatchSize = dataBatchSize
};
this.SetGenerateScriptOption(sourceScriptOption);
GenerateScriptMode scriptMode = this.GetGenerateScriptMode();
if (scriptMode == GenerateScriptMode.None)
{
MessageBox.Show("Please specify the script mode.");
return;
}
DbInterpreter dbInterpreter = DbInterpreterHelper.GetDbInterpreter(sourceDbType, this.sourceDbConnectionInfo, sourceScriptOption);
SelectionInfo selectionInfo = new SelectionInfo()
{
UserDefinedTypeNames = schemaInfo.UserDefinedTypes.Select(item => item.Name).ToArray(),
TableNames = schemaInfo.Tables.Select(item => item.Name).ToArray(),
ViewNames = schemaInfo.Views.Select(item => item.Name).ToArray()
};
try
{
schemaInfo = await dbInterpreter.GetSchemaInfoAsync(selectionInfo);
dbInterpreter.Subscribe(this);
GenerateScriptMode mode = GenerateScriptMode.None;
if (scriptMode.HasFlag(GenerateScriptMode.Schema))
{
mode = GenerateScriptMode.Schema;
dbInterpreter.GenerateSchemaScripts(schemaInfo);
}
if (scriptMode.HasFlag(GenerateScriptMode.Data))
{
mode = GenerateScriptMode.Data;
await dbInterpreter.GenerateDataScriptsAsync(schemaInfo);
}
this.OpenInExplorer(dbInterpreter.GetScriptOutputFilePath(mode));
MessageBox.Show(DONE);
}
catch (Exception ex)
{
this.HandleException(ex);
}
this.btnGenerateSourceScripts.Enabled = true;
}
private void AssertEqual(SchemaInfo x, SchemaInfo y)
{
AssertExtensions.AssertSequenceEquivalent(x.ReferenceTables, y.ReferenceTables);
AssertExtensions.AssertSequenceEquivalent(x.ShardedTables, y.ShardedTables);
}
public OguObjectCollection <IOguObject> QueryDescendants(IOrganization parent, string prefix, int maxCount)
{
return(this.QueryDescendants <IOguObject>(parent, prefix, maxCount, SchemaInfo.FilterByCategory("Users", "Groups", "Organizations").ToSchemaNames()));
}
static XmlQualifiedName AddAttributeTypeToXmlSchema(SchemaInfo schemaInfo, UxmlAttributeDescription description, IUxmlFactory factory, FactoryProcessingHelper processingData)
{
if (description.name == null)
{
return(null);
}
string attrTypeName = factory.uxmlQualifiedName + "_" + description.name + "_" + k_TypeSuffix;
string attrTypeNameInBaseElement = factory.substituteForTypeQualifiedName + "_" + description.name + "_" + k_TypeSuffix;
FactoryProcessingHelper.AttributeRecord attrRecord;
if (processingData.attributeTypeNames.TryGetValue(attrTypeNameInBaseElement, out attrRecord))
{
// If restriction != baseElement.restriction, we need to declare a new type.
// Note: we do not support attributes having a less restrictive restriction than its base type.
if ((description.restriction == null && attrRecord.desc.restriction == null) ||
(description.restriction != null && description.restriction.Equals(attrRecord.desc.restriction)))
{
// Register attrTypeName -> attrRecord for potential future derived elements.
processingData.attributeTypeNames.Add(attrTypeName, attrRecord);
return(attrRecord.name);
}
}
XmlQualifiedName xqn;
FactoryProcessingHelper.AttributeRecord attributeRecord;
if (description.restriction == null)
{
// Type is a built-in type.
xqn = new XmlQualifiedName(description.type, description.typeNamespace);
attributeRecord = new FactoryProcessingHelper.AttributeRecord {
name = xqn, desc = description
};
processingData.attributeTypeNames.Add(attrTypeName, attributeRecord);
return(xqn);
}
string attrTypeNameForSchema = factory.uxmlName + "_" + description.name + "_" + k_TypeSuffix;
xqn = new XmlQualifiedName(attrTypeNameForSchema, schemaInfo.schema.TargetNamespace);
XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType();
simpleType.Name = attrTypeNameForSchema;
UxmlEnumeration enumRestriction = description.restriction as UxmlEnumeration;
if (enumRestriction != null)
{
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
simpleType.Content = restriction;
restriction.BaseTypeName = new XmlQualifiedName(description.type, description.typeNamespace);
foreach (var v in enumRestriction.values)
{
XmlSchemaEnumerationFacet enumValue = new XmlSchemaEnumerationFacet();
enumValue.Value = v;
restriction.Facets.Add(enumValue);
}
}
else
{
UxmlValueMatches regexRestriction = description.restriction as UxmlValueMatches;
if (regexRestriction != null)
{
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
simpleType.Content = restriction;
restriction.BaseTypeName = new XmlQualifiedName(description.type, description.typeNamespace);
XmlSchemaPatternFacet pattern = new XmlSchemaPatternFacet();
pattern.Value = regexRestriction.regex;
restriction.Facets.Add(pattern);
}
else
{
UxmlValueBounds bounds = description.restriction as UxmlValueBounds;
if (bounds != null)
{
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
simpleType.Content = restriction;
restriction.BaseTypeName = new XmlQualifiedName(description.type, description.typeNamespace);
XmlSchemaFacet facet;
if (bounds.excludeMin)
{
facet = new XmlSchemaMinExclusiveFacet();
}
else
{
facet = new XmlSchemaMinInclusiveFacet();
}
facet.Value = bounds.min;
restriction.Facets.Add(facet);
if (bounds.excludeMax)
{
facet = new XmlSchemaMaxExclusiveFacet();
}
else
{
facet = new XmlSchemaMaxInclusiveFacet();
}
facet.Value = bounds.max;
restriction.Facets.Add(facet);
}
else
{
Debug.Log("Unsupported restriction type.");
}
}
}
schemaInfo.schema.Items.Add(simpleType);
attributeRecord = new FactoryProcessingHelper.AttributeRecord {
name = xqn, desc = description
};
processingData.attributeTypeNames.Add(attrTypeName, attributeRecord);
return(xqn);
}
public void LoadAllFederationAssemblies()
{
if (m_typesAssemblies != null && m_typesAssemblies.Length > 0)
m_schemaInfo = SchemaExtractor.Extract(m_typesAssemblies, m_typesDependencyAssemblies);
}
protected void CreateSchemaInfoTable()
{
EnsureHasConnection();
SchemaInfo.CreateTableIfYouHaventAlready();
}
/// <summary>
/// Get Schema Information for current DB.
/// The Schema Information will be cache into CacheManager.Default
/// </summary>
/// <returns></returns>
public virtual SchemaInfo GetSchemaInfo(string databaseName = null)
{
if (databaseName.IsNullOrEmpty())
{
var cn = (SqlConnectionStringBuilder)ConnectionString;
databaseName = cn.InitialCatalog;
if (databaseName.IsNullOrEmpty())
{
databaseName = cn.AttachDBFilename;
}
}
Guard.ArgumentIsNotNull(databaseName, nameof(databaseName));
SchemaInfo schema;
using (var reader = ExecuteReader(QuerySchemaInfo))
{
schema = new SchemaInfo(databaseName);
while (reader.Read())
{
#region Field Values
var ordinalPosition = reader.GetValue <int>(FieldOrdinalPosition);
var tableName = reader.GetValue <string>(FieldTableName);
var tableSchema = reader.GetValue <string>(FieldTableSchema);
var columnName = reader.GetValue <string>(FieldColumnName);
var isNullable = reader.GetValue <bool>(FieldIsNullable);
var dataType = reader.GetValue <string>(FieldDataType).ToSqlDbType();
var characterMaximumLength = reader.GetValue <int>(FieldCharacterMaximumLength);
var isIdentity = reader.GetValue <bool>(FieldIsIdentity);
var isComputed = reader.GetValue <bool>(FieldIsComputed);
var isPrimaryKey = reader.GetValue <bool>(FieldIsPrimaryKey);
var isPoreignKey = reader.GetValue <bool>(FieldIsPoreignKey);
var fkTableSchema = reader.GetValue <string>(FieldFkTableSchema);
var fkTableName = reader.GetValue <string>(FieldFkTableName);
var fkColumnName = reader.GetValue <string>(FieldFkColumnName);
var rowCount = reader.GetValue <int>(FieldRowCount);
var foreignKeyName = reader.GetValue <string>(FieldForeignKeyName);
var isTable = reader.GetValue <bool>(FieldIsTable);
#endregion Field Values
#region Collect Info
var tbName = new DbName(tableSchema, tableName);
if (isTable)
{
//Collect Tables
var table = schema.Tables[tbName];
if (table == null)
{
table = new TableInfo(tbName)
{
RowCount = rowCount
};
schema.Tables.Add(table);
}
//Collect ColumnInfo
var column = table.Columns[columnName];
if (column == null)
{
column = new ColumnInfo
{
Name = columnName,
OrdinalPosition = ordinalPosition,
DataType = dataType,
IsIdentity = isIdentity,
IsPrimaryKey = isPrimaryKey,
IsNullable = isNullable,
MaxLengh = characterMaximumLength,
IsComputed = isComputed
};
table.Columns.Add(column);
}
if (!isPoreignKey)
{
continue;
}
//Collect ForeignKeys
var refCol = new ReferencedColumnInfo(fkTableSchema, fkTableName, fkColumnName);
table.ForeignKeys.Add(new ForeignKeyInfo(foreignKeyName, column, refCol));
}
else
{
//Collect Views
var view = schema.Views[tbName];
if (view == null)
{
view = new ViewInfo(tbName);
schema.Views.Add(view);
}
if (!view.Columns.Contains(columnName))
{
view.Columns.Add(columnName);
}
}
#endregion Collect Info
}
}
schema = GetMaxPrimaryKeyValues(schema);
return(schema);
}
private async Task Convert()
{
SchemaInfo schemaInfo = this.GetSourceTreeSchemaInfo();
if (!this.ValidateSource(schemaInfo))
{
return;
}
if (this.targetDbConnectionInfo == null)
{
MessageBox.Show("Target connection info is null.");
return;
}
if (this.sourceDbConnectionInfo.Server == this.targetDbConnectionInfo.Server && this.sourceDbConnectionInfo.Database == this.targetDbConnectionInfo.Database)
{
MessageBox.Show("Source database cannot be equal to the target database.");
return;
}
DatabaseType sourceDbType = this.GetDatabaseType(this.cboSourceDB.Text);
DatabaseType targetDbType = this.GetDatabaseType(this.cboTargetDB.Text);
int dataBatchSize = SettingManager.Setting.DataBatchSize;
DbInterpreterOption sourceScriptOption = new DbInterpreterOption()
{
ScriptOutputMode = GenerateScriptOutputMode.None, DataBatchSize = dataBatchSize
};
DbInterpreterOption targetScriptOption = new DbInterpreterOption()
{
ScriptOutputMode = (GenerateScriptOutputMode.WriteToString), DataBatchSize = dataBatchSize
};
this.SetGenerateScriptOption(sourceScriptOption, targetScriptOption);
if (this.chkGenerateSourceScripts.Checked)
{
sourceScriptOption.ScriptOutputMode = sourceScriptOption.ScriptOutputMode | GenerateScriptOutputMode.WriteToFile;
}
if (this.chkOutputScripts.Checked)
{
targetScriptOption.ScriptOutputMode = targetScriptOption.ScriptOutputMode | GenerateScriptOutputMode.WriteToFile;
}
targetScriptOption.GenerateIdentity = this.chkGenerateIdentity.Checked;
GenerateScriptMode scriptMode = this.GetGenerateScriptMode();
if (scriptMode == GenerateScriptMode.None)
{
MessageBox.Show("Please specify the script mode.");
return;
}
DbConvetorInfo source = new DbConvetorInfo()
{
DbInterpreter = DbInterpreterHelper.GetDbInterpreter(sourceDbType, this.sourceDbConnectionInfo, sourceScriptOption)
};
DbConvetorInfo target = new DbConvetorInfo()
{
DbInterpreter = DbInterpreterHelper.GetDbInterpreter(targetDbType, this.targetDbConnectionInfo, targetScriptOption)
};
try
{
using (dbConvertor = new DbConvertor(source, target))
{
dbConvertor.Option.GenerateScriptMode = scriptMode;
dbConvertor.Option.BulkCopy = this.chkBulkCopy.Checked;
dbConvertor.Option.ExecuteScriptOnTargetServer = this.chkExecuteOnTarget.Checked;
dbConvertor.Option.UseTransaction = this.chkUseTransaction.Checked;
dbConvertor.Subscribe(this);
if (sourceDbType == DatabaseType.MySql)
{
source.DbInterpreter.Option.InQueryItemLimitCount = 2000;
}
if (targetDbType == DatabaseType.SqlServer)
{
target.DbOwner = this.txtTargetDbOwner.Text ?? "dbo";
}
else if (targetDbType == DatabaseType.MySql)
{
target.DbInterpreter.Option.RemoveEmoji = true;
}
dbConvertor.Option.SplitScriptsToExecute = true;
this.btnExecute.Enabled = false;
this.btnCancel.Enabled = true;
await dbConvertor.Convert(schemaInfo);
}
}
catch (Exception ex)
{
this.hasError = true;
this.HandleException(ex);
}
if (!this.hasError)
{
this.btnExecute.Enabled = true;
this.btnCancel.Enabled = false;
if (!this.dbConvertor.CancelRequested)
{
this.txtMessage.AppendText(Environment.NewLine + DONE);
MessageBox.Show(DONE);
}
else
{
MessageBox.Show("Task has been canceled.");
}
}
}
protected override void SetExtendedSchema(SchemaInfo schema, PropertyInfo pi)
{
if (pi.GetCustomAttribute<KeyAttribute>() != null || String.Equals(pi.Name, "Id", StringComparison.OrdinalIgnoreCase))
{
schema.IsKey = true;
}
}
public OguObjectCollection <IOguObject> GetObjects(params string[] ids)
{
ids.NullCheck("ids");
SCObjectAndRelationCollection relations = SCSnapshotAdapter.Instance.QueryObjectAndRelationByIDs(SchemaInfo.FilterByCategory("Users", "Groups", "Organizations").ToSchemaNames(), ids, false, DateTime.MinValue);
relations.FillDetails();
List <IOguObject> list = new List <IOguObject>(relations.Count);
foreach (var item in relations)
{
SchemaObjectBase obj = item.Detail;
if (obj != null)
{
IOguObject oguObj = obj.ToSimpleObject().ToOguObject();
list.Add(oguObj);
}
}
return(new OguObjectCollection <IOguObject>(list));
}
internal static FieldType WithSchemaNamedId(this FieldType field, SchemaInfo value)
{
return(field.WithMetadata(nameof(SchemaNamedId), value.Schema.NamedId()));
}
public IEnumerable <IOguObject> GetChildren(IOrganization parent)
{
SCObjectAndRelationCollection relations = SCSnapshotAdapter.Instance.QueryObjectAndRelationByParentIDs(SchemaInfo.FilterByCategory("Users", "Groups", "Organizations").ToSchemaNames(), new string[] { parent.ID }, false, true, false, DateTime.MinValue);
relations.FillDetails();
var parentList = SCSnapshotAdapter.Instance.LoadAllParentsInfo(true, parent.ID)[parent.ID];
StringBuilder strB = new StringBuilder(parentList.Count * 15);
for (int i = 0; i < parentList.Count; i++)
{
strB.Append(parentList[i].Name);
strB.Append("");
}
var parentPath = strB.ToString();
foreach (var item in relations)
{
OguBase ogu = (OguBase)item.Detail.ToPhantom();
ogu.FullPath = parentPath + ogu.Name;
yield return(ogu);
}
}
private void LoadDocumentType(XmlValidatingReader vr, XmlDocumentType dtNode)
{
SchemaInfo schInfo = vr.GetSchemaInfo();
if (schInfo != null)
{
//set the schema information into the document
doc.SchemaInformation = schInfo;
// Notation hashtable
if (schInfo.Notations != null)
{
foreach (SchemaNotation scNot in schInfo.Notations.Values)
{
dtNode.Notations.SetNamedItem(new XmlNotation(scNot.Name.Name, scNot.Pubid, scNot.SystemLiteral, doc));
}
}
// Entity hashtables
if (schInfo.GeneralEntities != null)
{
foreach (SchemaEntity scEnt in schInfo.GeneralEntities.Values)
{
XmlEntity ent = new XmlEntity(scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, doc);
ent.SetBaseURI(scEnt.DeclaredURI);
dtNode.Entities.SetNamedItem(ent);
}
}
if (schInfo.ParameterEntities != null)
{
foreach (SchemaEntity scEnt in schInfo.ParameterEntities.Values)
{
XmlEntity ent = new XmlEntity(scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, doc);
ent.SetBaseURI(scEnt.DeclaredURI);
dtNode.Entities.SetNamedItem(ent);
}
}
doc.Entities = dtNode.Entities;
//extract the elements which has attribute defined as ID from the element declarations
IDictionaryEnumerator elementDecls = schInfo.ElementDecls.GetEnumerator();
if (elementDecls != null)
{
elementDecls.Reset();
while (elementDecls.MoveNext())
{
SchemaElementDecl elementDecl = (SchemaElementDecl)elementDecls.Value;
if (elementDecl.AttDefs != null)
{
IDictionaryEnumerator attDefs = elementDecl.AttDefs.GetEnumerator();
while (attDefs.MoveNext())
{
SchemaAttDef attdef = (SchemaAttDef)attDefs.Value;
if (attdef.Datatype.TokenizedType == XmlTokenizedType.ID)
{
doc.AddIdInfo(
doc.GetXmlName(elementDecl.Name.Name, elementDecl.Name.Namespace),
doc.GetXmlName(attdef.Name.Name, attdef.Name.Namespace));
break;
}
}
}
}
}
}
}
public SchemaInfoBuilder()
{
_info = new SchemaInfo();
}
public override void Run()
{
//State = WorkerState.Working;
try
{
//initialize the context
using (CurrentDbContext = new AryaDbDataContext(CurrentProjectId, ImportRequestedBy))
{
var imageMgr = new ImageManager(CurrentDbContext, CurrentProjectId);
List <ListOfValuesInterchangeRecord> allData = ImportData.ListOfValues;
//read all the data into a list<T>, change this as its not very efficient and scalable.
var invalidRecords = allData.GetInvalidRecords();
var listOfValuesInterchangeRecords = invalidRecords as IList <ListOfValuesInterchangeRecord> ?? invalidRecords.ToList();
listOfValuesInterchangeRecords.ToList().ForEach(ir => _warnings.Add(new WorkerWarning
{
LineData = ir.ToString(),
ErrorMessage = Properties.Resources.RequiredValueNullWarningMessage
}));
var validImportRecords = allData.Except(listOfValuesInterchangeRecords.ToList()).ToList();
var newValueCount = 0;
int ignoredCount = 0;
int updatedCount = 0;
// load a dictionary with taxonomy string / id pairs (taken from TaxonomyImport)
var taxDict =
CurrentDbContext.ExecuteQuery <TaxonomyPathAndId>(@"SELECT TaxonomyPath, TaxonomyId
FROM V_Taxonomy
WHERE TaxonomyPath <> ''
AND ProjectId = {0}", CurrentProjectId).ToDictionary(
key => key.TaxonomyPath, value => value.TaxonomyId,
StringComparer.OrdinalIgnoreCase);
// load attribute and schema dictionaries
var attDict =
CurrentDbContext.Attributes.Where(
a => a.AttributeType == AttributeTypeEnum.Sku.ToString())
.Select(a => a)
.ToDictionary(key => key.AttributeName, value => value);
var schDict = new DoubleKeyDictionary <Guid, Guid, SchemaInfo>();
CurrentDbContext.SchemaInfos.ForEach(si => schDict.Add(si.TaxonomyID, si.AttributeID, si));
// iterate through the input records.
foreach (var csvRecord in validImportRecords)
{
var currentRecord = csvRecord;
// check for taxonomy - if it doesn't exist, give up.
if (!taxDict.ContainsKey(currentRecord.TaxonomyPath))
{
_warnings.Add(new WorkerWarning()
{
LineData = currentRecord.ToString(), ErrorMessage = Properties.Resources.TaxonomyDoesNotExistsWarningMessage
});
continue;
}
var taxId = taxDict[currentRecord.TaxonomyPath];
var taxonomy = CurrentDbContext.TaxonomyInfos.First(ti => ti.ID == taxId);
// if attribute exists, get it, otherwise give up.
if (!attDict.ContainsKey(currentRecord.AttributeName))
{
_warnings.Add(new WorkerWarning()
{
LineData = currentRecord.ToString(), ErrorMessage = Properties.Resources.AttributeDoesNotExistWarningMessage
});
continue;
}
var att = attDict[currentRecord.AttributeName];
// if schema info exists, get it, otherwise create both it and schema data
SchemaInfo sch;
if (schDict.ContainsKeys(taxId, att.ID))
{
sch = schDict[taxId, att.ID];
}
else
{
sch = new SchemaInfo(CurrentDbContext)
{
TaxonomyID = taxId,
Attribute = att,
SchemaDatas =
{
new SchemaData(CurrentDbContext)
{
InSchema = true, NavigationOrder = 0, DisplayOrder = 0
}
}
};
att.SchemaInfos.Add(sch);
schDict.Add(taxId, att.ID, sch);
}
var lov = sch.ListOfValues.FirstOrDefault(v => v.Value.ToLower() == currentRecord.Lov.ToLower() && v.Active);
string enrichmentImageGuid = null;
int displayOrder;
if (lov != null || (lov == null && CurrentImportOptions.HasFlag(ImportOptions.CreateMissingLOVs)))
{
// if image url exists try to upload the image - "try" is used in case the url is badly formed.
// string enrichmentImage = null;
var success = false;
if (currentRecord.EnrichmentImage != null)
{
//Success is for valid uri. If the image name only exist not the real file it will be false and added as warning
success = imageMgr.UploadImage(currentRecord.EnrichmentImage);
enrichmentImageGuid = imageMgr.RemoteImageGuid;
var newSku = imageMgr.ImageSku;
newSku.EntityInfos.Add(new EntityInfo(CurrentDbContext)
{
EntityDatas =
{
new EntityData(CurrentDbContext)
{
Attribute =
Attribute.GetAttributeFromName(CurrentDbContext,
Framework.Properties.Resources.LovIdAttributeName, true, AttributeTypeEnum.Sku, false),
Value = imageMgr.RemoteImageGuid
}
}
});
newSku.EntityInfos.Add(new EntityInfo(CurrentDbContext)
{
EntityDatas =
{
new EntityData(CurrentDbContext)
{
Attribute =
Attribute.GetAttributeFromName(CurrentDbContext,
Framework.Properties.Resources.AttributeIdAttributeName,
true, AttributeTypeEnum.Sku, false),
Value = sch.AttributeID.ToString()
}
}
});
newSku.EntityInfos.Add(new EntityInfo(CurrentDbContext)
{
EntityDatas =
{
new EntityData(CurrentDbContext)
{
Attribute =
Attribute.GetAttributeFromName(CurrentDbContext, Framework.Properties.Resources.TaxonomyIdAttributeName,
true, AttributeTypeEnum.Sku, false),
Value = sch.TaxonomyID.ToString()
}
}
});
taxonomy.SkuInfos.Add(new SkuInfo(CurrentDbContext)
{
Sku = newSku
});
if (!success)
{
_warnings.Add(new WorkerWarning
{
LineData = currentRecord.ToString(),
ErrorMessage = Properties.Resources.EnrichmentImageFileNotPresentWarningMessage
});
}
}
if (!string.IsNullOrEmpty(currentRecord.DisplayOrder) && !int.TryParse(currentRecord.DisplayOrder, out displayOrder))
{
_warnings.Add(new WorkerWarning()
{
LineData = currentRecord.ToString(), ErrorMessage = Properties.Resources.DisplayOrderNotValidNumberWarningMessage
});
continue;
}
}
// if specific value record exists in this schema, get it, otherwise create it.
//var lov = sch.ListOfValues.FirstOrDefault(v => v.Value.ToLower() == currentRecord.Lov.ToLower() && v.Active);
if (lov == null)
{
if (CurrentImportOptions.HasFlag(ImportOptions.CreateMissingLOVs))
{
sch.ListOfValues.Add(entity: new ListOfValue(CurrentDbContext)
{
Value = currentRecord.Lov,
EnrichmentImage = enrichmentImageGuid,
EnrichmentCopy = currentRecord.EnrichmentCopy,
DisplayOrder = int.TryParse(currentRecord.DisplayOrder, out displayOrder) ? displayOrder : (int?)null,
CreatedOn = DateTime.Now,
CreatedBy = ImportRequestedBy
});
newValueCount++;
}
else
{
_warnings.Add(new WorkerWarning
{
LineData = currentRecord.ToString(),
ErrorMessage = Properties.Resources.CreateLovFlagOffWarningMessage
});
ProcessSummaryReport(0);
}
}
else
{
if (lov.Value == currentRecord.Lov && lov.EnrichmentCopy == currentRecord.EnrichmentCopy &&
lov.EnrichmentImage == currentRecord.EnrichmentImage && lov.DisplayOrder.ToString() == currentRecord.DisplayOrder)
{
ignoredCount++;
continue;
}
var updatedFlag = false;
if (!string.IsNullOrEmpty(enrichmentImageGuid))
{
lov.EnrichmentImage = enrichmentImageGuid;
updatedFlag = true;
}
if (!string.IsNullOrEmpty(currentRecord.EnrichmentCopy))
{
lov.EnrichmentCopy = currentRecord.EnrichmentCopy;
updatedFlag = true;
}
if (!string.IsNullOrEmpty(currentRecord.DisplayOrder))
{
lov.DisplayOrder = int.TryParse(currentRecord.DisplayOrder, out displayOrder)
? displayOrder
: (int?)null;
updatedFlag = true;
}
if (updatedFlag)
{
lov.CreatedBy = ImportRequestedBy;
updatedCount++;
lov.CreatedOn = DateTime.Now;
}
else
{
ignoredCount++;
}
}
}
SaveDataChanges();
ProcessSummaryReport(newValueCount, updatedCount, ignoredCount);
}
}
catch (IndexOutOfRangeException ex)
{
var newException = new Exception(Properties.Resources.InvalidRowInInputFileMessage, ex);
Summary.SetError(newException);
}
catch (Exception ex)
{
Summary.SetError(ex);
}
}
public virtual async Task <SchemaInfo> GetSchemaInfoAsync(SchemaInfoFilter filter = null)
{
if (filter == null)
{
filter = new SchemaInfoFilter();
}
this.FeedbackInfo("Getting schema info...");
DatabaseObjectType dbObjectType = filter.DatabaseObjectType;
SchemaInfo schemaInfo = new SchemaInfo();
using (DbConnection connection = this.CreateConnection())
{
if (this.NeedFetchObjects(DatabaseObjectType.UserDefinedType, filter.UserDefinedTypeNames, filter))
{
schemaInfo.UserDefinedTypes = await this.GetUserDefinedTypesAsync(connection, filter);
}
if (this.NeedFetchObjects(DatabaseObjectType.Function, filter.FunctionNames, filter))
{
schemaInfo.Functions = await this.GetFunctionsAsync(connection, filter);
}
if (this.NeedFetchObjects(DatabaseObjectType.Table, filter.TableNames, filter))
{
schemaInfo.Tables = await this.GetTablesAsync(connection, filter);
}
if (this.NeedFetchObjects(DatabaseObjectType.View, filter.ViewNames, filter))
{
schemaInfo.Views = await this.GetViewsAsync(connection, filter);
}
if (this.NeedFetchObjects(DatabaseObjectType.Procedure, filter.ProcedureNames, filter))
{
schemaInfo.Procedures = await this.GetProceduresAsync(connection, filter);
}
if (this.NeedFetchTableObjects(DatabaseObjectType.TableColumn, filter, null))
{
schemaInfo.TableColumns = await this.GetTableColumnsAsync(connection, filter);
}
if (this.NeedFetchTableObjects(DatabaseObjectType.TablePrimaryKey, filter, null))
{
schemaInfo.TablePrimaryKeys = await this.GetTablePrimaryKeysAsync(connection, filter);
}
if ((this.Option.SortObjectsByReference && schemaInfo.Tables.Count > 1) || this.NeedFetchTableObjects(DatabaseObjectType.TableForeignKey, filter, null))
{
schemaInfo.TableForeignKeys = await this.GetTableForeignKeysAsync(connection, filter);
}
if (this.NeedFetchTableObjects(DatabaseObjectType.TableIndex, filter, null))
{
schemaInfo.TableIndexes = await this.GetTableIndexesAsync(connection, filter, this.Option.IncludePrimaryKeyWhenGetTableIndex);
}
if (this.NeedFetchTableObjects(DatabaseObjectType.TableConstraint, filter, null))
{
schemaInfo.TableConstraints = await this.GetTableConstraintsAsync(connection, filter);
}
if (this.NeedFetchTableObjects(DatabaseObjectType.TableTrigger, filter, filter.TableTriggerNames))
{
schemaInfo.TableTriggers = await this.GetTableTriggersAsync(connection, filter);
}
}
if (this.Option.SortObjectsByReference)
{
if (schemaInfo.Tables.Count > 1)
{
schemaInfo.Tables = TableReferenceHelper.ResortTables(schemaInfo.Tables, schemaInfo.TableForeignKeys);
}
DbObjectHelper.Resort(schemaInfo.Views);
DbObjectHelper.Resort(schemaInfo.Functions);
DbObjectHelper.Resort(schemaInfo.Procedures);
}
this.FeedbackInfo("End get schema info.");
return(schemaInfo);
}
public DataSet GetUserPermissions(string userValue, string appCodeName, UserValueType userValueType, RightMaskType rightMask, DelegationMaskType delegationMask)
{
string[] schemaTypes = SchemaInfo.FilterByCategory("Roles").ToSchemaNames();
string[] userIDs = OGUReaderService.SplitObjectValues(userValue);
SCObjectAndRelationCollection users = OGUReaderService.GetSearchAdapter(GetSearchOUIDType(userValueType), SchemaInfo.FilterByCategory("Users").ToSchemaNames(), userIDs, false).QueryObjectsAndRelations();
SchemaObjectCollection roles = SCSnapshotAdapter.Instance.QueryUserBelongToPermissions(schemaTypes, appCodeName, users.ToIDArray(), false, DateTime.MinValue);
DataSet ds = new DataSet();
ds.Tables.Add(QueryHelper.GetAppObjectTableBuilder(schemaTypes).Convert(roles));
return(ds);
}
private void LoadDocumentType(IDtdInfo dtdInfo, XmlDocumentType dtNode)
{
SchemaInfo schInfo = dtdInfo as SchemaInfo;
if (schInfo == null)
{
throw new XmlException(ResXml.Xml_InternalError, string.Empty);
}
dtNode.DtdSchemaInfo = schInfo;
if (schInfo != null)
{
//set the schema information into the document
_doc.DtdSchemaInfo = schInfo;
// Notation hashtable
if (schInfo.Notations != null)
{
foreach (SchemaNotation scNot in schInfo.Notations.Values)
{
dtNode.Notations.SetNamedItem(new XmlNotation(scNot.Name.Name, scNot.Pubid, scNot.SystemLiteral, _doc));
}
}
// Entity hashtables
if (schInfo.GeneralEntities != null)
{
foreach (SchemaEntity scEnt in schInfo.GeneralEntities.Values)
{
XmlEntity ent = new XmlEntity(scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, _doc);
ent.SetBaseURI(scEnt.DeclaredURI);
dtNode.Entities.SetNamedItem(ent);
}
}
if (schInfo.ParameterEntities != null)
{
foreach (SchemaEntity scEnt in schInfo.ParameterEntities.Values)
{
XmlEntity ent = new XmlEntity(scEnt.Name.Name, scEnt.Text, scEnt.Pubid, scEnt.Url, scEnt.NData.IsEmpty ? null : scEnt.NData.Name, _doc);
ent.SetBaseURI(scEnt.DeclaredURI);
dtNode.Entities.SetNamedItem(ent);
}
}
_doc.Entities = dtNode.Entities;
//extract the elements which has attribute defined as ID from the element declarations
IDictionaryEnumerator elementDecls = schInfo.ElementDecls.GetEnumerator();
if (elementDecls != null)
{
elementDecls.Reset();
while (elementDecls.MoveNext())
{
SchemaElementDecl elementDecl = (SchemaElementDecl)elementDecls.Value;
if (elementDecl.AttDefs != null)
{
IDictionaryEnumerator attDefs = elementDecl.AttDefs.GetEnumerator();
while (attDefs.MoveNext())
{
SchemaAttDef attdef = (SchemaAttDef)attDefs.Value;
if (attdef.Datatype.TokenizedType == XmlTokenizedType.ID)
{
//we only register the XmlElement based on their Prefix/LocalName and skip the namespace
_doc.AddIdInfo(
_doc.AddXmlName(elementDecl.Prefix, elementDecl.Name.Name, string.Empty, null),
_doc.AddAttrXmlName(attdef.Prefix, attdef.Name.Name, string.Empty, null));
break;
}
}
}
}
}
}
}
public abstract IDataReader LoadMatchingPrimaryKeys(SchemaInfo schemaInfo, ClassInfo classInfo, SoodaWhereClause whereClause, SoodaOrderBy orderBy, int startIdx, int pageCount);
public void Compile(ValidationEventHandler validationEventHandler) {
SchemaInfo sInfo = new SchemaInfo();
sInfo.SchemaType = SchemaType.XSD;
CompileSchema(null, System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver(), sInfo, null, validationEventHandler, NameTable, false);
}
public abstract IDataReader LoadObjectList(SchemaInfo schemaInfo, ClassInfo classInfo, SoodaWhereClause whereClause, SoodaOrderBy orderBy, int startIdx, int pageCount, SoodaSnapshotOptions options, out TableInfo[] tables);
#pragma warning disable 618
internal bool CompileSchema(XmlSchemaCollection xsc, XmlResolver resolver, SchemaInfo schemaInfo, string ns, ValidationEventHandler validationEventHandler, XmlNameTable nameTable, bool CompileContentModel) {
//Need to lock here to prevent multi-threading problems when same schema is added to set and compiled
lock (this) {
//Preprocessing
SchemaCollectionPreprocessor prep = new SchemaCollectionPreprocessor(nameTable, null, validationEventHandler);
prep.XmlResolver = resolver;
if (!prep.Execute(this, ns, true, xsc)) {
return false;
}
//Compilation
SchemaCollectionCompiler compiler = new SchemaCollectionCompiler(nameTable, validationEventHandler);
isCompiled = compiler.Execute(this, schemaInfo, CompileContentModel);
this.SetIsCompiled(isCompiled);
//
return isCompiled;
}
}
public abstract IDataReader LoadRefObjectList(SchemaInfo schemaInfo, RelationInfo relationInfo, int masterColumn, object masterValue, out TableInfo[] tables);
public void Load(IDataReader dr, bool acceptChanges, ISchemaTableReader schemaReader)
{
if (null == schemaReader)
throw new ArgumentNullException("schemaReader");
this.schemaList.MakeMutable();
this.schemaList.Clear();
if (!this.records.IsReadOnly)
{
this.records.Clear();
this.records.MakeReadOnly();
}
this._template = null;
DataTable schemaTable = dr.GetSchemaTable();
if (null == schemaTable)
throw new NullReferenceException("Table Schema can not be read");
int fieldCount = dr.FieldCount;
if (fieldCount > schemaTable.Rows.Count)
throw new InvalidOperationException("Schema table does not contain all necessary fields");
bool containsIdentity = schemaTable.Columns.OfType<DataColumn>().FirstOrDefault(c => String.Equals("IsIdentity", c.ColumnName)) != null;
IEnumerable<DataRow> rows = schemaTable.Rows.OfType<DataRow>();
string[] columnNames = new string[fieldCount];
for (int j = 0; j < fieldCount; ++j)
{
string columnName = dr.GetName(j);
columnNames[j] = columnName;
DataRow schemaRow = rows.FirstOrDefault(r => String.Equals(columnName, (String)r["ColumnName"]));
if (schemaRow != null)
{
if (schemaReader.IsMapped(schemaRow))
{
SchemaInfo schema = new SchemaInfo(columnName);
schema.IsNullable = schemaReader.AllowDBNull(schemaRow);
schema.DataType = schemaReader.GetDataType(schemaRow);
schema.IsKey = schemaReader.IsKey(schemaRow);
schema.MaxLength = schemaReader.GetMaxLength(schemaRow);
schema.ReadOnly = schemaReader.IsReadOnly(schemaRow);
if (containsIdentity && schemaReader.IsIdentity(schemaRow))
schema.DatabaseGeneratedOption = StoreGeneratedPattern.Identity;
schema.Order = j;
this.schemaList.Add(schema);
}
}
else
throw new NotFoundException("Column not found; {0} ", columnName);
}
this.Init();//Hiç Kayıt Yoksa Template oluşturulmuyor.
while (dr.Read())
{
Record newRecord = this.NewRecordInternal();//Template Type oluşturuldu. SchemaInfoCollection ReadOnly
for (int j = 0; j < fieldCount; ++j)
{
object dbValue = dr[j];
if (dr.IsDBNull(j))
dbValue = null;
SchemaInfo schema = this.schemaList[j];
string columnName = schema.ColumnName;
ICell cell = newRecord.GetCell(ref columnName);
cell.SetValueUnsafe(dbValue);
//Yeni oluşan record. PropertyChanged e gerek yok.
}
this.SetRecordID(newRecord);
this.records.Add(newRecord);
}
if (acceptChanges)
this.AcceptChanges();
}
public abstract IDataReader ExecuteQuery(Sooda.QL.SoqlQueryExpression query, SchemaInfo schema, params object[] parameters);
// TODO: move this elsewhere
public static void CreateSystemSchema(this ITransaction transaction)
{
transaction.CreateSystem();
// TODO: get the configured default culture...
var culture = CultureInfo.CurrentCulture.Name;
var schemaInfo = new SchemaInfo(SystemSchema.Name, SchemaTypes.System);
schemaInfo.Culture = culture;
transaction.CreateSchema(schemaInfo);
}
public IDataReader ExecuteQuery(Sooda.QL.SoqlQueryExpression queryText, SchemaInfo schema, ArrayList parameters)
{
return(ExecuteQuery(queryText, schema, parameters.ToArray()));
}