Пример #1
0
 public Program()
 {
     Name = "";
     CommandList = new CommandList();
     Functions = new List<UserDefinedFunction>();
     UserDefinedTypes = new TypeDescriptors();
     //EntryPoints = new Dictionary<UserDefinedFunction, int>();
 }
        public void Should_Deserialize_TypeDescriptors()
        {
            var bytes           = Serialize();
            var typeDescriptors = new TypeDescriptors();

            typeDescriptors.Deserialize(bytes);
            Assert.AreEqual(8, typeDescriptors.Types.Count);
            CollectionAssert.AreEqual(CreateTypeDescriptors().Types, typeDescriptors.Types);
        }
Пример #3
0
        private void Init(IsolationLevel il)
        {
            _il = il;
            _dbDatabaseProvider = DatabaseProviderFactory.CreateDatabaseProvider(_dbType);

            //开始缓存数据结构,并初始化dbset
            _typeDescriptors = TypeDescriptors.GetTypeDescriptors(this);
            //初始化数据链接
            InitDb();
            //初始化数据库结构
            InternalAdoSession.BeginTransaction(_il);
        }
        private TypeDescriptors CreateTypeDescriptors()
        {
            var typeDescriptors = new TypeDescriptors();

            typeDescriptors.AddKnownType(typeof(string));
            typeDescriptors.AddKnownType(typeof(object));
            typeDescriptors.AddKnownType(typeof(short));
            typeDescriptors.AddKnownType(typeof(int));
            typeDescriptors.AddKnownType(typeof(long));
            typeDescriptors.AddKnownType(typeof(double));
            typeDescriptors.AddKnownType(typeof(decimal));
            typeDescriptors.AddKnownType(typeof(float));
            return(typeDescriptors);
        }
Пример #5
0
        public DbContext(string connStr, IDatabaseProvider databaseProvider, IsolationLevel il = IsolationLevel.ReadCommitted)
        {
            _il = il;
            _dbConnectionStr = connStr;
            var newDatabase = DatabaseProviderFactory.CreateDatabaseProvider("", databaseProvider);

            _dbDatabaseProvider = newDatabase;
            _dbType             = newDatabase.DatabaseType;

            //开始缓存数据结构,并初始化dbset
            _typeDescriptors = TypeDescriptors.GetTypeDescriptors(this);
            //初始化数据链接
            InitDb();
            //初始化数据库结构
            InternalAdoSession.BeginTransaction(_il);
        }
Пример #6
0
        private void Init(string ConnectionStr, string ProviderName, IsolationLevel il)
        {
            _il = il;
            Checks.NotNull(ConnectionStr, "ConnectionStr");
            Checks.NotNull(ProviderName, "ProviderName");
            //开始初始化
            _dbConfig = new DbConfig();
            _dbConfig.ConnectionStr = ConnectionStr;
            _dbConfig.ProviderName  = ProviderName;

            //开始缓存数据结构,并初始化dbset
            _typeDescriptors = TypeDescriptors.GetTypeDescriptors(this);

            this._dbContextServiceProvider = DbContextServiceProviderFactory.CreateDbConnection(_dbConfig);
            //初始化数据链接
            InitDb();
            //初始化数据库结构
            InternalAdoSession.BeginTransaction(_il);
        }
Пример #7
0
        public override void OnUpdate(EventBean[] newData, EventBean[] oldData, NamedWindowRootViewInstance namedWindowRootView, EventTableIndexRepository indexRepository)
        {
            // If new data is filled, it is not a delete
            RevisionEventBeanDeclared revisionEvent;
            Object key;

            if ((newData == null) || (newData.Length == 0))
            {
                // we are removing an event
                revisionEvent = (RevisionEventBeanDeclared)oldData[0];
                key           = revisionEvent.Key;
                _statePerKey.Remove(key);

                // Insert into indexes for fast deletion, if there are any
                foreach (EventTable table in indexRepository.GetTables())
                {
                    table.Remove(oldData);
                }

                // make as not the latest event since its due for removal
                revisionEvent.IsLatest = false;

                namedWindowRootView.UpdateChildren(null, oldData);
                return;
            }

            revisionEvent = (RevisionEventBeanDeclared)newData[0];
            EventBean underlyingEvent    = revisionEvent.UnderlyingFullOrDelta;
            EventType underyingEventType = underlyingEvent.EventType;

            // obtain key values
            key = null;
            RevisionTypeDesc typesDesc       = null;
            bool             isBaseEventType = false;

            if (underyingEventType == _baseEventType)
            {
                key             = PropertyUtility.GetKeys(underlyingEvent, _fullKeyGetters);
                isBaseEventType = true;
            }
            else
            {
                typesDesc = TypeDescriptors.Get(underyingEventType);

                // if this type cannot be found, check all supertypes, if any
                if (typesDesc == null)
                {
                    IEnumerable <EventType> superTypes = underyingEventType.DeepSuperTypes;
                    if (superTypes != null)
                    {
                        foreach (var superType in superTypes)
                        {
                            if (superType == _baseEventType)
                            {
                                key             = PropertyUtility.GetKeys(underlyingEvent, _fullKeyGetters);
                                isBaseEventType = true;
                                break;
                            }
                            typesDesc = TypeDescriptors.Get(superType);
                            if (typesDesc != null)
                            {
                                TypeDescriptors.Put(underyingEventType, typesDesc);
                                key = PropertyUtility.GetKeys(underlyingEvent, typesDesc.KeyPropertyGetters);
                                break;
                            }
                        }
                    }
                }
                else
                {
                    key = PropertyUtility.GetKeys(underlyingEvent, typesDesc.KeyPropertyGetters);
                }
            }

            // get the state for this key value
            RevisionStateDeclared revisionState = _statePerKey.Get(key);

            // Delta event and no full
            if ((!isBaseEventType) && (revisionState == null))
            {
                return; // Ignore the event, its a delta and we don't currently have a full event for it
            }

            // New full event
            if (revisionState == null)
            {
                revisionState = new RevisionStateDeclared(underlyingEvent, null, null);
                _statePerKey.Put(key, revisionState);

                // prepare revison event
                revisionEvent.LastBaseEvent = underlyingEvent;
                revisionEvent.Key           = key;
                revisionEvent.Holders       = null;
                revisionEvent.IsLatest      = true;

                // Insert into indexes for fast deletion, if there are any
                foreach (EventTable table in indexRepository.GetTables())
                {
                    table.Add(newData);
                }

                // post to data window
                revisionState.LastEvent = revisionEvent;
                namedWindowRootView.UpdateChildren(new EventBean[] { revisionEvent }, null);
                return;
            }

            // new version
            long versionNumber = revisionState.IncRevisionNumber();

            // Previously-seen full event
            if (isBaseEventType)
            {
                revisionState.Holders             = null;
                revisionState.BaseEventUnderlying = underlyingEvent;
            }
            // Delta event to existing full event
            else
            {
                var groupNum = typesDesc.Group.GroupNum;
                var holders  = revisionState.Holders;
                if (holders == null)    // optimization - the full event sets it to null, deltas all get a new one
                {
                    holders = new RevisionBeanHolder[_groups.Length];
                }
                else
                {
                    holders = ArrayCopy(holders);   // preserve the last revisions
                }

                // add the new revision for a property group on top
                holders[groupNum]     = new RevisionBeanHolder(versionNumber, underlyingEvent, typesDesc.ChangesetPropertyGetters);
                revisionState.Holders = holders;
            }

            // prepare revision event
            revisionEvent.LastBaseEvent = revisionState.BaseEventUnderlying;
            revisionEvent.Holders       = revisionState.Holders;
            revisionEvent.Key           = key;
            revisionEvent.IsLatest      = true;

            // get prior event
            RevisionEventBeanDeclared lastEvent = revisionState.LastEvent;

            lastEvent.IsLatest = false;

            // data to post
            var newDataPost = new EventBean[] { revisionEvent };
            var oldDataPost = new EventBean[] { lastEvent };

            // Update indexes
            foreach (EventTable table in indexRepository.GetTables())
            {
                table.Remove(oldDataPost);
                table.Add(newDataPost);
            }

            // keep reference to last event
            revisionState.LastEvent = revisionEvent;

            namedWindowRootView.UpdateChildren(newDataPost, oldDataPost);
        }
Пример #8
0
 private PrimitiveType(TypeDescriptors typeDescriptor)
 {
     TypeDescriptor = typeDescriptor;
 }
Пример #9
0
 public static bool IsPrimitive(TypeDescriptors td)
 {
     return (td != TypeDescriptors.Array) && (td != TypeDescriptors.FullyQualifiedName);
 }
        /// <summary>
        /// Ctor.
        /// </summary>
        /// <param name="revisioneventTypeName">name</param>
        /// <param name="spec">specification</param>
        /// <param name="statementStopService">for stop handling</param>
        /// <param name="eventAdapterService">for nested property handling</param>
        /// <param name="eventTypeIdGenerator">The event type id generator.</param>
        public VAERevisionProcessorMerge(String revisioneventTypeName, RevisionSpec spec, StatementStopService statementStopService, EventAdapterService eventAdapterService, EventTypeIdGenerator eventTypeIdGenerator)
            : base(spec, revisioneventTypeName, eventAdapterService)
        {
            // on statement stop, remove versions
            statementStopService.StatementStopped += () => _statePerKey.Clear();
            _statePerKey = new Dictionary <Object, RevisionStateMerge>();

            // For all changeset properties, add type descriptors (property number, getter etc)
            var propertyDesc = new Dictionary <String, RevisionPropertyTypeDesc>();
            var count        = 0;

            foreach (String property in spec.ChangesetPropertyNames)
            {
                var fullGetter     = spec.BaseEventType.GetGetter(property);
                var propertyNumber = count;
                var paramList      = new RevisionGetterParameters(property, propertyNumber, fullGetter, null);

                // if there are no groups (full event property only), then simply use the full event getter
                EventPropertyGetter revisionGetter = new ProxyEventPropertyGetter(
                    eventBean =>
                {
                    var riv = (RevisionEventBeanMerge)eventBean;
                    return(riv.GetVersionedValue(paramList));
                },
                    eventBean => null,
                    eventBean => true);

                var type = spec.BaseEventType.GetPropertyType(property);
                if (type == null)
                {
                    foreach (EventType deltaType in spec.DeltaTypes)
                    {
                        var dtype = deltaType.GetPropertyType(property);
                        if (dtype != null)
                        {
                            type = dtype;
                            break;
                        }
                    }
                }

                var propertyTypeDesc = new RevisionPropertyTypeDesc(revisionGetter, paramList, type);
                propertyDesc.Put(property, propertyTypeDesc);
                count++;
            }

            count = 0;
            foreach (String property in spec.KeyPropertyNames)
            {
                var keyPropertyNumber = count;
                EventPropertyGetter revisionGetter;
                if (spec.KeyPropertyNames.Length == 1)
                {
                    revisionGetter = new ProxyEventPropertyGetter
                    {
                        ProcGet = eventBean => ((RevisionEventBeanMerge)eventBean).Key,
                        ProcIsExistsProperty = eventBean => true,
                        ProcGetFragment      = eventBean => null
                    };
                }
                else
                {
                    revisionGetter = new ProxyEventPropertyGetter
                    {
                        ProcGet = eventBean =>
                        {
                            var riv = (RevisionEventBeanMerge)eventBean;
                            return(((MultiKeyUntyped)riv.Key).Keys[keyPropertyNumber]);
                        },
                        ProcIsExistsProperty = eventBean => true,
                        ProcGetFragment      = eventBean => null
                    };
                }

                var type = spec.BaseEventType.GetPropertyType(property);
                if (type == null)
                {
                    foreach (EventType deltaType in spec.DeltaTypes)
                    {
                        var dtype = deltaType.GetPropertyType(property);
                        if (dtype != null)
                        {
                            type = dtype;
                            break;
                        }
                    }
                }
                var propertyTypeDesc = new RevisionPropertyTypeDesc(revisionGetter, null, type);
                propertyDesc.Put(property, propertyTypeDesc);
                count++;
            }

            // compile for each event type a list of getters and indexes within the overlay
            foreach (EventType deltaType in spec.DeltaTypes)
            {
                RevisionTypeDesc typeDesc = MakeTypeDesc(deltaType, spec.PropertyRevision);
                TypeDescriptors.Put(deltaType, typeDesc);
            }
            _infoFullType = MakeTypeDesc(spec.BaseEventType, spec.PropertyRevision);

            // how to handle updates to a full event
            if (spec.PropertyRevision == PropertyRevisionEnum.MERGE_DECLARED)
            {
                _updateStrategy = new UpdateStrategyDeclared(spec);
            }
            else if (spec.PropertyRevision == PropertyRevisionEnum.MERGE_NON_NULL)
            {
                _updateStrategy = new UpdateStrategyNonNull(spec);
            }
            else if (spec.PropertyRevision == PropertyRevisionEnum.MERGE_EXISTS)
            {
                _updateStrategy = new UpdateStrategyExists(spec);
            }
            else
            {
                throw new ArgumentException("Unknown revision type '" + spec.PropertyRevision + "'");
            }

            EventTypeMetadata metadata = EventTypeMetadata.CreateValueAdd(revisioneventTypeName, TypeClass.REVISION);

            RevisionEventType = new RevisionEventType(metadata, eventTypeIdGenerator.GetTypeId(revisioneventTypeName), propertyDesc, eventAdapterService);
        }
        public override void OnUpdate(EventBean[] newData, EventBean[] oldData, NamedWindowRootViewInstance namedWindowRootView, EventTableIndexRepository indexRepository)
        {
            // If new data is filled, it is not a delete
            RevisionEventBeanMerge revisionEvent;
            Object key;

            if ((newData == null) || (newData.Length == 0))
            {
                // we are removing an event
                revisionEvent = (RevisionEventBeanMerge)oldData[0];
                key           = revisionEvent.Key;
                _statePerKey.Remove(key);

                // Insert into indexes for fast deletion, if there are any
                foreach (EventTable table in indexRepository.GetTables())
                {
                    table.Remove(oldData);
                }

                // make as not the latest event since its due for removal
                revisionEvent.IsLatest = false;

                namedWindowRootView.UpdateChildren(null, oldData);
                return;
            }

            revisionEvent = (RevisionEventBeanMerge)newData[0];
            EventBean underlyingEvent    = revisionEvent.UnderlyingFullOrDelta;
            EventType underyingEventType = underlyingEvent.EventType;

            // obtain key values
            key = null;
            RevisionTypeDesc typesDesc;
            Boolean          isBaseEventType = false;

            if (underyingEventType == RevisionSpec.BaseEventType)
            {
                typesDesc       = _infoFullType;
                key             = PropertyUtility.GetKeys(underlyingEvent, _infoFullType.KeyPropertyGetters);
                isBaseEventType = true;
            }
            else
            {
                typesDesc = TypeDescriptors.Get(underyingEventType);

                // if this type cannot be found, check all supertypes, if any
                if (typesDesc == null)
                {
                    EventType[] superTypes = underyingEventType.DeepSuperTypes;
                    if (superTypes != null)
                    {
                        foreach (var superType in superTypes)
                        {
                            if (superType == RevisionSpec.BaseEventType)
                            {
                                typesDesc       = _infoFullType;
                                key             = PropertyUtility.GetKeys(underlyingEvent, _infoFullType.KeyPropertyGetters);
                                isBaseEventType = true;
                                break;
                            }
                            typesDesc = TypeDescriptors.Get(superType);
                            if (typesDesc != null)
                            {
                                TypeDescriptors.Put(underyingEventType, typesDesc);
                                key = PropertyUtility.GetKeys(underlyingEvent, typesDesc.KeyPropertyGetters);
                                break;
                            }
                        }
                    }
                }
                else
                {
                    key = PropertyUtility.GetKeys(underlyingEvent, typesDesc.KeyPropertyGetters);
                }
            }

            // get the state for this key value
            RevisionStateMerge revisionState = _statePerKey.Get(key);

            // Delta event and no full
            if ((!isBaseEventType) && (revisionState == null))
            {
                return; // Ignore the event, its a delta and we don't currently have a full event for it
            }

            // New full event
            if (revisionState == null)
            {
                revisionState = new RevisionStateMerge(underlyingEvent, null, null);
                _statePerKey.Put(key, revisionState);

                // prepare revison event
                revisionEvent.LastBaseEvent = underlyingEvent;
                revisionEvent.Key           = key;
                revisionEvent.Overlay       = null;
                revisionEvent.IsLatest      = true;

                // Insert into indexes for fast deletion, if there are any
                foreach (EventTable table in indexRepository.GetTables())
                {
                    table.Add(newData);
                }

                // post to data window
                revisionState.LastEvent = revisionEvent;
                namedWindowRootView.UpdateChildren(new EventBean[] { revisionEvent }, null);
                return;
            }

            // handle Update, changing revision state and event as required
            _updateStrategy.HandleUpdate(isBaseEventType, revisionState, revisionEvent, typesDesc);

            // prepare revision event
            revisionEvent.LastBaseEvent = revisionState.BaseEventUnderlying;
            revisionEvent.Overlay       = revisionState.Overlays;
            revisionEvent.Key           = key;
            revisionEvent.IsLatest      = true;

            // get prior event
            RevisionEventBeanMerge lastEvent = revisionState.LastEvent;

            lastEvent.IsLatest = false;

            // data to post
            var newDataPost = new EventBean[] { revisionEvent };
            var oldDataPost = new EventBean[] { lastEvent };

            // Update indexes
            foreach (EventTable table in indexRepository.GetTables())
            {
                table.Remove(oldDataPost);
                table.Add(newDataPost);
            }

            // keep reference to last event
            revisionState.LastEvent = revisionEvent;

            namedWindowRootView.UpdateChildren(newDataPost, oldDataPost);
        }
Пример #12
0
 private PrimitiveType(TypeDescriptors typeDescriptor)
 {
     TypeDescriptor = typeDescriptor;
 }
Пример #13
0
 public static bool IsPrimitive(TypeDescriptors td)
 {
     return((td != TypeDescriptors.Array) && (td != TypeDescriptors.FullyQualifiedName));
 }