internal FieldSignatureConverter(PEFileToObjectModel peFileToObjectModel, MetadataObject moduleField, MemoryReader signatureMemoryReader)
: base(peFileToObjectModel, signatureMemoryReader, moduleField)
{
//^ base;
//^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary.
this.FirstByte = this.SignatureMemoryReader.ReadByte();
if (!SignatureHeader.IsFieldSignature(this.FirstByte)) {
// Error...
}
bool isPinned;
this.customModifiers = this.GetCustomModifiers(out isPinned);
this.TypeReference = this.GetTypeReference();
}
internal static async Task ProcessAnnotationsFromData(CdmCorpusContext ctx, MetadataObject obj, CdmTraitCollection traits)
{
var multiTraitAnnotations = new List <Annotation>();
if (obj.Annotations != null)
{
foreach (var element in obj.Annotations)
{
if (!ShouldAnnotationGoIntoASingleTrait(element.Name))
{
multiTraitAnnotations.Add(element);
}
else
{
var innerTrait = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, ConvertAnnotationToTrait(element.Name));
innerTrait.Arguments.Add(await ArgumentPersistence.FromData(ctx, element));
traits.Add(innerTrait);
}
}
if (multiTraitAnnotations.Count > 0)
{
var trait = ctx.Corpus.MakeRef <CdmTraitReference>(CdmObjectType.TraitRef, "is.modelConversion.otherAnnotations", false);
trait.IsFromProperty = false;
var annotationsArgument = new CdmArgumentDefinition(ctx, "annotations")
{
Value = multiTraitAnnotations
};
trait.Arguments.Add(annotationsArgument);
traits.Add(trait);
}
}
if (obj.Traits != null)
{
foreach (var trait in obj.Traits)
{
var traitInstance = CdmFolder.TraitReferencePersistence.FromData(ctx, JToken.FromObject(trait));
traits.Add(traitInstance);
}
}
}
IEnumerator ApplyBingHeightmapV2(WWW metaReq, string key)
{
MetadataObject metadata = JsonConvert.DeserializeObject <MetadataObject>(metaReq.text);
List <double> bbox = metadata.resourceSets[0].resources[0].bbox;
string url = "http://dev.virtualearth.net/REST/v1/Elevation/Bounds?bounds=";
url += bbox[0] + "," + bbox[1] + "," + bbox[2] + "," + bbox[3];
int rows = 32;
url += "&rows=" + rows + "&cols=" + rows + "&heights=sealevel&key=" + key;
//max height point retrievable = 1024 = 32 * 32
WWW elevReq = new WWW(url);
yield return(elevReq);
ElevDataObject elevData = JsonConvert.DeserializeObject <ElevDataObject> (elevReq.text);
List <int> elevations = elevData.resourceSets[0].resources[0].elevations; //elevations at sea level in meters
TerrainData terrain = GetComponent <Terrain> ().terrainData;
int width = (terrain.heightmapWidth - 1) * 3;
float[,] heightmapData = new float[width, width]; //terrain.GetHeights(0, 0, width, width);
if (width % rows == 0)
{
heightmapData = ApplyElevationsToHeightmap(elevations, heightmapData, width);
heightmapData = Smooth(heightmapData, smoothings * 2, neighbors * 2, width);
float[] coordinates = new float[2];
coordinates[0] = float.Parse(metadata.resourceSets[0].resources[0].mapCenter.coordinates[0]);
coordinates[1] = float.Parse(metadata.resourceSets[0].resources[0].mapCenter.coordinates[1]);
GameControl.control.SetCurrentHeightmapData(heightmapData, centerLocation.zoom, coordinates);
GameControl.control.SaveAsCurrent();
}
else
{
Debug.Log("Something went wrong: size of terrain is not processable for heightmap generation");
}
}
public DmlSqlGenerator(QueryBuilder queryBuilder, ISqlSyntaxOverride syntaxOverride)
{
_syntaxOverride = syntaxOverride;
_sqlGenerationOptions = queryBuilder.SQLContext.SQLGenerationOptionsForServer;
_outputColumns = queryBuilder.QueryStatistics.OutputColumns;
if (queryBuilder.SQLQuery.QueryRoot.IsQueryWithUnions())
{
throw new Exception("Not editable query");
}
var metadataObjectsList = _outputColumns
.Select(outputColumn => outputColumn.MetadataObject)
.Where(metadataObject => metadataObject != null)
.Distinct();
_selectedMetadataObject = GetSelectedObject(metadataObjectsList);
if (_selectedMetadataObject == null)
{
throw new Exception("Not editable query");
}
}
public override Partition Clone(string newName = null, Table newParent = null)
{
if (!Handler.PowerBIGovernance.AllowCreate(typeof(Partition)))
{
throw new InvalidOperationException(string.Format(Messages.CannotCreatePowerBIObject, typeof(Partition).GetTypeName()));
}
Handler.BeginUpdate("Clone Partition");
// Create a clone of the underlying metadataobject:
var tom = MetadataObject.Clone() as TOM.Partition;
// Assign a new, unique name:
tom.Name = Parent.Partitions.GetNewName(string.IsNullOrEmpty(newName) ? tom.Name + " copy" : newName);
// Create the TOM Wrapper object, representing the metadataobject
MPartition obj = CreateFromMetadata(newParent ?? Parent, tom);
Handler.EndUpdate();
return(obj);
}
private static MessageProducerSettings CreateProducerSettings(InfoBase infoBase, IMetadataService metadataService)
{
MessageProducerSettings settings = new MessageProducerSettings();
MetadataObject metaObject = infoBase.InformationRegisters.Values.Where(с => с.Name == PRODUCER_TABLE_QUEUE_NAME).FirstOrDefault();
if (metaObject == null)
{
return(settings);
}
metadataService.EnrichFromDatabase(metaObject);
settings.DatabaseSettings = new Producer.DatabaseSettings()
{
DatabaseProvider = metadataService.DatabaseProvider,
ConnectionString = metadataService.ConnectionString,
DatabaseQueue = new Producer.DatabaseQueue()
{
TableName = metaObject.TableName,
ObjectName = string.Format("{0}.{1}", METAOBJECT_BASE_NAME, PRODUCER_TABLE_QUEUE_NAME)
}
};
foreach (MetadataProperty property in metaObject.Properties)
{
foreach (DatabaseField field in property.Fields)
{
settings.DatabaseSettings.DatabaseQueue.Fields.Add(new Producer.TableField()
{
Name = field.Name,
Property = property.Name
});
}
}
return(settings);
}
private void listBox1_MouseMove(object sender, MouseEventArgs e)
{
// Do drag:
if (listBox1.SelectedIndex != -1)
{
if ((e.Button & MouseButtons.Left) == MouseButtons.Left)
{
if (_dragBoxFromMouseDown != Rectangle.Empty && !_dragBoxFromMouseDown.Contains(e.X, e.Y))
{
string objectName = (string)listBox1.SelectedItem;
MetadataObject metadataObject = queryBuilder1.MetadataContainer.FindItem <MetadataObject>(objectName);
if (metadataObject != null)
{
MetadataDragObject dragObject = new MetadataDragObject();
dragObject.MetadataDragged.Add(metadataObject);
listBox1.DoDragDrop(dragObject, DragDropEffects.Copy);
}
}
}
}
}
// Caller should lock this...
internal IMethodReference GetMethodReferenceForToken(
MetadataObject owningObject,
uint methodRefToken
) {
uint tokenKind = methodRefToken & TokenTypeIds.TokenTypeMask;
uint rowId = methodRefToken & TokenTypeIds.RIDMask;
IMethodReference/*?*/ methRef = null;
switch (tokenKind) {
case TokenTypeIds.MethodDef:
methRef = this.GetMethodDefAtRow(rowId);
break;
case TokenTypeIds.MethodSpec:
methRef = this.GetMethodSpecAtRow(owningObject, rowId);
break;
case TokenTypeIds.MemberRef:
methRef = this.GetModuleMemberReferenceAtRow(owningObject, rowId) as IMethodReference;
break;
}
if (methRef == null) {
// Error...
methRef = Dummy.MethodReference;
}
return methRef;
}
internal ITypeMemberReference/*?*/ GetModuleMemberReferenceAtRow(
MetadataObject owningObject,
uint memberRefRowId
) {
if (memberRefRowId == 0 || memberRefRowId > this.PEFileReader.MemberRefTable.NumberOfRows) {
return null;
}
if (this.ModuleMemberReferenceArray[memberRefRowId] == null) {
lock (GlobalLock.LockingObject) {
//The same memberRef token can sometimes be shared by references that are distinct in the object model.
//Hence the worker decides whether to cache or not.
return this.GetModuleMemberReferenceAtRowWorker(owningObject, memberRefRowId);
}
}
MemberReference/*?*/ ret = this.ModuleMemberReferenceArray[memberRefRowId];
return ret;
}
internal IMarshallingInformation GetMarshallingInformation(
MetadataObject metadataObject
) {
uint fieldMarshalRowId = this.PEFileReader.FieldMarshalTable.GetFieldMarshalRowId(metadataObject.TokenValue);
if (fieldMarshalRowId == 0)
return Dummy.MarshallingInformation;
FieldMarshalRow fieldMarshalRow = this.PEFileReader.FieldMarshalTable[fieldMarshalRowId];
MemoryBlock fieldMarshalMemoryBlock = this.PEFileReader.BlobStream.GetMemoryBlockAt(fieldMarshalRow.NativeType);
MemoryReader memoryReader = new MemoryReader(fieldMarshalMemoryBlock);
System.Runtime.InteropServices.UnmanagedType unmanagedType = (System.Runtime.InteropServices.UnmanagedType)memoryReader.ReadByte();
if (memoryReader.NotEndOfBytes) {
if (unmanagedType == System.Runtime.InteropServices.UnmanagedType.ByValArray) {
uint numElements = (uint)memoryReader.ReadCompressedUInt32();
System.Runtime.InteropServices.UnmanagedType elementType = System.Runtime.InteropServices.UnmanagedType.AsAny;
if (memoryReader.NotEndOfBytes)
elementType = (System.Runtime.InteropServices.UnmanagedType)memoryReader.ReadByte();
return new ByValArrayMarshallingInformation(elementType, numElements);
} else if (unmanagedType == System.Runtime.InteropServices.UnmanagedType.CustomMarshaler) {
string marshallerName;
string marshallerArgument;
memoryReader.ReadInt16(); // Deliberate Skip...
int byteLen = memoryReader.ReadCompressedUInt32();
if (byteLen == -1 || byteLen == 0)
marshallerName = string.Empty;
else
marshallerName = memoryReader.ReadUTF8WithSize(byteLen);
ITypeReference/*?*/ marshaller = this.GetSerializedTypeNameAsTypeReference(marshallerName);
if (marshaller == null) marshaller = Dummy.TypeReference;
byteLen = memoryReader.ReadCompressedUInt32();
if (byteLen == -1 || byteLen == 0)
marshallerArgument = string.Empty;
else
marshallerArgument = memoryReader.ReadUTF8WithSize(byteLen);
return new CustomMarshallingInformation(marshaller, marshallerArgument);
} else if (unmanagedType == System.Runtime.InteropServices.UnmanagedType.LPArray) {
System.Runtime.InteropServices.UnmanagedType elementType = (System.Runtime.InteropServices.UnmanagedType)memoryReader.ReadByte();
int paramIndex = -1;
uint flag = 0;
uint numElements = 0;
if (memoryReader.NotEndOfBytes)
paramIndex = (int)memoryReader.ReadCompressedUInt32();
if (memoryReader.NotEndOfBytes)
numElements = (uint)memoryReader.ReadCompressedUInt32();
if (memoryReader.NotEndOfBytes) {
flag = (uint)memoryReader.ReadCompressedUInt32();
if (flag == 0) {
//TODO: check that paramIndex is 0
paramIndex = -1; //paramIndex is just a place holder so that numElements can be present
}
}
return new LPArrayMarshallingInformation(elementType, paramIndex, numElements);
} else if (unmanagedType == System.Runtime.InteropServices.UnmanagedType.SafeArray) {
System.Runtime.InteropServices.VarEnum elementType = (System.Runtime.InteropServices.VarEnum)memoryReader.ReadByte();
string subType = string.Empty;
if (memoryReader.NotEndOfBytes) {
int byteLen = memoryReader.ReadCompressedUInt32();
if (byteLen > 0)
subType = memoryReader.ReadUTF8WithSize(byteLen);
}
ITypeReference/*?*/ subTypeRef = this.GetSerializedTypeNameAsTypeReference(subType);
if (subTypeRef == null) subTypeRef = Dummy.TypeReference;
return new SafeArrayMarshallingInformation(elementType, subTypeRef);
} else if (unmanagedType == System.Runtime.InteropServices.UnmanagedType.ByValTStr) {
uint numElements = (uint)memoryReader.ReadCompressedUInt32();
return new ByValTStrMarshallingInformation(numElements);
} else if (unmanagedType == System.Runtime.InteropServices.UnmanagedType.Interface) {
uint iidParameterIndex = (uint)memoryReader.ReadCompressedUInt32();
return new IidParameterIndexMarshallingInformation(iidParameterIndex);
} else {
//TODO: error blob should not have extra info unless one of the above types.
}
}
return new SimpleMarshallingInformation(unmanagedType);
}
internal ITypeReference/*?*/ GetTypeReferenceForToken(
MetadataObject owningObject,
uint token,
bool mustBeStruct
) {
uint tokenType = token & TokenTypeIds.TokenTypeMask;
uint rowId = token & TokenTypeIds.RIDMask;
switch (tokenType) {
case TokenTypeIds.TypeDef: {
if (rowId == 0 || rowId > this.PEFileReader.TypeDefTable.NumberOfRows) {
// handle Error
}
return this.GetTypeDefinitionAtRow(rowId);
}
case TokenTypeIds.TypeRef: {
if (rowId == 0 || rowId > this.PEFileReader.TypeRefTable.NumberOfRows) {
// handle Error
}
return this.GetTypeRefReferenceAtRow(rowId, mustBeStruct);
}
case TokenTypeIds.TypeSpec: {
if (rowId == 0 || rowId > this.PEFileReader.TypeSpecTable.NumberOfRows) {
// handle Error
}
return this.GetTypeSpecReferenceAtRow(owningObject, rowId).UnderlyingModuleTypeReference;
}
}
return null;
}
internal TypeSpecReference/*?*/ GetTypeSpecReferenceAtRow(
MetadataObject owningObject,
uint typeSpecRowId
)
//^ requires this.PEFileReader.TypeSpecTable.NumberOfRows >= 1;
//^ requires typeSpecRowId >= 1 && typeSpecRowId <= this.PEFileReader.TypeSpecTable.NumberOfRows;
{
if (typeSpecRowId > this.PEFileReader.TypeSpecTable.NumberOfRows || typeSpecRowId == 0) {
return null;
}
uint ownerId = owningObject.TokenValue;
//^ assert this.ModuleTypeSpecHashtable != null;
TypeSpecReference/*?*/ typeSpecReference = this.ModuleTypeSpecHashtable.Find(ownerId, typeSpecRowId);
if (typeSpecReference == null) {
lock (GlobalLock.LockingObject) {
typeSpecReference = this.ModuleTypeSpecHashtable.Find(ownerId, typeSpecRowId);
if (typeSpecReference == null) {
typeSpecReference = new TypeSpecReference(this, typeSpecRowId, owningObject);
}
this.ModuleTypeSpecHashtable.Add(ownerId, typeSpecRowId, typeSpecReference);
}
}
return typeSpecReference;
}
private bool IsObjectHavePrimaryKey(MetadataObject metadataObject) => metadataObject.Items.Fields.Any(field => field.PrimaryKey);
internal ISecurityAttribute GetSecurityAttributeAtRow(
MetadataObject owningObject,
uint securityAttributeRowId
) {
if (securityAttributeRowId >= this.DeclSecurityArray.Length) {
// MD Error
return Dummy.SecurityAttribute;
}
if (this.DeclSecurityArray[securityAttributeRowId] == null) {
lock (GlobalLock.LockingObject) {
if (this.DeclSecurityArray[securityAttributeRowId] == null) {
DeclSecurityRow declSecurity = this.PEFileReader.DeclSecurityTable[securityAttributeRowId];
if (declSecurity.Parent == owningObject.TokenValue) {
this.DeclSecurityArray[securityAttributeRowId] = new SecurityAttribute(this, securityAttributeRowId, (SecurityAction)declSecurity.ActionFlags);
} else {
// MD Error
this.DeclSecurityArray[securityAttributeRowId] = Dummy.SecurityAttribute;
}
}
}
}
ISecurityAttribute/*?*/ ret = this.DeclSecurityArray[securityAttributeRowId];
//^ assert ret != null;
return ret;
}
// HOWTO: Fill metadata container with custom objects
public void FillMetadataContainer()
{
MetadataNamespace database = _query.SQLContext.MetadataContainer.AddDatabase("MyDB");
database.Default = true; // hides the default database prefix from object names
MetadataNamespace schema = database.AddSchema("MySchema");
schema.Default = true; // hides the default schema prefix from object names
// create table
MetadataObject tableOrders = schema.AddTable("Orders");
tableOrders.AddField("OrderID");
tableOrders.AddField("OrderDate");
tableOrders.AddField("City");
tableOrders.AddField("CustomerID");
tableOrders.AddField("ResellerID");
// create another table
MetadataObject tableCustomers = schema.AddTable("Customers");
tableCustomers.AddField("CustomerID");
tableCustomers.AddField("CustomerName");
tableCustomers.AddField("CustomerAddress");
MetadataField fieldCustValue = tableCustomers.AddField("CustomerValue");
fieldCustValue.FieldType = System.Data.DbType.Double;
MetadataField fieldCustBirthDate = tableCustomers.AddField("CustomerBirthDay");
fieldCustBirthDate.FieldType = System.Data.DbType.DateTime;
MetadataField fieldCustCity = tableCustomers.AddField("City");
fieldCustCity.FieldType = System.Data.DbType.String;
fieldCustCity.Size = 50;
// add a relation between these two tables
MetadataForeignKey relation = tableCustomers.AddForeignKey("FK_CustomerID");
relation.Fields.Add("CustomerID");
relation.ReferencedObjectName = tableOrders.GetQualifiedName();
relation.ReferencedFields.Add("CustomerID");
// create another table
MetadataObject salesOrderHeader = schema.AddTable("SalesOrderHeader");
salesOrderHeader.AddField("SalesOrderID");
salesOrderHeader.AddField("OrderDate");
// create another table
MetadataObject salesOrderDetail = schema.AddTable("SalesOrderDetail");
salesOrderDetail.AddField("SalesOrderID");
salesOrderDetail.AddField("UnitPrice");
//create a view
MetadataObject viewResellers = schema.AddView("Resellers");
viewResellers.AddField("ResellerID");
viewResellers.AddField("ResellerName");
}
private MetadataObject ParseObject(IEnumerable <XElement> elements, XElement element)
{
// Parse name of the object.
XAttribute nameAttribute = element.Attribute(NAME_ATTRIB);
// Check for nulls.
ValidateAttribute(element, nameAttribute, NAME_ATTRIB, TYPENAME_STRING);
// Get the name of this object.
string objectsName = nameAttribute.Value;
// Parse all fields.
IEnumerable <XElement> fieldElements = element.Descendants(FIELD_ATTRIB);
MetadataField[] objectsFields = new MetadataField[fieldElements.Count()];
// Field index.
int i = 0;
foreach (XElement fieldElement in fieldElements)
{
// Find field attributes.
XAttribute fieldNameAttribute = fieldElement.Attribute(NAME_ATTRIB);
XAttribute fieldTypeAttribute = fieldElement.Attribute(TYPE_ATTRIB);
XAttribute fieldValueAttribute = fieldElement.Attribute(VALUE_ATTRIB);
// Check that name and type are not null. Value can be null (default).
ValidateAttribute(fieldElement, fieldNameAttribute, NAME_ATTRIB, TYPENAME_STRING);
ValidateAttribute(fieldElement, fieldTypeAttribute, TYPE_ATTRIB, TYPENAME_STRING);
// Get field values.
string fieldName = fieldNameAttribute.Value;
string fieldType = fieldTypeAttribute.Value;
string fieldStringValue = fieldValueAttribute == null || string.IsNullOrEmpty(fieldValueAttribute.Value) ? string.Empty : fieldValueAttribute.Value;
// Check if we already have field with same name.
for (int j = 0; j < i; j++)
{
if (objectsFields[j].Name == fieldName)
{
throw MetadataParserException.FieldNameCollision(objectsName, fieldName);
}
}
// If type is primitive type, just parse it.
if (IsPrimitiveType(fieldType))
{
// Try to parse a primitive type from the string.
// TODO: it should be damn fast but is it clean?
object fieldValue = null;
// Parse primitive.
if (fieldType == TYPENAME_STRING)
{
// Get string value.
fieldValue = fieldStringValue;
}
if (fieldType == TYPENAME_INT)
{
// Try to get int value.
int num = 0;
if (!int.TryParse(fieldStringValue, out num))
{
throw MetadataParserException.InvalidValue(fieldStringValue, TYPENAME_INT, fieldElement.ToString());
}
fieldValue = num;
}
else if (fieldType == TYPENAME_BOOL)
{
// Try to get bool value.
bool state = false;
if (!bool.TryParse(fieldStringValue, out state))
{
throw MetadataParserException.InvalidValue(fieldStringValue, TYPENAME_BOOL, fieldElement.ToString());
}
fieldValue = state;
}
else if (fieldType == TYPENAME_BYTE)
{
// Try to get byte value.
byte num = 0;
if (!byte.TryParse(fieldStringValue, out num))
{
throw MetadataParserException.InvalidValue(fieldStringValue, TYPENAME_BYTE, fieldElement.ToString());
}
fieldValue = num;
}
else if (fieldType == TYPENAME_FLOAT)
{
// Try to get float value.
float num = 0.0f;
if (!float.TryParse(fieldStringValue, out num))
{
throw MetadataParserException.InvalidValue(fieldStringValue, TYPENAME_FLOAT, fieldElement.ToString());
}
fieldValue = num;
}
objectsFields[i] = new MetadataField(fieldName, fieldValue);
}
else if (IsCustomObject(fieldType))
{
// Check if type is custom object type.
IEnumerable <XElement> possibleChilds = elements.Where(e => e.HasAttributes)
.Where(e => e.Attribute(NAME_ATTRIB) != null);
XElement child = possibleChilds.FirstOrDefault(e => e.Attribute(NAME_ATTRIB).Value == fieldStringValue);
// Got child, parse it and set field value to it.
if (child != null)
{
MetadataObject metadataObject = ParseObject(elements, child);
objectsFields[i] = new MetadataField(fieldName, metadataObject);
}
else
{
// Not a custom type, throw exception.
throw new InvalidOperationException("Type must be a primitive or custom type.");
}
}
i++;
}
return(new MetadataObject(objectsName, objectsFields));
}
public void Enrich(MetadataObject metadataObject)
{
if (!(metadataObject is AccumulationRegister register))
{
throw new ArgumentOutOfRangeException();
}
ConfigObject configObject = Configurator.FileReader.ReadConfigObject(register.FileName.ToString());
register.Name = configObject.GetString(new int[] { 1, 13, 1, 2 });
ConfigObject alias = configObject.GetObject(new int[] { 1, 13, 1, 3 });
if (alias.Values.Count == 3)
{
register.Alias = configObject.GetString(new int[] { 1, 13, 1, 3, 2 });
}
register.UseSplitter = configObject.GetInt32(new int[] { 1, 20 }) == 1;
register.RegisterKind = (RegisterKind)configObject.GetInt32(new int[] { 1, 15 });
Configurator.ConfigurePropertyПериод(register);
Configurator.ConfigurePropertyНомерЗаписи(register);
Configurator.ConfigurePropertyАктивность(register);
if (register.RegisterKind == RegisterKind.Balance)
{
Configurator.ConfigurePropertyВидДвижения(register);
}
// 7 - коллекция измерений
ConfigObject properties = configObject.GetObject(new int[] { 7 });
// 7.0 = b64d9a43-1642-11d6-a3c7-0050bae0a776 - идентификатор коллекции измерений
Guid propertiesUuid = configObject.GetUuid(new int[] { 7, 0 });
if (propertiesUuid == new Guid("b64d9a43-1642-11d6-a3c7-0050bae0a776"))
{
Configurator.ConfigureProperties(register, properties, PropertyPurpose.Dimension);
}
// TODO: ???
// Configurator.ConfigurePropertyDimHash(register);
// Справка 1С: Хеш-функция измерений.
// Поле присутствует, если количество измерений не позволяет организовать уникальный индекс по измерениям.
// 5 - коллекция ресурсов
properties = configObject.GetObject(new int[] { 5 });
// 5.0 = b64d9a41-1642-11d6-a3c7-0050bae0a776 - идентификатор коллекции ресурсов
propertiesUuid = configObject.GetUuid(new int[] { 5, 0 });
if (propertiesUuid == new Guid("b64d9a41-1642-11d6-a3c7-0050bae0a776"))
{
Configurator.ConfigureProperties(register, properties, PropertyPurpose.Measure);
}
// 6 - коллекция реквизитов
properties = configObject.GetObject(new int[] { 6 });
// 6.0 = b64d9a42-1642-11d6-a3c7-0050bae0a776 - идентификатор коллекции реквизитов
propertiesUuid = configObject.GetUuid(new int[] { 6, 0 });
if (propertiesUuid == new Guid("b64d9a42-1642-11d6-a3c7-0050bae0a776"))
{
Configurator.ConfigureProperties(register, properties, PropertyPurpose.Property);
}
Configurator.ConfigureSharedProperties(register);
}
public void Enrich(MetadataObject metadataObject)
{
if (!(metadataObject is Document document))
{
throw new ArgumentOutOfRangeException();
}
ConfigObject configObject = Configurator.FileReader.ReadConfigObject(document.FileName.ToString());
document.Uuid = configObject.GetUuid(new int[] { 1, 3 });
document.Name = configObject.GetString(new int[] { 1, 9, 1, 2 });
ConfigObject alias = configObject.GetObject(new int[] { 1, 9, 1, 3 });
if (alias.Values.Count == 3)
{
document.Alias = configObject.GetString(new int[] { 1, 9, 1, 3, 2 });
}
document.NumberType = (NumberType)configObject.GetInt32(new int[] { 1, 11 });
document.NumberLength = configObject.GetInt32(new int[] { 1, 12 });
document.Periodicity = (Periodicity)configObject.GetInt32(new int[] { 1, 13 });
Configurator.ConfigurePropertyСсылка(document);
Configurator.ConfigurePropertyВерсияДанных(document);
Configurator.ConfigurePropertyПометкаУдаления(document);
Configurator.ConfigurePropertyДата(document);
if (document.NumberLength > 0)
{
if (document.Periodicity != Periodicity.None)
{
Configurator.ConfigurePropertyПериодичность(document);
}
Configurator.ConfigurePropertyНомер(document);
}
Configurator.ConfigurePropertyПроведён(document);
ConfigObject registers = configObject.GetObject(new int[] { 1, 24 });
Configurator.ConfigureRegistersToPost(document, registers);
// 5 - коллекция реквизитов
ConfigObject properties = configObject.GetObject(new int[] { 5 });
// 5.0 = 45e46cbc-3e24-4165-8b7b-cc98a6f80211 - идентификатор коллекции реквизитов
Guid propertiesUuid = configObject.GetUuid(new int[] { 5, 0 });
if (propertiesUuid == new Guid("45e46cbc-3e24-4165-8b7b-cc98a6f80211"))
{
Configurator.ConfigureProperties(document, properties, PropertyPurpose.Property);
}
Configurator.ConfigureSharedProperties(document);
// 3 - коллекция табличных частей справочника
ConfigObject tableParts = configObject.GetObject(new int[] { 3 });
// 3.0 = 21c53e09-8950-4b5e-a6a0-1054f1bbc274 - идентификатор коллекции табличных частей
Guid collectionUuid = configObject.GetUuid(new int[] { 3, 0 });
if (collectionUuid == new Guid("21c53e09-8950-4b5e-a6a0-1054f1bbc274"))
{
Configurator.ConfigureTableParts(document, tableParts);
}
}
} //end method
private void LoadUltraLiteSchemaTree()
{
queryBuilder.MetadataContainer.BeginUpdate();
MetadataItem schemaRoot = null;
PFDataAccessObjects.PFDatabase db = null;
try
{
queryBuilder.MetadataContainer.Items.Clear();
queryBuilder.InitializeDatabaseSchemaTree();
if (queryBuilder.MetadataContainer.Items.Count == 1)
{
schemaRoot = queryBuilder.MetadataContainer.Items[0];
}
else
{
schemaRoot = queryBuilder.MetadataContainer.AddDatabase("UltraLiteDb");
}
//MetadataObject table = queryBuilder.MetadataContainer.AddTable("TestTable");
//MetadataObject table = schemaRoot.AddTable("TestTable");
//get list of tables and add them to the schema tree
db = new PFDataAccessObjects.PFDatabase(PFDataAccessObjects.DatabasePlatform.SQLAnywhereUltraLite);
db.ConnectionString = this.ConnectionString;
db.OpenConnection();
DataTable datatableList = db.Connection.GetSchema(ULMetaDataCollectionNames.Tables);
foreach (DataRow row in datatableList.Rows)
{
string tableName = row["table_name"].ToString();
MetadataObject table = schemaRoot.AddTable(tableName);
string sql = "select * from " + tableName + " where 0=1";
Console.WriteLine(sql);
DataTable columnList = db.RunQueryDataTable(sql, CommandType.Text);
foreach (DataColumn col in columnList.Columns)
{
MetadataField metadataField = table.AddField(col.ColumnName);
// setup field
metadataField.FieldType = TypeToDbType(col.DataType);
metadataField.Nullable = col.AllowDBNull;
metadataField.ReadOnly = col.ReadOnly;
if (col.MaxLength != -1)
{
metadataField.Size = col.MaxLength;
}
// detect the field is primary key
foreach (DataColumn pkColumn in columnList.PrimaryKey)
{
if (col == pkColumn)
{
metadataField.PrimaryKey = true;
}
}
}
//close and reopen connection to free up space used by temp tables in the UL .NET provider
db.CloseConnection();
db.OpenConnection();
}
//MetadataField field = table.AddField("Fld1");
//field.FieldTypeName = "nvarchar";
//field.Size = 30;
//field = table.AddField("Fld2");
//field.FieldTypeName = "int";
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Attempt to load UltraLite Schema Tree failed.");
_msg.Append(Environment.NewLine);
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
if (db != null)
{
db.Connection.Close();
if (db.IsConnected)
{
db.CloseConnection();
}
}
db = null;
queryBuilder.MetadataContainer.EndUpdate();
}
queryBuilder.DatabaseSchemaTreeOptions.DefaultExpandLevel = 1;
queryBuilder.InitializeDatabaseSchemaTree();
}
private LocalizedName CreateLocalizedName(MetadataObject metadataObject, Culture culture, string text)
{
return(LocalizedName.NewObject(text, culture, metadataObject));
}
// Caller must lock this...
internal object/*?*/ GetReferenceForToken(
MetadataObject owningObject,
uint token
) {
uint tokenKind = token & TokenTypeIds.TokenTypeMask;
uint rowId = token & TokenTypeIds.RIDMask;
switch (tokenKind) {
case TokenTypeIds.TypeDef: {
if (rowId == 0 || rowId > this.PEFileReader.TypeDefTable.NumberOfRows) {
// handle Error
return null;
}
return this.GetTypeDefinitionAtRow(rowId);
}
case TokenTypeIds.TypeRef: {
if (rowId == 0 || rowId > this.PEFileReader.TypeRefTable.NumberOfRows) {
// handle Error
return null;
}
return this.GetTypeRefReferenceAtRow(rowId);
}
case TokenTypeIds.TypeSpec: {
if (rowId == 0 || rowId > this.PEFileReader.TypeSpecTable.NumberOfRows) {
// handle Error
return null;
}
return this.GetTypeSpecReferenceAtRow(owningObject, rowId).UnderlyingModuleTypeReference;
}
case TokenTypeIds.MethodDef:
if (rowId == 0 || rowId > this.PEFileReader.MethodTable.NumberOfRows) {
// handle Error
return null;
}
return this.GetMethodDefAtRow(rowId);
case TokenTypeIds.FieldDef:
if (rowId == 0 || rowId > this.PEFileReader.FieldTable.NumberOfRows) {
// handle Error
return null;
}
return this.GetFieldDefAtRow(rowId);
case TokenTypeIds.MemberRef:
if (rowId == 0 || rowId > this.PEFileReader.MemberRefTable.NumberOfRows) {
// handle Error
return null;
}
return this.GetModuleMemberReferenceAtRow(owningObject, rowId);
case TokenTypeIds.MethodSpec:
if (rowId == 0 || rowId > this.PEFileReader.MethodSpecTable.NumberOfRows) {
// handle Error
return null;
}
return this.GetMethodSpecAtRow(owningObject, rowId);
default:
return null;
}
}
internal ICustomAttribute GetCustomAttributeAtRow(
MetadataObject owningObject,
uint token,
uint customAttributeRowId
) {
if (customAttributeRowId == 0 || customAttributeRowId > this.PEFileReader.CustomAttributeTable.NumberOfRows) {
// MD Error
return Dummy.CustomAttribute;
}
if (this.CustomAttributeArray[customAttributeRowId] == null) {
lock (GlobalLock.LockingObject) {
if (this.CustomAttributeArray[customAttributeRowId] == null) {
CustomAttributeRow customAttribute = this.PEFileReader.CustomAttributeTable[customAttributeRowId];
if (customAttribute.Parent == token || (customAttribute.Parent == 1 && token == TokenTypeIds.Assembly+1)) {
uint ctorTokenType = customAttribute.Type & TokenTypeIds.TokenTypeMask;
uint ctorRowId = customAttribute.Type & TokenTypeIds.RIDMask;
IMethodReference/*?*/ moduleMethodReference = null;
if (ctorTokenType == TokenTypeIds.MethodDef) {
moduleMethodReference = this.GetMethodDefAtRow(ctorRowId);
} else if (ctorTokenType == TokenTypeIds.MemberRef) {
moduleMethodReference = this.GetModuleMemberReferenceAtRow(owningObject, ctorRowId) as IMethodReference;
}
if (moduleMethodReference == null) {
// TODO: MDError
this.CustomAttributeArray[customAttributeRowId] = Dummy.CustomAttribute;
return Dummy.CustomAttribute;
}
this.currentOwningObject = owningObject;
if (customAttribute.Value == 0) {
this.CustomAttributeArray[customAttributeRowId] =
this.ModuleReader.metadataReaderHost.Rewrite(this.Module, new CustomAttribute(this, customAttributeRowId, moduleMethodReference, null, null));
} else {
// TODO: Check if customAttribute.Value is within the range
MemoryBlock signatureMemoryBlock = this.PEFileReader.BlobStream.GetMemoryBlockAt(customAttribute.Value);
// TODO: Error checking enough space in signature memoryBlock.
MemoryReader memoryReader = new MemoryReader(signatureMemoryBlock);
this.ModuleReader.metadataReaderHost.StartGuessingGame();
CustomAttributeDecoder customAttrDecoder = new CustomAttributeDecoder(this, memoryReader, customAttributeRowId, moduleMethodReference);
while (customAttrDecoder.decodeFailed && this.ModuleReader.metadataReaderHost.TryNextPermutation())
customAttrDecoder = new CustomAttributeDecoder(this, memoryReader, customAttributeRowId, moduleMethodReference);
if (!customAttrDecoder.decodeFailed)
this.ModuleReader.metadataReaderHost.WinGuessingGame();
//else
//TODO: error
this.CustomAttributeArray[customAttributeRowId] = customAttrDecoder.CustomAttribute;
}
} else {
// MD Error
this.CustomAttributeArray[customAttributeRowId] = Dummy.CustomAttribute;
}
}
}
}
ICustomAttribute/*?*/ ret = this.CustomAttributeArray[customAttributeRowId];
//^ assert ret != null;
return ret;
}
public IEnumerator saveCachedHeighmaps(Vector3 cellSize, Vector3 center)
{
for (int i = 0; i < 9; i++)
{
cachedHeightmaps.Add(GetCachedHMIndex(center, cellSize, i), new float[size, size]);
}
Debug.Log("started");
string url;
if (firstRequest)
{
url = GetUrlMetadata();
}
else
{
url = GetBaseImageryUrl();
url += imSet + "?";
url += "mapArea=" + GetBBoxString(cellSize, center);
url += "&mapSize=" + size + "," + size;
url += "&mapMetadata=1&key=" + key;
}
WWW metaReq = new WWW(url);
yield return(metaReq);
MetadataObject metadata = JsonConvert.DeserializeObject <MetadataObject>(metaReq.text);
if (firstRequest)
{
firstRequest = false;
firstSpawnPoint = new Vector3(center.x + cellSize.x, center.y, center.z + cellSize.z);
firstBbox = metadata.resourceSets[0].resources[0].bbox;
realGPSSize = firstBbox[3] - firstBbox[1]; //east - west
}
List <double> bbox = metadata.resourceSets[0].resources[0].bbox;
url = "http://dev.virtualearth.net/REST/v1/Elevation/Bounds?bounds=";
url += bbox[0] + "," + bbox[1] + "," + bbox[2] + "," + bbox[3];
int rows = 32;
url += "&rows=" + rows + "&cols=" + rows + "&heights=sealevel&key=" + key;
//max height point retrievable = 1024 = 32 * 32
WWW elevReq = new WWW(url);
yield return(elevReq);
ElevDataObject elevData = JsonConvert.DeserializeObject <ElevDataObject> (elevReq.text);
List <int> elevations = elevData.resourceSets[0].resources[0].elevations; //elevations at sea level in meters
//TerrainData terrain = GetComponent<Terrain> ().terrainData;
int width = 512 * 3;
float[,] heightmapData = new float[width, width]; //terrain.GetHeights(0, 0, width, width);
if (width % rows == 0)
{
heightmapData = ApplyElevationsToHeightmap(elevations, heightmapData, width);
heightmapData = Smooth(heightmapData, smoothings, neighbors, width);
for (int i = 0; i < 9; i++)
{
cachedHeightmaps.Add(GetCachedHMIndex(center, cellSize, i), GetHeightmapForChunk(heightmapData, i));
}
}
else
{
Debug.Log("Something went wrong: size of terrain is not processable for heightmap generation");
}
keepGoing = false;
Debug.Log("finished");
Debug.Log(cachedHeightmaps.Count);
}
//^ [NotDelayed]
internal MethodSpecSignatureConverter(
PEFileToObjectModel peFileToObjectModel,
MetadataObject owningObject,
MemoryReader signatureMemoryReader
)
: base(peFileToObjectModel, signatureMemoryReader, owningObject) {
//^ this.GenericTypeArguments = TypeCache.EmptyTypeArray;
//^ this.SignatureMemoryReader = signatureMemoryReader;
//^ base;
byte firstByte = this.SignatureMemoryReader.ReadByte();
if (!SignatureHeader.IsGenericInstanceSignature(firstByte)) {
// MDError
}
int typeArgCount = this.SignatureMemoryReader.ReadCompressedUInt32();
ITypeReference/*?*/[] typeRefArr = new ITypeReference/*?*/[typeArgCount];
for (int i = 0; i < typeArgCount; ++i) {
typeRefArr[i] = this.GetTypeReference();
}
this.GenericTypeArguments = new EnumerableArrayWrapper<ITypeReference/*?*/, ITypeReference>(typeRefArr, Dummy.TypeReference);
}
public override bool GetReferencingObjectNames(UpdatableObjectList <MetadataQualifiedName> list, MetadataObject forObject, MetadataLoadingOptions loadingOptions)
{
if (forObject.Server == null)
{
MetadataNamespace database = forObject.Database;
MetadataNamespace schema = forObject.Schema;
string[] restrictions = new string[6];
restrictions[0] = database != null ? database.Name : null;
restrictions[1] = schema != null ? schema.Name : null;
restrictions[2] = forObject.Name;
using (DataTable foreignKeys = _connection.GetSchema("ForeignKeys", restrictions))
{
int databaseField = foreignKeys.Columns.IndexOf("FKTABLE_CAT");
int schemaField = foreignKeys.Columns.IndexOf("FKTABLE_SCHEM");
int nameField = foreignKeys.Columns.IndexOf("FKTABLE_NAME");
foreach (DataRow row in foreignKeys.Rows)
{
object referencingName = nameField != -1 ? row[nameField] : null;
object referencingSchema = schemaField != -1 ? row[schemaField] : null;
object referencingDatabase = databaseField != -1 ? row[databaseField] : null;
MetadataQualifiedName name = new MetadataQualifiedName();
if (referencingName != null)
{
name.Add(referencingName.ToString(), MetadataType.Objects);
}
if (referencingSchema != null)
{
name.Add(referencingSchema.ToString(), MetadataType.Schema);
}
if (referencingDatabase != null)
{
name.Add(referencingDatabase.ToString(), MetadataType.Schema);
}
list.Add(name);
}
return(true);
}
}
return(false);
}
//////////////////////////////////////////////////////////////////////////
/// 4th way:
/// This method demonstrates manual filling of metadata structure from
/// stored DataSet.
//////////////////////////////////////////////////////////////////////////
private void btn4Way_Click(object sender, EventArgs e)
{
QBuilder.MetadataProvider = null;
QBuilder.MetadataLoadingOptions.OfflineMode = true; // prevent QueryBuilder to request metadata from connection
DataSet dataSet = new DataSet();
// Load sample dataset created in the Visual Studio with Dataset Designer
// and exported to XML using WriteXmlSchema() method.
dataSet.ReadXmlSchema(@"StoredDataSetSchema.xml");
QBuilder.MetadataContainer.BeginUpdate();
try
{
QBuilder.ClearMetadata();
// add tables
foreach (DataTable table in dataSet.Tables)
{
// add new metadata table
MetadataObject metadataTable = QBuilder.MetadataContainer.AddTable(table.TableName);
// add metadata fields (columns)
foreach (DataColumn column in table.Columns)
{
// create new field
MetadataField metadataField = metadataTable.AddField(column.ColumnName);
// setup field
metadataField.FieldType = TypeToDbType(column.DataType);
metadataField.Nullable = column.AllowDBNull;
metadataField.ReadOnly = column.ReadOnly;
if (column.MaxLength != -1)
{
metadataField.Size = column.MaxLength;
}
// detect the field is primary key
foreach (DataColumn pkColumn in table.PrimaryKey)
{
if (column == pkColumn)
{
metadataField.PrimaryKey = true;
}
}
}
// add relations
foreach (DataRelation relation in table.ParentRelations)
{
// create new relation on the parent table
MetadataForeignKey metadataRelation = metadataTable.AddForeignKey(relation.RelationName);
// set referenced table
using (MetadataQualifiedName referencedName = new MetadataQualifiedName())
{
referencedName.Add(relation.ParentTable.TableName);
metadataRelation.ReferencedObjectName = referencedName;
}
// set referenced fields
foreach (DataColumn parentColumn in relation.ParentColumns)
{
metadataRelation.ReferencedFields.Add(parentColumn.ColumnName);
}
// set fields
foreach (DataColumn childColumn in relation.ChildColumns)
{
metadataRelation.Fields.Add(childColumn.ColumnName);
}
}
}
}
finally
{
QBuilder.MetadataContainer.EndUpdate();
}
QBuilder.InitializeDatabaseSchemaTree();
}
internal static void ProcessTraitsAndAnnotationsToData(CdmCorpusContext ctx, MetadataObject obj, CdmTraitCollection traits)
{
if (traits == null)
{
return;
}
var annotations = new List <Annotation>();
var extensions = new List <JToken>();
foreach (var trait in traits)
{
if (ExtensionHelper.TraitRefIsExtension(trait))
{
// Safe to cast since extensions can only be trait refs, not trait group refs
ExtensionHelper.ProcessExtensionTraitToObject(trait as CdmTraitReference, obj);
continue;
}
if (trait.NamedReference == "is.modelConversion.otherAnnotations")
{
// Safe to cast since "is.modelConversion.otherAnnotations" is a trait, not trait group
foreach (var annotation in (trait as CdmTraitReference).Arguments[0].Value)
{
if (annotation is JObject jAnnotation)
{
annotations.Add(jAnnotation.ToObject <Annotation>());
}
else if (annotation is NameValuePair)
{
Annotation element = new Annotation()
{
Name = annotation.Name,
Value = annotation.Value
};
annotations.Add(element);
}
else
{
Logger.Warning(ctx, Tag, nameof(ProcessTraitsAndAnnotationsToData), null, CdmLogCode.WarnAnnotationTypeNotSupported);
}
}
}
else if (
!ignoredTraits.Contains(trait.NamedReference) &&
!trait.NamedReference.StartsWith("is.dataFormat") &&
!(modelJsonPropertyTraits.Contains(trait.NamedReference) && trait is CdmTraitReference && (trait as CdmTraitReference).IsFromProperty))
{
var extension = trait is CdmTraitGroupReference?
CdmFolder.TraitGroupReferencePersistence.ToData(trait as CdmTraitGroupReference, null, null) :
CdmFolder.TraitReferencePersistence.ToData(trait as CdmTraitReference, null, null);
extensions.Add(JToken.FromObject(extension, JsonSerializationUtil.JsonSerializer));
}
}
if (annotations.Count > 0)
{
obj.Annotations = annotations;
}
if (extensions.Count > 0)
{
obj.Traits = extensions;
}
}
internal ITypeReference/*?*/ GetTypeReferenceForToken(
MetadataObject owningObject,
uint token
) {
return this.GetTypeReferenceForToken(owningObject, token, false);
}
//////////////////////////////////////////////////////////////////////////
/// 4th way:
/// This method demonstrates manual filling of metadata structure from
/// stored DataSet.
//////////////////////////////////////////////////////////////////////////
public void Way4(object sender, EventArgs e)
{
ActiveTabs = 3;
var queryBuilder1 = QueryBuilderStore.Get("LoadMetadata");
ResetQueryBuilderMetadata(queryBuilder1);
queryBuilder1.MetadataLoadingOptions.OfflineMode = true; // prevent QueryBuilder to request metadata from connection
DataSet dataSet = new DataSet();
// Load sample dataset created in the Visual Studio with Dataset Designer
// and exported to XML using WriteXmlSchema() method.
var xml = Path.Combine(Server.MapPath("~"), "../Sample databases/StoredDataSetSchema.xml");
dataSet.ReadXmlSchema(xml);
queryBuilder1.MetadataContainer.BeginUpdate();
try
{
queryBuilder1.ClearMetadata();
// add tables
foreach (DataTable table in dataSet.Tables)
{
// add new metadata table
MetadataObject metadataTable = queryBuilder1.MetadataContainer.AddTable(table.TableName);
// add metadata fields (columns)
foreach (DataColumn column in table.Columns)
{
// create new field
MetadataField metadataField = metadataTable.AddField(column.ColumnName);
// setup field
metadataField.FieldType = TypeToDbType(column.DataType);
metadataField.Nullable = column.AllowDBNull;
metadataField.ReadOnly = column.ReadOnly;
if (column.MaxLength != -1)
{
metadataField.Size = column.MaxLength;
}
// detect the field is primary key
foreach (DataColumn pkColumn in table.PrimaryKey)
{
if (column == pkColumn)
{
metadataField.PrimaryKey = true;
}
}
}
// add relations
foreach (DataRelation relation in table.ParentRelations)
{
// create new relation on the parent table
MetadataForeignKey metadataRelation = metadataTable.AddForeignKey(relation.RelationName);
// set referenced table
using (MetadataQualifiedName referencedName = new MetadataQualifiedName())
{
referencedName.Add(relation.ParentTable.TableName);
metadataRelation.ReferencedObjectName = referencedName;
}
// set referenced fields
foreach (DataColumn parentColumn in relation.ParentColumns)
{
metadataRelation.ReferencedFields.Add(parentColumn.ColumnName);
}
// set fields
foreach (DataColumn childColumn in relation.ChildColumns)
{
metadataRelation.Fields.Add(childColumn.ColumnName);
}
}
}
}
finally
{
queryBuilder1.MetadataContainer.EndUpdate();
}
queryBuilder1.MetadataStructure.Refresh();
}
internal IMetadataConstant GetDefaultValue(
MetadataObject metadataObject
) {
uint constRowId = this.PEFileReader.ConstantTable.GetConstantRowId(metadataObject.TokenValue);
if (constRowId == 0)
return Dummy.Constant;
ConstantRow constRow = this.PEFileReader.ConstantTable[constRowId];
MemoryBlock constValueMemoryBlock = this.PEFileReader.BlobStream.GetMemoryBlockAt(constRow.Value);
MemoryReader memoryReader = new MemoryReader(constValueMemoryBlock);
switch (constRow.Type) {
case ElementType.Boolean: {
byte val = memoryReader.ReadByte();
return new ConstantExpression(this.PlatformType.SystemBoolean, val != 0);
}
case ElementType.Char:
return new ConstantExpression(this.PlatformType.SystemChar, memoryReader.ReadChar());
case ElementType.Int8:
return new ConstantExpression(this.PlatformType.SystemInt8, memoryReader.ReadSByte());
case ElementType.Int16:
return new ConstantExpression(this.PlatformType.SystemInt16, memoryReader.ReadInt16());
case ElementType.Int32:
return new ConstantExpression(this.PlatformType.SystemInt32, memoryReader.ReadInt32());
case ElementType.Int64:
return new ConstantExpression(this.PlatformType.SystemInt64, memoryReader.ReadInt64());
case ElementType.UInt8:
return new ConstantExpression(this.PlatformType.SystemUInt8, memoryReader.ReadByte());
case ElementType.UInt16:
return new ConstantExpression(this.PlatformType.SystemUInt16, memoryReader.ReadUInt16());
case ElementType.UInt32:
return new ConstantExpression(this.PlatformType.SystemUInt32, memoryReader.ReadUInt32());
case ElementType.UInt64:
return new ConstantExpression(this.PlatformType.SystemUInt64, memoryReader.ReadUInt64());
case ElementType.Single:
return new ConstantExpression(this.PlatformType.SystemFloat32, memoryReader.ReadSingle());
case ElementType.Double:
return new ConstantExpression(this.PlatformType.SystemFloat64, memoryReader.ReadDouble());
case ElementType.String: {
int byteLen = memoryReader.Length;
string/*?*/ value;
if (byteLen == -1) {
value = null;
} else if (byteLen == 0) {
value = string.Empty;
} else {
value = memoryReader.ReadUTF16WithSize(byteLen);
}
return new ConstantExpression(this.PlatformType.SystemString, value);
}
case ElementType.Class:
return new ConstantExpression(this.PlatformType.SystemObject, null);
}
// MDError...
return Dummy.Constant;
}
private void LocalizeMetadataObjectEnDe(MetadataObject metadataObject, string nameEnglish, string nameGerman)
{
LocalizedName.NewObject(nameGerman, _cultureDe, metadataObject);
LocalizedName.NewObject(nameEnglish, _cultureEn, metadataObject);
}
//^ invariant this.PEFileReader.MethodSpecTable.NumberOfRows >= 1 ==> this.MethodSpecHashtable != null;
internal ITypeMemberReference/*?*/ GetModuleMemberReferenceAtRowWorker(
MetadataObject owningObject,
uint memberRefRowId
) {
if (memberRefRowId == 0 || memberRefRowId > this.PEFileReader.MemberRefTable.NumberOfRows) {
return null;
}
if (this.ModuleMemberReferenceArray[memberRefRowId] == null) {
MemberRefRow memberRefRow = this.PEFileReader.MemberRefTable[memberRefRowId];
uint classTokenType = memberRefRow.Class & TokenTypeIds.TokenTypeMask;
uint classRowId = memberRefRow.Class & TokenTypeIds.RIDMask;
ITypeReference/*?*/ parentTypeReference = null;
switch (classTokenType) {
case TokenTypeIds.TypeDef:
parentTypeReference = this.GetTypeDefinitionAtRow(classRowId);
break;
case TokenTypeIds.TypeRef:
parentTypeReference = this.GetTypeRefReferenceAtRow(classRowId);
break;
case TokenTypeIds.TypeSpec:
parentTypeReference = this.GetTypeSpecReferenceAtRow(owningObject, classRowId).UnderlyingModuleTypeReference;
break;
case TokenTypeIds.MethodDef: {
var/*?*/ methodDef = this.GetMethodDefAtRow(classRowId);
if (methodDef == null) {
// Error...
return null;
}
parentTypeReference = methodDef.ContainingType;
break;
}
case TokenTypeIds.ModuleRef: {
ModuleReference/*?*/ modRef = this.GetModuleReferenceAt(classRowId);
if (modRef == null) {
// MDError
return null;
}
var module = this.ResolveModuleRefReference(modRef) as Module;
if (module == null) {
//TODO: MDError...
return null;
}
PEFileToObjectModel modulePEFileToObjectModel = module.PEFileToObjectModel;
parentTypeReference = modulePEFileToObjectModel._Module_;
break;
}
default: {
// MDError...
return null;
}
}
if (parentTypeReference == null) {
// Error...
return null;
}
MemberReference retModuleMemberReference;
IName name = this.GetNameFromOffset(memberRefRow.Name);
byte firstByte = this.PEFileReader.BlobStream.GetByteAt(memberRefRow.Signature, 0);
var genericTypeInstance = parentTypeReference as IGenericTypeInstanceReference;
var specializedNestedTypeReference = parentTypeReference as ISpecializedNestedTypeReference;
if (SignatureHeader.IsFieldSignature(firstByte)) {
if (genericTypeInstance != null || specializedNestedTypeReference != null) {
//The same memberRef token can be shared by distinct instance references, therefore special caching is required
FieldReference unspecializedFieldReference = this.UnspecializedMemberReferenceArray[memberRefRowId] as FieldReference;
if (unspecializedFieldReference == null) {
unspecializedFieldReference = new FieldReference(this, memberRefRowId, TypeCache.Unspecialize(parentTypeReference), name);
this.UnspecializedMemberReferenceArray[memberRefRowId] = unspecializedFieldReference;
}
uint key1 = parentTypeReference.InternedKey;
uint key2 = unspecializedFieldReference.InternedKey;
var specializedField = this.SpecializedFieldHashtable.Find(key1, key2);
if (specializedField == null) {
specializedField = new SpecializedFieldReference(parentTypeReference, unspecializedFieldReference, this.InternFactory);
this.SpecializedFieldHashtable.Add(key1, key2, specializedField);
}
return specializedField;
} else {
retModuleMemberReference = new FieldReference(this, memberRefRowId, parentTypeReference, name);
}
} else if (SignatureHeader.IsMethodSignature(firstByte)) {
if (genericTypeInstance != null || specializedNestedTypeReference != null) {
//The same memberRef token can be shared by distinct instance references, therefore special caching is required
MethodReference unspecializedMethodReference = this.UnspecializedMemberReferenceArray[memberRefRowId] as MethodReference;
if (unspecializedMethodReference == null) {
unspecializedMethodReference = new MethodReference(this, memberRefRowId, TypeCache.Unspecialize(parentTypeReference), name, firstByte);
this.UnspecializedMemberReferenceArray[memberRefRowId] = unspecializedMethodReference;
}
uint key1 = parentTypeReference.InternedKey;
uint key2 = unspecializedMethodReference.InternedKey;
var specializedMethod = this.SpecializedMethodHashtable.Find(key1, key2);
if (specializedMethod == null) {
specializedMethod = new SpecializedMethodReference(parentTypeReference, unspecializedMethodReference, this.InternFactory);
this.SpecializedMethodHashtable.Add(key1, key2, specializedMethod);
}
return specializedMethod;
} else {
retModuleMemberReference = new MethodReference(this, memberRefRowId, parentTypeReference, name, firstByte);
}
} else {
// MD Error
return null;
}
this.ModuleMemberReferenceArray[memberRefRowId] = retModuleMemberReference;
}
MemberReference/*?*/ ret = this.ModuleMemberReferenceArray[memberRefRowId];
return ret;
}
protected void btn4_Click(object sender, EventArgs e)
{
var queryBuilder1 = QueryBuilderControl1.QueryBuilder;
queryBuilder1.MetadataProvider = null;
queryBuilder1.OfflineMode = true; // prevent QueryBuilder to request metadata from connection
DataSet dataSet = new DataSet();
// Load sample dataset created in the Visual Studio with Dataset Designer
// and exported to XML using WriteXmlSchema() method.
dataSet.ReadXmlSchema(Path.Combine(Server.MapPath("~/"), "StoredDataSetSchema.xml"));
queryBuilder1.MetadataContainer.BeginUpdate();
try
{
queryBuilder1.MetadataContainer.Items.Clear();
// add tables
foreach (DataTable table in dataSet.Tables)
{
// add new metadata table
MetadataObject metadataTable = queryBuilder1.MetadataContainer.AddTable(table.TableName);
// add metadata fields (columns)
foreach (DataColumn column in table.Columns)
{
// create new field
MetadataField metadataField = metadataTable.AddField(column.ColumnName);
// setup field
metadataField.FieldType = TypeToDbType(column.DataType);
metadataField.Nullable = column.AllowDBNull;
metadataField.ReadOnly = column.ReadOnly;
if (column.MaxLength != -1)
{
metadataField.Size = column.MaxLength;
}
// detect the field is primary key
foreach (DataColumn pkColumn in table.PrimaryKey)
{
if (column == pkColumn)
{
metadataField.PrimaryKey = true;
}
}
}
// add relations
foreach (DataRelation relation in table.ParentRelations)
{
// create new relation on the parent table
MetadataForeignKey metadataRelation = metadataTable.AddForeignKey(relation.RelationName);
// set referenced table
using (MetadataQualifiedName referencedName = new MetadataQualifiedName())
{
referencedName.Add(relation.ParentTable.TableName);
metadataRelation.ReferencedObjectName = referencedName;
}
// set referenced fields
foreach (DataColumn parentColumn in relation.ParentColumns)
{
metadataRelation.ReferencedFields.Add(parentColumn.ColumnName);
}
// set fields
foreach (DataColumn childColumn in relation.ChildColumns)
{
metadataRelation.Fields.Add(childColumn.ColumnName);
}
}
}
}
finally
{
queryBuilder1.MetadataContainer.EndUpdate();
}
queryBuilder1.MetadataStructure.Refresh();
StatusBar1.Message.Information("Metadata loaded");
}
internal IMethodReference/*?*/ GetMethodSpecAtRow(
MetadataObject owningObject,
uint methodSpecRowId
) {
if (methodSpecRowId == 0 || methodSpecRowId > this.PEFileReader.MethodSpecTable.NumberOfRows) {
return null;
}
uint ownerId = owningObject.TokenValue;
IGenericMethodInstanceReference/*?*/ methodSpecReference = this.ModuleMethodSpecHashtable.Find(ownerId, methodSpecRowId);
if (methodSpecReference == null) {
lock (GlobalLock.LockingObject) {
methodSpecReference = this.ModuleMethodSpecHashtable.Find(ownerId, methodSpecRowId);
if (methodSpecReference == null) {
MethodSpecRow methodSpecRow = this.PEFileReader.MethodSpecTable[methodSpecRowId];
uint methToken = methodSpecRow.Method;
uint tokenKind = methToken & TokenTypeIds.TokenTypeMask;
uint rowId = methToken & TokenTypeIds.RIDMask;
IMethodReference/*?*/ moduleMethod;
if (tokenKind == TokenTypeIds.MethodDef) {
moduleMethod = this.GetMethodDefAtRow(rowId);
} else if (tokenKind == TokenTypeIds.MemberRef) {
moduleMethod = this.GetModuleMemberReferenceAtRow(owningObject, rowId) as IMethodReference;
} else {
// MDError...
return null;
}
if (moduleMethod == null) {
// MDError...
return null;
}
// TODO: error checking offset in range
MemoryBlock signatureMemoryBlock = this.PEFileReader.BlobStream.GetMemoryBlockAt(methodSpecRow.Instantiation);
// TODO: Error checking enough space in signature memoryBlock.
MemoryReader memoryReader = new MemoryReader(signatureMemoryBlock);
// TODO: Check if this is really a method spec signature there.
MethodSpecSignatureConverter methodSpecSigConv = new MethodSpecSignatureConverter(this, owningObject, memoryReader);
methodSpecReference = new GenericMethodInstanceReferenceWithToken(moduleMethod, methodSpecSigConv.GenericTypeArguments, this.InternFactory,
methodSpecRowId | TokenTypeIds.MethodSpec);
this.ModuleMethodSpecHashtable.Add(ownerId, methodSpecRowId, methodSpecReference);
}
}
}
return methodSpecReference;
}
internal static async Task ProcessTraitsAndAnnotationsToData(CdmCorpusContext ctx, MetadataObject obj, CdmTraitCollection traits)
{
if (traits == null)
{
return;
}
var annotations = new List <Annotation>();
var extensions = new List <JToken>();
foreach (var trait in traits)
{
if (ExtensionHelper.TraitRefIsExtension(trait))
{
ExtensionHelper.ProcessExtensionTraitToObject(trait, obj);
continue;
}
if (trait.NamedReference == "is.modelConversion.otherAnnotations")
{
foreach (var annotation in trait.Arguments[0].Value)
{
if (annotation is JObject jAnnotation)
{
annotations.Add(jAnnotation.ToObject <Annotation>());
}
else if (annotation is Annotation)
{
annotations.Add(annotation);
}
else
{
Logger.Warning(nameof(Utils), ctx, "Unsupported annotation type.");
}
}
}
else if (
!ignoredTraits.Contains(trait.NamedReference) &&
!trait.NamedReference.StartsWith("is.dataFormat") &&
!(modelJsonPropertyTraits.Contains(trait.NamedReference) && trait.IsFromProperty))
{
var extension = CdmFolder.TraitReferencePersistence.ToData(trait, null, null);
extensions.Add(JToken.FromObject(extension, JsonSerializationUtil.JsonSerializer));
}
}
if (annotations.Count > 0)
{
obj.Annotations = annotations;
}
if (extensions.Count > 0)
{
obj.Traits = extensions;
}
}
// Caller should lock this...
internal IFieldReference GetFieldReferenceForToken(
MetadataObject owningObject,
uint fieldRefToken
) {
uint tokenKind = fieldRefToken & TokenTypeIds.TokenTypeMask;
uint rowId = fieldRefToken & TokenTypeIds.RIDMask;
switch (tokenKind) {
case TokenTypeIds.FieldDef:
FieldDefinition/*?*/ fieldDef = this.GetFieldDefAtRow(rowId);
if (fieldDef == null)
return Dummy.FieldReference;
else
return fieldDef;
case TokenTypeIds.MemberRef: {
var fieldRef = this.GetModuleMemberReferenceAtRow(owningObject, rowId) as IFieldReference;
if (fieldRef == null) {
// MDError/ILError?
return Dummy.FieldReference;
} else {
return fieldRef;
}
}
default:
return Dummy.FieldReference;
}
}
//^ invariant this.PEFileReader.MethodSpecTable.NumberOfRows >= 1 ==> this.MethodSpecHashtable != null;
internal MemberReference/*?*/ GetModuleMemberReferenceAtRowWorker(
MetadataObject owningObject,
uint memberRefRowId
) {
if (memberRefRowId == 0 || memberRefRowId > this.PEFileReader.MemberRefTable.NumberOfRows) {
return null;
}
if (this.ModuleMemberReferenceArray[memberRefRowId] == null) {
MemberRefRow memberRefRow = this.PEFileReader.MemberRefTable[memberRefRowId];
uint classTokenType = memberRefRow.Class & TokenTypeIds.TokenTypeMask;
uint classRowId = memberRefRow.Class & TokenTypeIds.RIDMask;
IModuleTypeReference/*?*/ parentTypeReference = null;
switch (classTokenType) {
case TokenTypeIds.TypeDef:
parentTypeReference = this.GetTypeDefinitionAtRowWorker(classRowId);
break;
case TokenTypeIds.TypeRef:
parentTypeReference = this.GetTypeRefReferenceAtRowWorker(classRowId);
break;
case TokenTypeIds.TypeSpec:
parentTypeReference = this.GetTypeSpecReferenceAtRow(owningObject, classRowId).UnderlyingModuleTypeReference;
break;
case TokenTypeIds.MethodDef: {
MethodDefinition/*?*/ methodDef = this.GetMethodDefAtRow(classRowId);
if (methodDef == null) {
// Error...
return null;
}
parentTypeReference = methodDef.OwningModuleType;
break;
}
case TokenTypeIds.ModuleRef: {
ModuleReference/*?*/ modRef = this.GetModuleReferenceAt(classRowId);
if (modRef == null) {
// MDError
return null;
}
Module/*?*/ module = this.ResolveModuleRefReference(modRef);
if (module == null) {
//TODO: MDError...
return null;
}
PEFileToObjectModel modulePEFileToObjectModel = module.PEFileToObjectModel;
parentTypeReference = modulePEFileToObjectModel._Module_;
break;
}
default: {
// MDError...
return null;
}
}
if (parentTypeReference == null) {
// Error...
return null;
}
MemberReference retModuleMemberReference;
IName name = this.GetNameFromOffset(memberRefRow.Name);
byte firstByte = this.PEFileReader.BlobStream.GetByteAt(memberRefRow.Signature, 0);
IModuleGenericTypeInstance/*?*/ genericTypeInstance = parentTypeReference as IModuleGenericTypeInstance;
IModuleSpecializedNestedTypeReference/*?*/ specializedNestedTypeReference = parentTypeReference as IModuleSpecializedNestedTypeReference;
if (SignatureHeader.IsFieldSignature(firstByte)) {
if (genericTypeInstance != null) {
//The same memberRef token can be shared by distinct instance references, therefore recompute every time.
return new GenericInstanceFieldReference(this, memberRefRowId, genericTypeInstance, name);
} else if (specializedNestedTypeReference != null) {
//The same memberRef token can be shared by distinct instance references, therefore recompute every time.
return new SpecializedNestedTypeFieldReference(this, memberRefRowId, parentTypeReference, specializedNestedTypeReference, name);
} else {
retModuleMemberReference = new FieldReference(this, memberRefRowId, parentTypeReference, name);
}
} else if (SignatureHeader.IsMethodSignature(firstByte)) {
if (genericTypeInstance != null) {
//The same memberRef token can be shared by distinct instance references, therefore recompute every time.
return new GenericInstanceMethodReference(this, memberRefRowId, genericTypeInstance, name, firstByte);
} else if (specializedNestedTypeReference != null) {
//The same memberRef token can be shared by distinct instance references, therefore recompute every time.
return new SpecializedNestedTypeMethodReference(this, memberRefRowId, parentTypeReference, specializedNestedTypeReference, name, firstByte);
} else {
retModuleMemberReference = new MethodReference(this, memberRefRowId, parentTypeReference, name, firstByte);
}
} else {
// MD Error
return null;
}
this.ModuleMemberReferenceArray[memberRefRowId] = retModuleMemberReference;
}
MemberReference/*?*/ ret = this.ModuleMemberReferenceArray[memberRefRowId];
return ret;
}
internal void GetCustomAttributeInfo(
MetadataObject metadataObject,
out uint customAttributeRowIdStart,
out uint customAttributeRowIdEnd
) {
customAttributeRowIdStart = 0;
customAttributeRowIdEnd = 0;
if (metadataObject.TokenValue == 0xFFFFFFFF)
return;
uint customAttributeCount;
customAttributeRowIdStart = this.PEFileReader.CustomAttributeTable.FindCustomAttributesForToken(metadataObject.TokenValue, out customAttributeCount);
customAttributeRowIdEnd = customAttributeRowIdStart + customAttributeCount;
}
/// <summary>
/// Processes extensions from an object which was obtained from a "model.json" file.
/// From every extension found, it's value (name, value) is added to traitRefSet,
/// and it's definition (name, type) is added to extensionTraitDefList.
/// </summary>
/// <param name="ctx"> The context </param>
/// <param name="sourceObject"> The object obtained from "model.json" file.</param>
/// <param name="traitRefSet"> The list of extensions found, in the form of (name & value).</param>
/// <param name="extensionTraitDefList"> The list of definitions. For each extension, it's definition is added to this list (name & type).</param>
/// <param name="localExtensionTraitDefList"> Same as extensionTraitDefList but limited to extensions inside one document.</param>
public static void ProcessExtensionFromJson(
CdmCorpusContext ctx,
MetadataObject sourceObject,
CdmTraitCollection traitRefSet,
List <CdmTraitDefinition> extensionTraitDefList,
List <CdmTraitDefinition> localExtensionTraitDefList = null)
{
var extensions = sourceObject.ExtensionFields;
foreach (JProperty extensionAsJProperty in extensions.Children())
{
string traitName = AddExtensionTraitNamePrefix(extensionAsJProperty.Name);
CdmTraitDefinition extensionTraitDef = extensionTraitDefList.Find((CdmTraitDefinition trait) => trait.TraitName == traitName);
bool traitExists = extensionTraitDef != null;
if (!traitExists)
{
extensionTraitDef = ctx.Corpus.MakeObject <CdmTraitDefinition>(CdmObjectType.TraitDef, traitName);
extensionTraitDef.ExtendsTrait = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "is.extension", true);
}
CdmTraitReference extensionTraitRef = ctx.Corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, traitName);
var extensionValue = extensionAsJProperty.Value;
var extensionType = extensionValue.Type;
var shouldLookIntoProperties = extensionType == JTokenType.Object;
if (shouldLookIntoProperties)
{
var extensionValueAsJObject = extensionValue as JObject;
// extensionProperty.Name is here the equivalent of extensionProperty from TS project
foreach (JProperty extensionProperty in extensionValueAsJObject.Children())
{
// for every extensionProperty will have to save the (name, value) pair into extensionArgument,
// which will be saved in extensionTraitRef (the entity that will contain the data)
// (name, type) will be saved in extensionParameter,
// which will be saved in extensionTraitDef (the definition of the data, that can be saved in a schema file)
JToken extensionPropertyValue = extensionProperty.Value;
if (extensionPropertyValue == null)
{
continue;
}
CdmArgumentDefinition extensionArgument = ctx.Corpus.MakeObject <CdmArgumentDefinition>(
CdmObjectType.ArgumentDef,
extensionProperty.Name
);
CdmParameterDefinition extensionParameter = extensionTraitDef.Parameters.AllItems.Find(
(CdmParameterDefinition parameter) => parameter.Name == extensionProperty.Name);
bool parameterExists = extensionParameter != null;
if (!parameterExists)
{
extensionParameter = ctx.Corpus.MakeObject <CdmParameterDefinition>(CdmObjectType.ParameterDef, extensionProperty.Name);
extensionParameter.DataTypeRef = ctx.Corpus.MakeObject <CdmDataTypeReference>(CdmObjectType.DataTypeRef,
ConvertJTokenTypeToExpectedString(extensionPropertyValue.Type),
true);
}
if (extensionPropertyValue is JValue extensionPropertyValueAsJValue)
{
extensionArgument.Value = extensionPropertyValueAsJValue.Value;
}
else
{
extensionArgument.Value = extensionPropertyValue;
}
extensionTraitRef.Arguments.Add(extensionArgument);
if (!parameterExists)
{
extensionTraitDef.Parameters.Add(extensionParameter);
}
}
}
else
{
CdmArgumentDefinition extensionArgument = ctx.Corpus.MakeObject <CdmArgumentDefinition>(CdmObjectType.ArgumentDef, traitName);
CdmParameterDefinition extensionParameter = extensionTraitDef.Parameters.AllItems.Find((CdmParameterDefinition parameter) => parameter.Name == traitName);
bool parameterExists = extensionParameter != null;
if (!parameterExists)
{
extensionParameter = ctx.Corpus.MakeObject <CdmParameterDefinition>(CdmObjectType.ParameterDef, traitName);
extensionParameter.DataTypeRef = ctx.Corpus.MakeObject <CdmDataTypeReference>(
CdmObjectType.DataTypeRef,
ConvertJTokenTypeToExpectedString(extensionType),
true);
}
if (extensionValue is JValue extensionValuePrimite)
{
extensionArgument.Value = extensionValuePrimite.Value;
}
else
{
extensionArgument.Value = extensionValue;
}
extensionTraitRef.Arguments.Add(extensionArgument);
if (!parameterExists)
{
extensionTraitDef.Parameters.Add(extensionParameter);
}
}
if (!traitExists)
{
extensionTraitDefList.Add(extensionTraitDef);
}
if (localExtensionTraitDefList != null)
{
localExtensionTraitDefList.Add(extensionTraitDef);
}
traitRefSet.Add(extensionTraitRef);
}
}
internal void GetSecurityAttributeInfo(
MetadataObject metadataObject,
out uint securityAttributeRowIdStart,
out uint securityAttributeRowIdEnd
) {
securityAttributeRowIdStart = 0;
securityAttributeRowIdEnd = 0;
if (metadataObject.TokenValue == 0xFFFFFFFF)
return;
uint securityAttributeCount;
securityAttributeRowIdStart = this.PEFileReader.DeclSecurityTable.FindSecurityAttributesForToken(metadataObject.TokenValue, out securityAttributeCount);
securityAttributeRowIdEnd = securityAttributeRowIdStart + securityAttributeCount;
}
private void AddUserFields(QueryBuilder queryBuilder)
{
MetadataObject order = queryBuilder.MetadataContainer.FindItem <MetadataObject>("Orders");
order.AddUserField("DetailsCount", "(select count(*) from [Order Details] od where od.OrderId = Orders.OrderId)");
}
internal SignatureConverter(
PEFileToObjectModel peFileToObjectModel,
MemoryReader signatureMemoryReader,
MetadataObject metadataOwnerObject
)
//^ requires signatureMemoryReader.Length > 0;
{
this.PEFileToObjectModel = peFileToObjectModel;
this.SignatureMemoryReader = signatureMemoryReader;
this.MetadataOwnerObject = metadataOwnerObject;
this.ModuleMethodReference = metadataOwnerObject as IMethodReference;
this.ModuleMemberReference = metadataOwnerObject as ITypeMemberReference;
TypeMember/*?*/ moduleTypeMember = metadataOwnerObject as TypeMember;
if (moduleTypeMember != null) {
this.ModuleGenericType = moduleTypeMember.ContainingTypeDefinition as TypeBase;
this.ModuleGenericMethod = moduleTypeMember as GenericMethod;
return;
}
var moduleGenericType = metadataOwnerObject as TypeBase;
if (moduleGenericType != null) {
this.ModuleGenericType = moduleGenericType;
return;
}
GenericTypeParameter/*?*/ genericTypeParam = metadataOwnerObject as GenericTypeParameter;
if (genericTypeParam != null) {
this.ModuleGenericType = genericTypeParam.OwningGenericType;
return;
}
GenericMethodParameter/*?*/ genericMethodParam = metadataOwnerObject as GenericMethodParameter;
if (genericMethodParam != null) {
this.ModuleGenericType = genericMethodParam.OwningGenericMethod.ContainingTypeDefinition as TypeBase;
this.ModuleGenericMethod = genericMethodParam.OwningGenericMethod;
return;
}
}
private static void CreateRabbitMQQueues(string ms, string pg, string d, string u, string p, string rmq)
{
Console.Write(string.Format(CREATE_RABBITMQ_QUEUES_QUESTION, rmq));
string answer = Console.ReadLine();
if (answer.ToLowerInvariant() != "y")
{
return;
}
Console.Write(INPUT_HOST_TEXT);
string host = Console.ReadLine();
Console.Write(INPUT_PORT_TEXT);
string port = Console.ReadLine();
Console.Write(INPUT_USER_TEXT);
string user = Console.ReadLine();
Console.Write(INPUT_PASS_TEXT);
string pass = Console.ReadLine();
MessageProducerSettings settings = CreateMessageBrokerSettings(host, port, user, pass);
IMetadataService metadataService = new MetadataService();
if (!string.IsNullOrWhiteSpace(ms))
{
metadataService.UseDatabaseProvider(DatabaseProviders.SQLServer);
metadataService.ConfigureConnectionString(ms, d, u, p);
}
else
{
metadataService.UseDatabaseProvider(DatabaseProviders.PostgreSQL);
metadataService.ConfigureConnectionString(pg, d, u, p);
}
Console.WriteLine(LOADING_METADATA_NOTICE);
InfoBase infoBase = metadataService.LoadInfoBase();
Console.WriteLine(METADATA_LOADED_NOTICE);
MetadataObject metaObject = infoBase.Publications.Values.Where(p => p.Name == rmq).FirstOrDefault();
if (metaObject == null)
{
Console.WriteLine(string.Format(PUBLICATION_IS_NOT_FOUND_WARNING, rmq));
return;
}
if (!(metaObject is Publication publication))
{
Console.WriteLine(string.Format(PUBLICATION_IS_NOT_FOUND_WARNING, rmq));
return;
}
PublicationDataMapper mapper = new PublicationDataMapper();
mapper.UseDatabaseProvider(metadataService.DatabaseProvider);
mapper.UseConnectionString(metadataService.ConnectionString);
mapper.SelectSubscribers(publication);
using (IConnection messageBroker = CreateConnection(settings.MessageBrokerSettings))
{
string queueName;
foreach (Subscriber subscriber in publication.Subscribers)
{
if (subscriber.IsMarkedForDeletion)
{
continue;
}
queueName = CreateQueueName(publication.Publisher.Code, subscriber.Code);
CreateExchangeAndQueue(messageBroker, queueName);
queueName = CreateQueueName(subscriber.Code, publication.Publisher.Code);
CreateExchangeAndQueue(messageBroker, queueName);
}
}
}
} //end method
private void LoadSQLServerCE35SchemaTree()
{
queryBuilder.MetadataContainer.BeginUpdate();
PFDataAccessObjects.PFDatabase db = null;
string sql = string.Empty;
try
{
queryBuilder.MetadataContainer.Items.Clear();
//get list of tables and add them to the schema tree
db = new PFDataAccessObjects.PFDatabase(PFDataAccessObjects.DatabasePlatform.SQLServerCE35);
db.ConnectionString = this.ConnectionString;
db.OpenConnection();
sql = "select TABLE_NAME from INFORMATION_SCHEMA.TABLES";
DataTable datatableList = db.RunQueryDataTable(sql, CommandType.Text);
foreach (DataRow row in datatableList.Rows)
{
string tableName = row["TABLE_NAME"].ToString();
MetadataObject table = queryBuilder.MetadataContainer.AddTable(tableName);
sql = "select * from " + tableName + " where 0=1";
Console.WriteLine(sql);
DataTable columnList = db.RunQueryDataTable(sql, CommandType.Text);
foreach (DataColumn col in columnList.Columns)
{
MetadataField metadataField = table.AddField(col.ColumnName);
// setup field
metadataField.FieldType = TypeToDbType(col.DataType);
metadataField.Nullable = col.AllowDBNull;
metadataField.ReadOnly = col.ReadOnly;
if (col.MaxLength != -1)
{
metadataField.Size = col.MaxLength;
}
// detect the field is primary key
foreach (DataColumn pkColumn in columnList.PrimaryKey)
{
if (col == pkColumn)
{
metadataField.PrimaryKey = true;
}
}
}
//close and reopen connection to free up space used by temp tables in the .NET provider
db.CloseConnection();
db.OpenConnection();
}
}
catch (System.Exception ex)
{
_msg.Length = 0;
_msg.Append("Attempt to load SQLCE 3.5 Schema Tree failed.");
_msg.Append(Environment.NewLine);
_msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex));
throw new System.Exception(_msg.ToString());
}
finally
{
if (db != null)
{
db.Connection.Close();
if (db.IsConnected)
{
db.CloseConnection();
}
}
db = null;
queryBuilder.MetadataContainer.EndUpdate();
}
queryBuilder.DatabaseSchemaTreeOptions.DefaultExpandLevel = 0;
queryBuilder.InitializeDatabaseSchemaTree();
}
public bool Remove(MetadataObject metadataObject)
{
return(objects.Remove(metadataObject));
}
private void LoadFieldsFromGetSchema(MetadataList fields, MetadataLoadingOptions loadingOptions)
{
SQLContext sqlContext = fields.SQLContext;
string olddb = Connection.Database;
try
{
// load tables
string[] restrictions = new string[3];
if (sqlContext.SyntaxProvider.IsSupportDatabases())
{
MetadataNamespace database = fields.Parent.Database;
if (database != null)
{
restrictions[0] = database.Name;
}
else
{
return;
}
}
else
{
restrictions[0] = null;
}
if (sqlContext.SyntaxProvider.IsSupportSchemas())
{
MetadataNamespace schema = fields.Parent.Schema;
if (schema != null)
{
restrictions[1] = schema.Name;
}
else
{
return;
}
}
else
{
restrictions[1] = null;
}
MetadataObject obj = fields.Parent.Object;
if (obj == null)
{
return;
}
restrictions[2] = obj.Name;
try
{
if (!string.IsNullOrEmpty(restrictions[0]) && Connection.Database != restrictions[0])
{
Connection.ChangeDatabase(restrictions[0]);
}
DataTable schemaTable = _connection.GetSchema("Columns", restrictions);
schemaTable.DefaultView.Sort = "ORDINAL_POSITION";
DataTable ordinalSortedColumns = schemaTable.DefaultView.ToTable();
MetadataFieldsFetcherFromDatatable mof = new MetadataFieldsFetcherFromDatatable(sqlContext);
mof.NameFieldName = "COLUMN_NAME";
mof.ServerTypeFieldName = "TYPE_NAME";
mof.SizeFieldName = "COLUMN_SIZE";
mof.ScaleFieldName = "DECIMAL_DIGITS";
mof.DescriptionFieldName = "REMARKS";
mof.Datatable = ordinalSortedColumns;
mof.LoadFields(fields);
}
catch
{
// loading from OLEDB catalog failed
}
}
finally
{
if (Connection.Database != olddb)
{
Connection.ChangeDatabase(olddb);
}
}
}
} // buildBindingList(...)
private void TreatField(MetadataItem mdi)
{
MetadataField mdf = mdi as MetadataField;
if (mdf == null)
{
return;
}
//
ColumnQN colQN = new ColumnQN();
colQN.IsSystem = mdi.System;
colQN.IsDefault = mdi.Default;
colQN.ObjectType = Enum.GetName(typeof(MetadataType), mdi.Type);
if (mdi.Parent != null)
{
colQN.ParentType = Enum.GetName(typeof(MetadataType), mdi.Parent.Type);
}
colQN.Remarks = mdf.Description;
#region --- Server.Database.Schema.Object.Column Names ---
if (mdf.Server != null)
{
MetadataNamespace srv = mdf.Server;
colQN.ServerAltName = srv.AltName;
colQN.ServerName = srv.Name;
colQN.ServerNameFull = srv.NameFull;
colQN.ServerNameQuoted = srv.NameQuoted;
}
if (mdf.Database != null)
{
MetadataNamespace database = mdf.Database;
colQN.DatabaseAltName = database.AltName;
colQN.DatabaseName = database.Name;
colQN.DatabaseNameFull = database.NameFull;
colQN.DatabaseNameQuoted = database.NameQuoted;
}
if (mdf.Schema != null)
{
MetadataNamespace schema = mdf.Schema;
colQN.SchemaAltName = schema.AltName;
colQN.SchemaName = schema.Name;
colQN.SchemaNameFull = schema.NameFull;
colQN.SchemaNameQuoted = schema.NameQuoted;
}
if (mdf.Object != null)
{
MetadataObject obj = mdf.Object;
colQN.ParentAltName = obj.AltName;
colQN.ParentName = obj.Name;
colQN.ParentNameFull = obj.NameFull;
colQN.ParentNameQuoted = obj.NameQuoted;
}
{
colQN.AltName = mdf.AltName;
colQN.Name = mdf.Name;
colQN.NameFull = mdf.NameFull;
colQN.NameQuoted = mdf.NameQuoted;
}
#endregion
string idescription = mdi.Description;
object itag = mdi.Tag;
string iuserData = mdi.UserData;
MetadataNamespace package = mdf.Package;
//string writeXMLNode = WriteXMLNode(mdf);
//
{
colQN.DatabaseTypeName = mdf.FieldTypeName;
colQN.StorageTypeName = Enum.GetName(typeof(DbType), mdf.FieldType);
colQN.Size = mdf.Size;
colQN.Precision = mdf.Precision;
colQN.Scale = mdf.Scale;
colQN.IsPrimaryKey = mdf.PrimaryKey;
colQN.IsNullable = mdf.Nullable;
colQN.IsReadOnly = mdf.ReadOnly;
{
colQN.IsVirtual = mdf.IsVirtual();
colQN.Expression = mdf.Expression;
}
// string writeXMLNode = WriteXMLNode(mdf);
}
//
// colQN.Serialize(@"D:\TEMP\CS\QWERTY.XML");
//
this._colQnBindingList.Add(colQN);
}
/// <summary>
/// Used as helper for converting a Manifest to a Model.
/// Adds an extension stored in "Manifest" format to the data structure representing a <see cref="Model"/>
/// </summary>
/// <param name="extensionTraitRef">
/// The data structure containing the extension in the format used by the Manifest
/// </param>
/// <param name="destination">
/// The data structure used by <see cref="Model"/> where the data will be added to.
/// There are multiple data structures that can have extensions, and any of these can be used here (assuming they are used by Model.Json data format)
/// </param>
public static void ProcessExtensionTraitToObject(CdmTraitReference extensionTraitRef, MetadataObject destination)
{
if (destination.ExtensionFields == null)
{
destination.ExtensionFields = new JObject();
}
string originalExtensionName = RemoveExtensionTraitNamePrefix(extensionTraitRef.NamedReference);
JToken extensionValue;
if (extensionTraitRef.Arguments.Count == 1 && extensionTraitRef.Arguments[0].Name == extensionTraitRef.NamedReference)
{
extensionValue = extensionTraitRef.Arguments[0].Value;
}
else
{
var extensionValueAsJObject = new JObject();
foreach (CdmArgumentDefinition argument in extensionTraitRef.Arguments)
{
var propertyName = argument.Name;
var propertyValue = argument.Value;
extensionValueAsJObject.Add(propertyName, propertyValue);
}
extensionValue = extensionValueAsJObject;
}
destination.ExtensionFields.Add(originalExtensionName, extensionValue);
}
public void Enrich(MetadataObject metadataObject)
{
if (!(metadataObject is Characteristic model))
{
throw new ArgumentOutOfRangeException();
}
ConfigObject configObject = Configurator.FileReader.ReadConfigObject(model.FileName.ToString());
model.Uuid = configObject.GetUuid(new int[] { 1, 3 });
model.TypeUuid = configObject.GetUuid(new int[] { 1, 9 });
model.Name = configObject.GetString(new int[] { 1, 13, 1, 2 });
ConfigObject alias = configObject.GetObject(new int[] { 1, 13, 1, 3 });
if (alias.Values.Count == 3)
{
model.Alias = configObject.GetString(new int[] { 1, 13, 1, 3, 2 });
}
model.CodeLength = configObject.GetInt32(new int[] { 1, 21 });
model.DescriptionLength = configObject.GetInt32(new int[] { 1, 23 });
model.IsHierarchical = configObject.GetInt32(new int[] { 1, 19 }) != 0;
Configurator.ConfigurePropertyСсылка(model);
Configurator.ConfigurePropertyВерсияДанных(model);
Configurator.ConfigurePropertyПометкаУдаления(model);
Configurator.ConfigurePropertyПредопределённый(model);
Configurator.ConfigurePropertyТипЗначения(model);
if (model.CodeLength > 0)
{
Configurator.ConfigurePropertyКод(model);
}
if (model.DescriptionLength > 0)
{
Configurator.ConfigurePropertyНаименование(model);
}
if (model.IsHierarchical)
{
Configurator.ConfigurePropertyРодитель(model);
if (model.HierarchyType == HierarchyType.Groups)
{
Configurator.ConfigurePropertyЭтоГруппа(model);
}
}
// 1.18 - описание типов значений характеристики
ConfigObject propertyTypes = configObject.GetObject(new int[] { 1, 18 });
model.TypeInfo = (DataTypeInfo)TypeInfoConverter.Convert(propertyTypes);
// 3 - коллекция реквизитов
ConfigObject properties = configObject.GetObject(new int[] { 3 });
// 3.0 = 31182525-9346-4595-81f8-6f91a72ebe06 - идентификатор коллекции реквизитов
Guid propertiesUuid = configObject.GetUuid(new int[] { 3, 0 });
if (propertiesUuid == new Guid("31182525-9346-4595-81f8-6f91a72ebe06"))
{
Configurator.ConfigureProperties(model, properties, PropertyPurpose.Property);
}
Configurator.ConfigureSharedProperties(model);
// 5 - коллекция табличных частей
ConfigObject tableParts = configObject.GetObject(new int[] { 5 });
// 5.0 = 54e36536-7863-42fd-bea3-c5edd3122fdc - идентификатор коллекции табличных частей
Guid collectionUuid = configObject.GetUuid(new int[] { 5, 0 });
if (collectionUuid == new Guid("54e36536-7863-42fd-bea3-c5edd3122fdc"))
{
Configurator.ConfigureTableParts(model, tableParts);
}
}
