public virtual IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata
, bool isPrimitive)
{
return isPrimitive
? Handlers4.PrimitiveClassReflector(classMetadata, reflector)
: classMetadata.ClassReflector();
}
public ModifiedAspectTraversalStrategy(ClassMetadata classMetadata, IList ancestors
)
{
_classDiffs = new ArrayList();
_classDiffs.Add(new HierarchyAnalyzer.Same(classMetadata));
Sharpen.Collections.AddAll(_classDiffs, ancestors);
}
internal QCandidates(LocalTransaction a_trans, ClassMetadata a_classMetadata, QField
a_field)
{
// Transaction necessary as reference to stream
// root of the QCandidate tree
// collection of all constraints
// possible class information
// possible field information
// current executing constraint, only set where needed
i_trans = a_trans;
i_classMetadata = a_classMetadata;
_field = a_field;
if (a_field == null || a_field._fieldMetadata == null || !(a_field._fieldMetadata
.GetHandler() is StandardReferenceTypeHandler))
{
return;
}
var yc = ((StandardReferenceTypeHandler) a_field._fieldMetadata.GetHandler
()).ClassMetadata();
if (i_classMetadata == null)
{
i_classMetadata = yc;
}
else
{
yc = i_classMetadata.GetHigherOrCommonHierarchy(yc);
if (yc != null)
{
i_classMetadata = yc;
}
}
}
protected override bool Accept(ClassMetadata classmetadata)
{
#if CF || SILVERLIGHT
return false;
#else
return NetReflector.ToNative(classmetadata.ClassReflector()) == typeof (DateTimeOffset);
#endif
}
public virtual IUpdateDepth Adjust(ClassMetadata clazz)
{
if (clazz.CascadesOnDeleteOrUpdate())
{
return AdjustDepthToBorders().Descend();
}
return Descend();
}
public override IActivationDepth Descend(ClassMetadata metadata)
{
if (_depth < 1)
{
return this;
}
return new FixedActivationDepth(_depth - 1, _mode
);
}
public SodaQueryComparator(LocalObjectContainer container, ClassMetadata extent,
Ordering[] orderings)
{
_container = container;
_transaction = ((LocalTransaction) _container.Transaction);
_extentType = extent;
_orderings = orderings;
ResolveFieldPaths(orderings);
}
private int ConfiguredActivationDepth(ClassMetadata metadata)
{
var config = metadata.ConfigOrAncestorConfig();
if (config != null && _mode.IsActivate())
{
return config.AdjustActivationDepth(_depth);
}
return _depth;
}
protected override bool Accept(ClassMetadata classmetadata)
{
var isGuid = NetReflector.ToNative(classmetadata.ClassReflector()) == typeof (Guid);
if (!isGuid)
{
classmetadata.TraverseDeclaredFields(reindexer);
}
return isGuid;
}
public HierarchyAnalyzer(ClassMetadata storedClass, IReflectClass runtimeClass)
{
if (storedClass == null || runtimeClass == null)
{
throw new ArgumentNullException();
}
_storedClass = storedClass;
_runtimeClass = runtimeClass;
_objectClass = runtimeClass.Reflector().ForClass(typeof (object));
}
public override IActivationDepth Descend(ClassMetadata metadata)
{
if (null == metadata)
{
return new LegacyActivationDepth(_depth - 1,
_mode);
}
return new LegacyActivationDepth(DescendDepth
(metadata), _mode);
}
private int DescendDepth(ClassMetadata metadata)
{
var depth = ConfiguredActivationDepth(metadata) - 1;
if (metadata.IsStruct())
{
// We also have to instantiate structs completely every time.
return Math.Max(1, depth);
}
return depth;
}
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz
, ByteArrayBuffer reader)
{
var indexID = reader.ReadInt();
if (indexID == 0)
{
return;
}
clazz.Index().Read(stream, indexID);
}
public virtual bool RebuildIndexForClass(LocalObjectContainer container, ClassMetadata
classMetadata)
{
var ids = classMetadata.GetIDs();
for (var i = 0; i < ids.Length; i++)
{
RebuildIndexForObject(container, (int) ids[i]);
}
return ids.Length > 0;
}
public override IReflectClass ClassReflector(IReflector reflector, ClassMetadata
classMetadata, bool isPrimitive)
{
var primitiveClaxx = Handlers4.PrimitiveClassReflector(classMetadata, reflector
);
if (primitiveClaxx != null)
{
return primitiveClaxx;
}
return base.ClassReflector(reflector, classMetadata, isPrimitive);
}
public virtual void Write(Transaction trans, ClassMetadata clazz, ByteArrayBuffer
writer)
{
writer.WriteShortString(trans, clazz.NameToWrite());
var intFormerlyKnownAsMetaClassID = 0;
writer.WriteInt(intFormerlyKnownAsMetaClassID);
writer.WriteIDOf(trans, clazz._ancestor);
WriteIndex(trans, clazz, writer);
writer.WriteInt(clazz.DeclaredAspectCount());
clazz.TraverseDeclaredAspects(new _IProcedure4_39(this, trans, clazz, writer));
}
public ClassMetadata Analyze(Type type)
{
ClassMetadata metadata = new ClassMetadata(type);
foreach (IExtractor extractor in _extractors)
{
extractor.Extract(type, metadata, _heuristics);
}
return metadata;
}
public void ShouldSetTypePropertyToPropertyArgument()
{
// Given
// When
var metadata = new ClassMetadata(typeof(Exception));
// Then
metadata.Should().NotBeNull();
metadata.Type.Should().Be(typeof(Exception));
}
private int ProcessAspectsOf(ClassMetadata classMetadata, ITraverseAspectCommand
command, int currentSlot, ITraverseAspectCommandProcessor
processor)
{
var aspectCount = command.DeclaredAspectCount(classMetadata);
for (var i = 0; i < aspectCount && !command.Cancelled(); i++)
{
processor.Process(command, classMetadata._aspects[i], currentSlot);
currentSlot++;
}
return currentSlot;
}
public virtual IActivationDepth ActivationDepthFor(ClassMetadata classMetadata, ActivationMode
mode)
{
if (IsTAAware(classMetadata))
{
return new NonDescendingActivationDepth(mode);
}
if (mode.IsPrefetch())
{
return new FixedActivationDepth(1, mode);
}
return new DescendingActivationDepth(this, mode);
}
public virtual bool SkipClass(ClassMetadata classMetadata)
{
if (classMetadata.GetName() == null)
{
return true;
}
var claxx = classMetadata.ClassReflector();
if (Stream()._handlers.IclassInternal.IsAssignableFrom(claxx))
{
return true;
}
return false;
}
protected override FieldMetadata FromSpec(RawFieldSpec spec, ObjectContainerBase
stream, ClassMetadata containingClass)
{
var actualField = base.FromSpec(spec, stream, containingClass);
if (spec == null)
{
return null;
}
if (spec.IndexID() != 0)
{
actualField.InitIndex(stream.SystemTransaction(), spec.IndexID());
}
return actualField;
}
public void Read(ObjectContainerBase stream, ClassMetadata clazz, ByteArrayBuffer
reader)
{
clazz.SetAncestor(stream.ClassMetadataForID(reader.ReadInt()));
// if(clazz.callConstructor()){
// // The logic further down checks the ancestor YapClass, whether
// // or not it is allowed, not to call constructors. The ancestor
// // YapClass may possibly have not been loaded yet.
// clazz.createConstructor(true);
// }
clazz.CheckType();
ReadIndex(stream, clazz, reader);
clazz._aspects = ReadAspects(stream, reader, clazz);
}
internal FieldMetadata(ClassMetadata containingClass, IReflectField field, ClassMetadata
fieldType) : this(containingClass)
{
Init(field.GetName());
_reflectField = field;
_fieldType = fieldType;
_fieldTypeID = fieldType.GetID();
// TODO: beautify !!! possibly pull up isPrimitive to ReflectField
var isPrimitive = field is GenericField
? ((GenericField)field).IsPrimitive()
: false;
Configure(field.GetFieldType(), isPrimitive);
CheckDb4oType();
SetAvailable();
}
internal void ReReadClassMetadata(ClassMetadata clazz)
{
if (clazz != null)
{
ReReadClassMetadata(clazz._ancestor);
clazz.ReadName(_systemTransaction);
clazz.ForceRead();
clazz.SetStateClean();
clazz.BitFalse(Const4.CheckedChanges);
clazz.BitFalse(Const4.Reading);
clazz.BitFalse(Const4.Continue);
clazz.BitFalse(Const4.Dead);
clazz.CheckChanges();
}
}
public void RefreshClassCache(ClassMetadata clazz, IReflectClass oldReflector)
{
if (clazz.StateUnread())
{
_classMetadataByBytes.Put(clazz.ReadName(_systemTransaction), clazz);
}
else
{
if (oldReflector != null)
{
_classMetadataByClass.Remove(oldReflector);
}
_classMetadataByClass.Put(clazz.ClassReflector(), clazz);
}
}
public ClassMetadata GetClassMetadata(string name)
{
ClassMetadata classMetadata = (ClassMetadata)_classMetadataByBytes.Remove(GetNameBytes
(name));
if (classMetadata == null)
{
classMetadata = FindInitializedClassByName(name);
}
if (classMetadata != null)
{
classMetadata = ReadClassMetadata(classMetadata, null);
}
return(classMetadata);
}
public int ClassMetadataIdForName(string name)
{
ClassMetadata classMetadata = (ClassMetadata)_classMetadataByBytes.Get(GetNameBytes
(name));
if (classMetadata == null)
{
classMetadata = FindInitializedClassByName(name);
}
if (classMetadata != null)
{
return(classMetadata.GetID());
}
return(0);
}
public override void Write(Transaction trans, ClassMetadata clazz, ClassAspect aspect
, ByteArrayBuffer writer)
{
base.Write(trans, clazz, aspect, writer);
if (!(aspect is FieldMetadata))
{
return;
}
var field = (FieldMetadata) aspect;
if (!HasBTreeIndex(field))
{
return;
}
writer.WriteIDOf(trans, field.GetIndex(trans));
}
public virtual IActivationDepth ActivationDepthFor(ClassMetadata classMetadata, ActivationMode
mode)
{
if (mode.IsPrefetch())
{
return new LegacyActivationDepth(1, mode);
}
var globalLegacyActivationDepth = ConfigImpl(classMetadata).ActivationDepth();
var config = classMetadata.ConfigOrAncestorConfig();
var defaultDepth = null == config
? globalLegacyActivationDepth
: config.AdjustActivationDepth
(globalLegacyActivationDepth);
return new LegacyActivationDepth(defaultDepth, mode);
}
public virtual IReflectClass ReflectClassFromElementsEntry(ObjectContainerBase container
, ArrayInfo info, int classID)
{
if (classID == 0)
{
return(null);
}
ClassMetadata classMetadata = container.ClassMetadataForID(classID);
if (classMetadata == null)
{
return(null);
}
return(ClassReflector(container.Reflector(), classMetadata, info.Primitive()));
}
public string ToString(ClassMetadata classMetadata)
{
var result = new StringBuilder();
if (Value is Criteria)
{
var criteria = Value as Criteria;
result.Append(criteria.ToString(classMetadata));
}
else
{
result.Append(OperationToString(classMetadata));
}
return(result.ToString());
}
protected override FieldMetadata FromSpec(RawFieldSpec spec, ObjectContainerBase
stream, ClassMetadata containingClass)
{
var actualField = base.FromSpec(spec, stream, containingClass);
if (spec == null)
{
return(null);
}
if (spec.IndexID() != 0)
{
actualField.InitIndex(stream.SystemTransaction(), spec.IndexID());
}
return(actualField);
}
public virtual object ReadFieldValue(FieldMetadata field)
{
ReadBuffer(ObjectId());
if (Buffer() == null)
{
return(null);
}
ClassMetadata classMetadata = ReadObjectHeader();
if (classMetadata == null)
{
return(null);
}
return(ReadFieldValue(classMetadata, field));
}
public Msg ReplyFromServer()
{
int id = _payLoad.ReadInt();
string name = string.Empty;
lock (ContainerLock())
{
ClassMetadata classMetadata = Container().ClassMetadataForID(id);
if (classMetadata != null)
{
name = classMetadata.GetName();
}
}
return(Msg.ClassNameForId.GetWriterForString(Transaction(), name));
}
/// <summary>
/// Defines the point class
/// </summary>
/// <param name="virtualMachine">The VM to define for</param>
public static (ClassType, ManagedFunction) DefinePointClass(VirtualMachine virtualMachine)
{
var intType = virtualMachine.TypeProvider.FindPrimitiveType(PrimitiveTypes.Int);
var voidType = virtualMachine.TypeProvider.FindPrimitiveType(PrimitiveTypes.Void);
var pointMetadata = new ClassMetadata("Point");
pointMetadata.DefineField(new FieldDefinition("x", intType, AccessModifier.Public));
pointMetadata.DefineField(new FieldDefinition("y", intType, AccessModifier.Public));
pointMetadata.CreateFields();
virtualMachine.ClassMetadataProvider.Add(pointMetadata);
var pointType = virtualMachine.TypeProvider.FindClassType("Point");
return(pointType, CreateDefaultConstructor(virtualMachine, pointType));
}
private static TypeStatement NormalizeLiteralTypeStatement(
TypeStatement type,
ClassMetadata classMetadata,
AbstractSyntaxTree ast,
TypeOverrideDetails typeOverrideDetails
)
{
if (type.IsTypeQuery)
{
var(found, className, toGenerateNode) = GetNode(
type.TypeQuery.Class,
ast
);
if (!found)
{
return(type);
}
var typeNode = toGenerateNode.Children.FirstOrDefault(
a => a.IdentifierStr == type.TypeQuery.Type
);
if (typeNode is not null)
{
var typedType = GenericTypeIdentifier.Identify(
typeNode.Last,
classMetadata,
ast,
typeOverrideDetails
);
return(typedType);
}
}
if (type.IsLiteral)
{
type.Name = GenerationIdentifiedTypes.CachedEntity;
}
var literalGenericTypes = type.GenericTypes.Where(
a => a.IsLiteral
);
foreach (var genericType in literalGenericTypes)
{
genericType.Name = GenerationIdentifiedTypes.CachedEntity;
}
return(type);
}
// Our QConPath objects are just placeholders to fields,
// so the parents are reachable.
// If we find a "real" constraint, we throw the QPath
// out and replace it with the other constraint.
private void Morph(BooleanByRef removeExisting, QCon newConstraint, IReflectClass
claxx)
{
bool mayMorph = true;
if (claxx != null)
{
ClassMetadata yc = i_trans.Container().ProduceClassMetadata(claxx);
if (yc != null)
{
IEnumerator i = IterateChildren();
while (i.MoveNext())
{
QField qf = ((QCon)i.Current).GetField();
if (!yc.HasField(i_trans.Container(), qf.Name()))
{
mayMorph = false;
break;
}
}
}
}
// }
if (mayMorph)
{
IEnumerator j = IterateChildren();
while (j.MoveNext())
{
newConstraint.AddConstraint((QCon)j.Current);
}
if (HasJoins())
{
IEnumerator k = IterateJoins();
while (k.MoveNext())
{
QConJoin qcj = (QConJoin)k.Current;
qcj.ExchangeConstraint(this, newConstraint);
newConstraint.AddJoin(qcj);
}
}
i_parent.ExchangeConstraint(this, newConstraint);
removeExisting.value = true;
}
else
{
i_parent.AddConstraint(newConstraint);
}
}
public string ToString(ClassMetadata classMetadata)
{
var orderStr = new StringBuilder();
var i = 0;
foreach (var subOrder in subOrders)
{
if (i > 0)
{
orderStr.Append(",");
}
orderStr.Append(subOrder.ToString(classMetadata));
i++;
}
return(orderStr.Length > 0 ? string.Format(" ORDER BY {0}", orderStr) : "");
}
private ObjectHeader(ObjectContainerBase container, ClassMetadata
classMetadata, IReadWriteBuffer reader)
{
var classID = reader.ReadInt();
_marshallerFamily = ReadMarshallerFamily(reader, classID);
classID = NormalizeID(classID);
_classMetadata = (classMetadata != null
? classMetadata
: container.ClassMetadataForID
(classID));
// This check has been added to cope with defragment in debug mode: SlotDefragment#setIdentity()
// will trigger calling this constructor with a source db class metadata and a target db stream,
// thus _classMetadata==null. There may be a better solution, since this call is just meant to
// skip the object header.
_headerAttributes = SlotFormat().ReadHeaderAttributes((ByteArrayBuffer) reader);
}
private static string UnionTypeCheck(
Node node,
ClassMetadata classMetadata
)
{
var firstNode = node.Children.FirstOrDefault(
childNode => childNode.Kind != SyntaxKind.NullKeyword &&
childNode.Kind != SyntaxKind.UndefinedKeyword
);
return(GetFromNode(
firstNode,
firstNode.Kind,
classMetadata
));
}
public virtual IActivationDepth ActivationDepthFor(ClassMetadata classMetadata, ActivationMode
mode)
{
if (mode.IsPrefetch())
{
return(new LegacyActivationDepth(1, mode));
}
var globalLegacyActivationDepth = ConfigImpl(classMetadata).ActivationDepth();
var config = classMetadata.ConfigOrAncestorConfig();
var defaultDepth = null == config
? globalLegacyActivationDepth
: config.AdjustActivationDepth
(globalLegacyActivationDepth);
return(new LegacyActivationDepth(defaultDepth, mode));
}
private FileUsageStatsCollector.InstanceUsage ClassSlotUsage(ClassMetadata clazz)
{
if (!clazz.HasClassIndex())
{
return(new FileUsageStatsCollector.InstanceUsage(0, 0));
}
IMiscCollector miscCollector = ((IMiscCollector)MiscCollectors[clazz.GetName()]);
LongByRef slotUsage = new LongByRef();
LongByRef miscUsage = new LongByRef();
BTreeClassIndexStrategy index = (BTreeClassIndexStrategy)clazz.Index();
index.TraverseAll(_db.SystemTransaction(), new _IVisitor4_166(this, slotUsage, miscCollector
, miscUsage));
return(new FileUsageStatsCollector.InstanceUsage(slotUsage.value, miscUsage.value
));
}
public override void Write(Transaction trans, ClassMetadata clazz, ClassAspect aspect
, ByteArrayBuffer writer)
{
base.Write(trans, clazz, aspect, writer);
if (!(aspect is FieldMetadata))
{
return;
}
var field = (FieldMetadata)aspect;
if (!HasBTreeIndex(field))
{
return;
}
writer.WriteIDOf(trans, field.GetIndex(trans));
}
private void CheckFieldTypeID()
{
int id = _fieldType != null?_fieldType.GetID() : 0;
if (_fieldTypeID == 0)
{
_fieldTypeID = id;
return;
}
if (id > 0 && id != _fieldTypeID)
{
// wrong type, refactoring, field should be turned off
// TODO: it would be cool to log something here
_fieldType = null;
}
}
/// <exception cref="System.Exception"></exception>
public virtual void TestReflectField()
{
Store(new OldVersionReflectFieldAfterRefactorTestCase.ItemBefore(IdValue));
Reopen();
FileSession().StoredClass(typeof(OldVersionReflectFieldAfterRefactorTestCase.ItemBefore
)).Rename(typeof(OldVersionReflectFieldAfterRefactorTestCase.ItemAfter).FullName
);
Reopen();
ClassMetadata classMetadata = Container().ClassMetadataForName(typeof(OldVersionReflectFieldAfterRefactorTestCase.ItemAfter
).FullName);
ByRef originalField = new ByRef();
classMetadata.TraverseDeclaredFields(new _IProcedure4_37(originalField));
Assert.AreEqual(typeof(int).FullName, ((FieldMetadata)originalField.value).GetStoredType
().GetName());
}
public void IterateTopLevelClasses(IVisitor4 visitor)
{
ClassMetadataIterator i = Iterator();
while (i.MoveNext())
{
ClassMetadata classMetadata = i.CurrentClass();
if (!classMetadata.IsInternal())
{
if (classMetadata.GetAncestor() == null)
{
visitor.Visit(classMetadata);
}
}
}
}
public static ITypeHandler4 CorrectHandlerVersion(IHandlerVersionContext context,
ITypeHandler4 typeHandler, ClassMetadata classMetadata)
{
ITypeHandler4 correctHandlerVersion = CorrectHandlerVersion(context, typeHandler);
if (typeHandler != correctHandlerVersion)
{
CorrectClassMetadataOn(correctHandlerVersion, classMetadata);
if (correctHandlerVersion is ArrayHandler)
{
ArrayHandler arrayHandler = (ArrayHandler)correctHandlerVersion;
CorrectClassMetadataOn(arrayHandler.DelegateTypeHandler(), classMetadata);
}
}
return(correctHandlerVersion);
}
public override bool CreateClassMetadata(ClassMetadata clazz, IReflectClass claxx
, ClassMetadata superClazz)
{
Write(Msg.CreateClass.GetWriterForString(SystemTransaction(), Config().ResolveAliasRuntimeName
(claxx.GetName())));
Msg resp = GetResponse();
if (resp == null)
{
return(false);
}
if (resp.Equals(Msg.Failed))
{
// if the class can not be created on the server, send class meta to the server.
SendClassMeta(claxx);
resp = GetResponse();
}
if (resp.Equals(Msg.Failed))
{
if (ConfigImpl.ExceptionsOnNotStorable())
{
throw new ObjectNotStorableException(claxx);
}
return(false);
}
if (!resp.Equals(Msg.ObjectToClient))
{
return(false);
}
MsgObject message = (MsgObject)resp;
StatefulBuffer bytes = message.Unmarshall();
if (bytes == null)
{
return(false);
}
bytes.SetTransaction(SystemTransaction());
if (!base.CreateClassMetadata(clazz, claxx, superClazz))
{
return(false);
}
clazz.SetID(message.GetId());
clazz.ReadName1(SystemTransaction(), bytes);
ClassCollection().AddClassMetadata(clazz);
ClassCollection().ReadClassMetadata(clazz, claxx);
return(true);
}
public void TestDeallocationClassFields()
{
using (var container = this.CreateContainer())
{
var gc = container.VirtualMachine.GarbageCollector;
var intType = container.VirtualMachine.TypeProvider.FindPrimitiveType(PrimitiveTypes.Int);
(var pointType, var pointConstructor) = TestHelpers.DefinePointClass(container.VirtualMachine);
var listMetadata = new ClassMetadata("List");
listMetadata.DefineField(new FieldDefinition("head", pointType, AccessModifier.Public));
listMetadata.CreateFields();
container.VirtualMachine.ClassMetadataProvider.Add(listMetadata);
var listType = container.VirtualMachine.TypeProvider.FindClassType("List");
var listConstructorFunction = TestHelpers.CreateDefaultConstructor(container.VirtualMachine, listType);
var func = new ManagedFunction(
new FunctionDefinition("main", new List <BaseType>(), intType),
new List <BaseType>()
{
listType
},
new List <Instruction>()
{
new Instruction(OpCodes.NewObject, ".constructor", listType, new List <BaseType>()),
new Instruction(OpCodes.StoreLocal, 0),
new Instruction(OpCodes.LoadLocal, 0),
new Instruction(OpCodes.NewObject, ".constructor", pointType, new List <BaseType>()),
new Instruction(OpCodes.StoreField, "List::head"),
new Instruction(OpCodes.Call, "std.gc.collect", new List <BaseType>()),
new Instruction(OpCodes.LoadInt, 0),
new Instruction(OpCodes.Return)
});
container.VirtualMachine.LoadFunctionsAsAssembly(new List <ManagedFunction>()
{
func,
pointConstructor,
listConstructorFunction
});
var result = container.Execute();
Assert.AreEqual(1, gc.Deallocations.Count);
Assert.AreEqual(0, gc.Deallocations[0].Count);
}
}
public static TypeStatement Identify(
Node node,
ClassMetadata classMetadata,
TypeScriptAST ast,
TypeOverrideDetails typeOverrideDetails
)
{
var typeIdentifier = TypeIdentifier.Identify(
node,
classMetadata
);
var isTypeAlias = AliasTypeIdentifier.Identify(
node,
ast
);
var aliasType = isTypeAlias ? AliasTypeStatementIdentifier.Identify(
typeIdentifier,
classMetadata,
ast,
typeOverrideDetails
) : null;
var isLiteral = IsTypeLiteralRule.Check(
node
) || TypeLiteralIdentifier.Identify(
typeIdentifier
);
var genericTypes = new List <TypeStatement>();
if (node is TypeReferenceNode referenceNode &&
referenceNode.TypeArguments != null &&
referenceNode.TypeArguments.Any())
{
foreach (var typeArgument in referenceNode.TypeArguments)
{
if (typeArgument is Node typeArgumentNode)
{
genericTypes.Add(
Identify(
typeArgumentNode,
classMetadata,
ast,
typeOverrideDetails
)
);
}
}
}
public Update(ClassMetadata metadata) : base(90)
{
TableName = metadata.TableName;
Alias = "t";
Fields = new List <string>();
foreach (var column in metadata.Columns.Select(c => c.Value).ToList())
{
if (column.IsIdentifier ||
column.IsCustomColumn ||
(column.IsRelationship && column.RelationshipType == RelationshipType.OneToMany)
)
{
continue;
}
Fields.Add(column.ColumnName);
}
}
private FieldMetadata FieldMetadataFrom(QField qField, ClassMetadata
type)
{
var existingField = qField.GetFieldMetadata();
if (existingField != null)
{
return(existingField);
}
var field = type.FieldMetadataForName(qField.Name());
if (field != null)
{
field.Alive();
}
return(field);
}
internal ClassMetadata ProduceClassMetadata(IReflectClass reflectClazz)
{
ClassMetadata classMetadata = ClassMetadataForReflectClass(reflectClazz);
if (classMetadata != null)
{
return(classMetadata);
}
ClassMetadata classBeingCreated = (ClassMetadata)_creating.Get(reflectClazz);
if (classBeingCreated != null)
{
return(classBeingCreated);
}
ClassMetadata newClassMetadata = new ClassMetadata(Container(), reflectClazz);
_creating.Put(reflectClazz, newClassMetadata);
try
{
if (!CreateClassMetadata(newClassMetadata, reflectClazz))
{
return(null);
}
// ObjectContainerBase#createClassMetadata may add the ClassMetadata already,
// so we have to check again
if (!IsRegistered(reflectClazz))
{
AddClassMetadata(newClassMetadata);
_classInits.Process(newClassMetadata);
}
else
{
RegisterClassMetadataById(newClassMetadata);
if (newClassMetadata.AspectsAreNull())
{
_classInits.Process(newClassMetadata);
}
}
Container().SetDirtyInSystemTransaction(this);
}
finally
{
_creating.Remove(reflectClazz);
}
return(newClassMetadata);
}
internal ClassMetadata ClassMetadataForReflectClass(IReflectClass reflectClazz)
{
ClassMetadata cached = (ClassMetadata)_classMetadataByClass.Get(reflectClazz);
if (cached != null)
{
return(cached);
}
ClassMetadata byName = (ClassMetadata)_classMetadataByName.Get(reflectClazz.GetName
());
if (byName != null)
{
return(byName);
}
return(ReadClassMetadata(reflectClazz));
}
public override void Defrag(ClassMetadata classMetadata, ClassAspect aspect, LatinStringIO
sio, DefragmentContextImpl context)
{
context.IncrementStringOffset(sio);
if (!(aspect is FieldMetadata))
{
return;
}
if (((FieldMetadata)aspect).IsVirtual())
{
return;
}
// handler ID
context.CopyID();
// skip primitive/array/narray attributes
context.IncrementOffset(1);
}
private void AssociateYapClass(Transaction a_trans, object a_object)
{
if (a_object == null)
{
}
else
{
//It seems that we need not result the following field
//i_object = null;
//i_comparator = Null.INSTANCE;
//i_classMetadata = null;
// FIXME: Setting the YapClass to null will prevent index use
// If the field is typed we can guess the right one with the
// following line. However this does break some SODA test cases.
// Revisit!
// if(i_field != null){
// i_classMetadata = i_field.getYapClass();
// }
_classMetadata = a_trans.Container().ProduceClassMetadata(a_trans.Reflector().ForObject
(a_object));
if (_classMetadata != null)
{
i_object = _classMetadata.GetComparableObject(a_object);
if (a_object != i_object)
{
i_attributeProvider = _classMetadata.Config().QueryAttributeProvider();
_classMetadata = a_trans.Container().ProduceClassMetadata(a_trans.Reflector().ForObject
(i_object));
}
if (_classMetadata != null)
{
_classMetadata.CollectConstraints(a_trans, this, i_object, new _IVisitor4_84(this
));
}
else
{
AssociateYapClass(a_trans, null);
}
}
else
{
AssociateYapClass(a_trans, null);
}
}
}
public virtual void CheckClassHasFields(ClassMetadata classMetadata)
{
if (classMetadata.AspectsAreNull() || classMetadata.DeclaredAspectCount() == 0)
{
var name = classMetadata.GetName();
string[] ignoredPackages = {"java.util."};
for (var i = 0; i < ignoredPackages.Length; i++)
{
if (name.IndexOf(ignoredPackages[i]) == 0)
{
return;
}
}
if (IsDb4oClass(classMetadata))
{
return;
}
OnDiagnostic(new ClassHasNoFields(name));
}
}
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz
, ByteArrayBuffer reader)
{
var indexID = reader.ReadInt();
if (!stream.MaintainsIndices() || !(stream is LocalObjectContainer))
{
return;
}
if (Btree(clazz) != null)
{
return;
}
clazz.Index().Read(stream, ValidIndexId(indexID));
if (IsOldClassIndex(indexID))
{
new ClassIndexesToBTrees_5_5().Convert((LocalObjectContainer) stream, indexID, Btree
(clazz));
stream.SetDirtyInSystemTransaction(clazz);
}
}
protected virtual FieldMetadata FromSpec(RawFieldSpec spec, ObjectContainerBase stream
, ClassMetadata containingClass)
{
if (spec == null)
{
return null;
}
var name = spec.Name();
if (spec.IsVirtualField())
{
return stream._handlers.VirtualFieldByName(name);
}
if (spec.IsTranslator())
{
return new TranslatedAspect(containingClass, name);
}
if (spec.IsField())
{
return new FieldMetadata(containingClass, name, spec.FieldTypeID(), spec.IsPrimitive
(), spec.IsArray(), spec.IsNArray());
}
return new UnknownTypeHandlerAspect(containingClass, name);
}
