public async Task <SampleTableEntry> SaveAsync(SampleTableEntry sampleTableEntry)
        {
            var context = new Amazon.DynamoDBv2.DataModel.DynamoDBContext(_dynamoDbClient);

            await context.SaveAsync(new SampleTable
            {
                PartitionKey = sampleTableEntry.PartitionKey,
                SortKey      = sampleTableEntry.SortKey
            });

            return(sampleTableEntry);
        }
Example #2
0
        public void Denormalize(DynamoDBContext context)
        {
            // analyze all PropertyStorage configs and denormalize data into other properties
            // all data must exist in PropertyStorage objects prior to denormalization

            foreach (var property in Properties)
            {
                // only add non-ignored properties
                if (property.IsIgnored)
                {
                    continue;
                }

                property.Validate(context);
                AddPropertyStorage(property);

                string propertyName = property.PropertyName;

                foreach (var index in property.Indexes)
                {
                    var gsi = index as PropertyStorage.GSI;
                    if (gsi != null)
                    {
                        AddGSIConfigs(gsi.IndexNames, propertyName, gsi.IsHashKey);
                    }

                    var lsi = index as PropertyStorage.LSI;
                    if (lsi != null)
                    {
                        AddLSIConfigs(lsi.IndexNames, propertyName);
                    }
                }
            }

            if (this.HashKeyPropertyNames.Count == 0)
            {
                throw new InvalidOperationException("No hash key configured for type " + TargetTypeInfo.FullName);
            }
        }
Example #3
0
        /// <summary>
        /// Validates configurations and sets required fields
        /// </summary>
        public void Validate(DynamoDBContext context)
        {
            if (IsVersion)
            {
                Utils.ValidateVersionType(MemberType);    // no conversion is possible, so type must be a nullable primitive
            }
            if (IsHashKey && IsRangeKey)
            {
                throw new InvalidOperationException("Property " + PropertyName + " cannot be both hash and range key");
            }

            if (ConverterType != null)
            {
                if (StoreAsEpoch)
                {
                    throw new InvalidOperationException("Converter for " + PropertyName + " must not be set at the same time as StoreAsEpoch is set to true");
                }

                if (!Utils.CanInstantiateConverter(ConverterType) || !Utils.ImplementsInterface(ConverterType, typeof(IPropertyConverter)))
                {
                    throw new InvalidOperationException("Converter for " + PropertyName + " must be instantiable with no parameters and must implement IPropertyConverter");
                }

                this.Converter = Utils.InstantiateConverter(ConverterType, context) as IPropertyConverter;
            }

            IPropertyConverter converter;

            if (context.ConverterCache.TryGetValue(MemberType, out converter) && converter != null)
            {
                this.Converter = converter;
            }

            foreach (var index in Indexes)
            {
                IndexNames.AddRange(index.IndexNames);
            }
        }
Example #4
0
        public ItemStorageConfig GetConfig(Type type, DynamoDBFlatConfig flatConfig)
        {
            lock (Cache)
            {
                ConfigTableCache tableCache;
                if (!Cache.TryGetValue(type, out tableCache))
                {
                    var baseStorageConfig = CreateStorageConfig(type, null);
                    tableCache  = new ConfigTableCache(baseStorageConfig);
                    Cache[type] = tableCache;
                }

                string actualTableName = DynamoDBContext.GetTableName(tableCache.BaseTableName, flatConfig);

                ItemStorageConfig config;
                if (!tableCache.Cache.TryGetValue(actualTableName, out config))
                {
                    config = CreateStorageConfig(type, actualTableName);
                    tableCache.Cache[actualTableName] = config;
                }
                return(config);
            }
        }
Example #5
0
 internal BatchGet(DynamoDBContext context, DynamoDBFlatConfig config)
 {
     Context = context;
     Config  = config;
     Keys    = new List <Key>();
 }
Example #6
0
 public S3LinkConverter(DynamoDBContext context)
 {
     this.context = context;
 }
Example #7
0
 internal BatchWrite(DynamoDBContext context, DynamoDBFlatConfig config)
 {
     Context = context;
     Config  = config;
 }
Example #8
0
 internal AsyncSearch(DynamoDBContext source, DynamoDBContext.ContextSearch contextSearch)
 {
     SourceContext  = source;
     DocumentSearch = contextSearch.Search;
     Config         = contextSearch.FlatConfig;
 }
Example #9
0
 public ItemStorageConfigCache(DynamoDBContext context)
 {
     Cache   = new Dictionary <Type, ConfigTableCache>();
     Context = context;
 }
Example #10
0
        public ItemStorageConfig GetConfig(Type type, DynamoDBFlatConfig flatConfig, bool conversionOnly = false)
        {
            ConfigTableCache  tableCache = null;
            ItemStorageConfig config;

            string actualTableName = null;

            try
            {
                _readerWriterLockSlim.EnterReadLock();

                Cache.TryGetValue(type, out tableCache);
                if (tableCache != null)
                {
                    // If this type is only used for conversion, do not attempt to populate the config from the table
                    if (conversionOnly)
                    {
                        return(tableCache.BaseTypeConfig);
                    }

                    actualTableName = DynamoDBContext.GetTableName(tableCache.BaseTableName, flatConfig);

                    if (tableCache.Cache.TryGetValue(actualTableName, out config))
                    {
                        return(config);
                    }
                }
            }
            finally
            {
                if (_readerWriterLockSlim.IsReadLockHeld)
                {
                    _readerWriterLockSlim.ExitReadLock();
                }
            }

            try
            {
                _readerWriterLockSlim.EnterWriteLock();

                if (tableCache == null)
                {
                    // Check to see if another thread go the write lock before this thread and filled the cache.
                    Cache.TryGetValue(type, out tableCache);

                    if (tableCache == null)
                    {
                        var baseStorageConfig = CreateStorageConfig(type, actualTableName: null);
                        tableCache  = new ConfigTableCache(baseStorageConfig);
                        Cache[type] = tableCache;
                    }
                }

                // If this type is only used for conversion, do not attempt to populate the config from the table
                if (conversionOnly)
                {
                    return(tableCache.BaseTypeConfig);
                }

                if (actualTableName == null)
                {
                    actualTableName = DynamoDBContext.GetTableName(tableCache.BaseTableName, flatConfig);
                }

                // Check to see if another thread go the write lock before this thread and filled the cache.
                if (tableCache.Cache.TryGetValue(actualTableName, out config))
                {
                    return(config);
                }

                config = CreateStorageConfig(type, actualTableName);
                tableCache.Cache[actualTableName] = config;

                return(config);
            }
            finally
            {
                if (_readerWriterLockSlim.IsWriteLockHeld)
                {
                    _readerWriterLockSlim.ExitWriteLock();
                }
            }
        }
Example #11
0
 internal AsyncSearch(DynamoDBContext source, Search documentSearch)
 {
     SourceContext  = source;
     DocumentSearch = documentSearch;
 }