public override Tuple GenerateKey(KeyInfo keyInfo, Session session)
 {
     return(Tuple.Create(seed++, seed++));
 }
 /// <summary>
 /// Converts the <paramref name="source"/> <see cref="Tuple"/> to
 /// its string representation.
 /// </summary>
 /// <param name="source">The tuple to convert.</param>
 /// <param name="format">Indicates whether to use <see cref="Format"/>,
 /// or <see cref="Tuple.ToString"/> method.</param>
 /// <returns>String representation of <paramref name="source"/> <see cref="Tuple"/>.</returns>
 public static string ToString(this Tuple source, bool format)
 {
     return(format ? source.Format() : source.ToString());
 }
 public abstract void Execute(Tuple source, string[] targets, int fieldIndex);
예제 #4
0
        public static Key Materialize(Domain domain, string nodeId,
                                      TypeInfo type, Tuple value, TypeReferenceAccuracy accuracy, bool canCache, int[] keyIndexes)
        {
            var hierarchy = type.Hierarchy;
            var keyInfo   = type.Key;

            if (keyIndexes == null)
            {
                if (value.Descriptor != keyInfo.TupleDescriptor)
                {
                    throw new ArgumentException(Strings.ExWrongKeyStructure);
                }
                if (accuracy == TypeReferenceAccuracy.ExactType)
                {
                    int typeIdColumnIndex = keyInfo.TypeIdColumnIndex;
                    if (typeIdColumnIndex >= 0 && !value.GetFieldState(typeIdColumnIndex).IsAvailable())
                    {
                        // Ensures TypeId is filled in into Keys of newly created Entities
                        value.SetValue(typeIdColumnIndex, type.TypeId);
                    }
                }
            }
            if (hierarchy != null && hierarchy.Root.IsLeaf)
            {
                accuracy = TypeReferenceAccuracy.ExactType;
                canCache = false; // No reason to cache
            }

            Key key;
            var isGenericKey = keyInfo.TupleDescriptor.Count <= WellKnown.MaxGenericKeyLength;

            if (isGenericKey)
            {
                key = CreateGenericKey(domain, nodeId, type, accuracy, value, keyIndexes);
            }
            else
            {
                if (keyIndexes != null)
                {
                    throw Exceptions.InternalError(Strings.ExKeyIndexesAreSpecifiedForNonGenericKey, OrmLog.Instance);
                }
                key = new LongKey(nodeId, type, accuracy, value);
            }
            if (!canCache)
            {
                return(key);
            }
            var keyCache = domain.KeyCache;

            lock (keyCache) {
                Key foundKey;
                if (keyCache.TryGetItem(key, true, out foundKey))
                {
                    key = foundKey;
                }
                else
                {
                    if (accuracy == TypeReferenceAccuracy.ExactType)
                    {
                        keyCache.Add(key);
                    }
                }
            }
            return(key);
        }
 public abstract void Execute(string[] source, Tuple target, int fieldIndex);
예제 #6
0
        public static Key Materialize(Domain domain, string nodeId,
                                      TypeInfo type, TypeReferenceAccuracy accuracy, params object[] values)
        {
            var keyInfo = type.Key;

            ArgumentValidator.EnsureArgumentIsInRange(values.Length, 1, keyInfo.TupleDescriptor.Count, "values");

            var tuple       = Tuple.Create(keyInfo.TupleDescriptor);
            int typeIdIndex = keyInfo.TypeIdColumnIndex;

            if (typeIdIndex >= 0)
            {
                tuple.SetValue(typeIdIndex, type.TypeId);
            }

            int tupleIndex = 0;

            if (tupleIndex == typeIdIndex)
            {
                tupleIndex++;
            }
            for (int valueIndex = 0; valueIndex < values.Length; valueIndex++)
            {
                var value = values[valueIndex];
                ArgumentValidator.EnsureArgumentNotNull(value, String.Format("values[{0}]", valueIndex));
                var entity = value as Entity;
                if (entity != null)
                {
                    entity.EnsureNotRemoved();
                    value = entity.Key;
                }
                var key = value as Key;
                if (key != null)
                {
                    if (key.TypeReference.Type.Hierarchy == type.Hierarchy)
                    {
                        typeIdIndex = -1; // Key must be fully copied in this case
                    }
                    for (int keyIndex = 0; keyIndex < key.Value.Count; keyIndex++)
                    {
                        tuple.SetValue(tupleIndex++, key.Value.GetValueOrDefault(keyIndex));
                        if (tupleIndex == typeIdIndex)
                        {
                            tupleIndex++;
                        }
                    }
                    continue;
                }
                tuple.SetValue(tupleIndex++, value);
                if (tupleIndex == typeIdIndex)
                {
                    tupleIndex++;
                }
            }
            if (tupleIndex != tuple.Count)
            {
                throw new ArgumentException(String.Format(
                                                Strings.ExSpecifiedValuesArentEnoughToCreateKeyForTypeX, type.Name));
            }

            return(Materialize(domain, nodeId, type, tuple, accuracy, false, null));
        }
예제 #7
0
        private static Key CreateGenericKey(Domain domain, string nodeId, TypeInfo type, TypeReferenceAccuracy accuracy, Tuple tuple, int[] keyIndexes)
        {
            var keyTypeInfo = domain.GenericKeyFactories.GetOrAdd(type, BuildGenericKeyFactory);

            if (keyIndexes == null)
            {
                return(keyTypeInfo.DefaultConstructor(nodeId, type, tuple, accuracy));
            }
            return(keyTypeInfo.KeyIndexBasedConstructor(nodeId, type, tuple, accuracy, keyIndexes));
        }
 /// <summary>
 /// Extracts the key part from <paramref name="tuple"/> using <see cref="OrderKeyExtractorTransform"/>.
 /// </summary>
 /// <param name="tuple">The tuple to extract the key from.</param>
 /// <returns>A tuple containing extracted order key.</returns>
 public Tuple OrderKeyExtractor(Tuple tuple)
 {
     return(OrderKeyExtractorTransform.Apply(TupleTransformType.Auto, tuple));
 }
예제 #9
0
 /// <summary>
 ///   Initializes a new instance of this class.
 /// </summary>
 /// <param name="source">The <see cref="UnaryProvider.Source"/> property value.</param>
 /// <param name="key">Wrapped to <see cref="Key"/> property value.</param>
 public SeekProvider(CompilableProvider source, Tuple key)
     : base(ProviderType.Seek, source)
 {
     Key = () => key;
     Initialize();
 }
예제 #10
0
 internal static Key Create(Domain domain, string nodeId, TypeInfo type, TypeReferenceAccuracy accuracy, Tuple value)
 {
     return(KeyFactory.Materialize(domain, nodeId, type, value, accuracy, false, null));
 }
        public static int ExtractTypeId(TypeInfo type, TypeIdRegistry typeIdRegistry, Tuple tuple, int typeIdIndex, out TypeReferenceAccuracy accuracy)
        {
            accuracy = TypeReferenceAccuracy.Hierarchy;
            if (type.IsInterface)
            {
                accuracy = TypeReferenceAccuracy.BaseType;
            }

            if (typeIdIndex < 0)
            {
                if (type.IsLeaf)
                {
                    accuracy = TypeReferenceAccuracy.ExactType;
                }
                return(typeIdRegistry.GetTypeId(type));
            }

            accuracy = TypeReferenceAccuracy.ExactType;
            TupleFieldState state;
            var             value = tuple.GetValue <int>(typeIdIndex, out state);

            if (type.IsLeaf)
            {
                return(state.HasValue() ? typeIdRegistry.GetTypeId(type) : TypeInfo.NoTypeId);
            }
            // Hack here: 0 (default) = TypeInfo.NoTypeId
            return(value);
        }
예제 #12
0
        /// <summary>
        /// Creates <see cref="Key"/> instance
        /// for the specified <see cref="Entity"/> <paramref name="type"/>,
        /// with specified <paramref name="value"/>, <paramref name="accuracy"/> and <paramref name="nodeId"/>.
        /// </summary>
        /// <param name="domain">Domain to use.</param>
        /// <param name="nodeId">Node identifier to use.</param>
        /// <param name="type">Entity type.</param>
        /// <param name="accuracy">Key accuracy.</param>
        /// <param name="value">Key values.</param>
        /// <returns>A newly created or existing <see cref="Key"/> instance.</returns>
        public static Key Create([NotNull] Domain domain, [NotNull] string nodeId, [NotNull] Type type, TypeReferenceAccuracy accuracy, [NotNull] Tuple value)
        {
            ArgumentValidator.EnsureArgumentNotNull(domain, "domain");
            ArgumentValidator.EnsureArgumentNotNull(type, "type");
            ArgumentValidator.EnsureArgumentNotNull(value, "value");

            return(Create(domain, nodeId, domain.Model.Types[type], accuracy, value));
        }
예제 #13
0
 /// <summary>
 /// Creates <see cref="Key"/> instance
 /// for the specified <see cref="Entity"/> <paramref name="type"/>,
 /// with specified <paramref name="value"/> and <paramref name="accuracy"/>.
 /// </summary>
 /// <param name="domain">Domain to use.</param>
 /// <param name="type">Entity type.</param>
 /// <param name="accuracy">Key accuracy.</param>
 /// <param name="value">Key values.</param>
 /// <returns>A newly created or existing <see cref="Key"/> instance.</returns>
 public static Key Create([NotNull] Domain domain, [NotNull] Type type, TypeReferenceAccuracy accuracy, [NotNull] Tuple value)
 {
     return(Create(domain, WellKnown.DefaultNodeId, type, accuracy, value));
 }
예제 #14
0
 /// <summary>
 /// Creates <see cref="Key"/> instance
 /// for the specified <see cref="Entity"/> type <typeparamref name="T"/>
 /// and with specified <paramref name="value"/>.
 /// </summary>
 /// <typeparam name="T">Type of <see cref="Entity"/> descendant to get <see cref="Key"/> for.</typeparam>
 /// <param name="domain">Domain to use.</param>
 /// <param name="value">Key value.</param>
 /// <returns>
 /// A newly created or existing <see cref="Key"/> instance.
 /// </returns>
 public static Key Create <T>([NotNull] Domain domain, [NotNull] Tuple value)
     where T : IEntity
 {
     return(Create(domain, WellKnown.DefaultNodeId, typeof(T), TypeReferenceAccuracy.BaseType, value));
 }
예제 #15
0
        internal Tuple CreateTuple()
        {
            var descriptor = TypeReference.Type.Key.TupleDescriptor;

            return(Tuple.Create(descriptor));
        }
예제 #16
0
        public void FieldAccessTest()
        {
            const int       iterationCount = 10000000;
            TupleDescriptor descriptor     = TupleDescriptor.Create(shortFieldTypes);
            Tuple           tuple          = Tuple.Create(descriptor);

            for (int i = 0; i < iterationCount; i++)
            {
                tuple.SetValue(0, (object)i);
            }
            for (int i = 0; i < iterationCount; i++)
            {
                TupleFieldState state;
                tuple.GetValue(0, out state);
            }

            for (int i = 0; i < iterationCount; i++)
            {
                tuple.SetValue(0, i);
            }
            for (int i = 0; i < iterationCount; i++)
            {
                tuple.GetValue <int>(0);
            }
            for (int i = 0; i < iterationCount; i++)
            {
                TupleFieldState state;
                tuple.GetValue <int>(0, out state);
            }
            for (int i = 0; i < iterationCount; i++)
            {
                TupleFieldState state;
                tuple.GetValue <int?>(0, out state);
            }

            using (new Measurement("Tuple.SetValue?", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    tuple.SetValue(0, null);
                }
            using (new Measurement("Tuple.SetValue", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    tuple.SetValue(0, (object)i);
                }
            using (new Measurement("Tuple.GetValue", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    tuple.GetValue(0);
                }
            using (new Measurement("Tuple.GetValue(_,_)", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    TupleFieldState state;
                    tuple.GetValue(0, out state);
                }
            using (new Measurement("Tuple.GetValueOrDefault", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    tuple.GetValueOrDefault(0);
                }

            using (new Measurement("Tuple.SetValue<T>", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    tuple.SetValue(0, i);
                }
            using (new Measurement("Tuple.GetValue<T>", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    tuple.GetValue <int>(0);
                }
            using (new Measurement("Tuple.GetValue<T>(_,_)", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    TupleFieldState state;
                    tuple.GetValue <int>(0, out state);
                }
            using (new Measurement("Tuple.GetValueOrDefault<T>", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    tuple.GetValueOrDefault <int>(0);
                }

            using (new Measurement("Tuple.SetValue<T?>", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    tuple.SetValue(0, new int?(i));
                }
            using (new Measurement("Tuple.GetValue<T?>", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    tuple.GetValue <int?>(0);
                }
            using (new Measurement("Tuple.GetValue<T?>(_,_)", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    TupleFieldState state;
                    tuple.GetValue <int?>(0, out state);
                }
            using (new Measurement("Tuple.GetValueOrDefault<T?>", iterationCount))
                for (int i = 0; i < iterationCount; i++)
                {
                    tuple.GetValueOrDefault <int?>(0);
                }
        }