Implementation

• Use partial normalization to find followed users

  In this step, you will see how to find followed users. These are the users that a particular user is following in your application. You will also see how to retrieve all of the data about the users being followed.

  As noted in the introduction to this module, you may want to use a partial normalization technique around friendships and users. Rather than storing the full information about each user in the Friendship entity, you can use the BatchGetItem API to retrieve information about a user in a Friendship entity.

  In the code you downloaded, there is a file in the application/ directory called find_and_enrich_following_for_user.py. The contents of this script are shown below.
  

  import boto3
  
  from entities import User
  
  dynamodb = boto3.client('dynamodb')
  
  USERNAME = "haroldwatkins"
  
  
  def find_and_enrich_following_for_user(username):
      friend_value = "#FRIEND#{}".format(username)
      resp = dynamodb.query(
          TableName='quick-photos',
          IndexName='InvertedIndex',
          KeyConditionExpression="SK = :sk",
          ExpressionAttributeValues={":sk": {"S": friend_value}},
          ScanIndexForward=True
      )
  
      keys = [
          {
              "PK": {"S": "USER#{}".format(item["followedUser"]["S"])},
              "SK": {"S": "#METADATA#{}".format(item["followedUser"]["S"])},
          }
          for item in resp["Items"]
      ]
  
      friends = dynamodb.batch_get_item(
          RequestItems={
              "quick-photos": {
                  "Keys": keys
              }
          }
      )
  
      enriched_friends =  [User(item) for item in friends['Responses']['quick-photos']]
  
      return enriched_friends
  
  
  
  follows = find_and_enrich_following_for_user(USERNAME)
  
  print("Users followed by {}:".format(USERNAME))
  for follow in follows:
      print(follow)

  Code snippet copied

  Copy

  The find_and_enrich_following_for_user function is similar to the find_follower_for_user function you used in the last module. The function accepts a username for whom you want to find the followed users. The function first makes a Query request using the inverted index to find all of the users that the given username is following. It then assembles a BatchGetItem to fetch the full User entity for each of the followed users and returns those entities.

  This results in two requests to DynamoDB, rather than the ideal of one. However, it’s satisfying a fairly complex access pattern, and it avoids the need to constantly update Friendship entities every time a user profile is updated. This partial normalization can be a great tool for your modeling needs.

  Execute the script by running the following command in your terminal.
  

  python application/find_and_enrich_following_for_user.py
  

  Code snippet copied

  Copy

  Your console should output a list of users followed by the given username.
  

  Users followed by haroldwatkins:
  User<ppierce -- Ernest Mccarty>
  User<vpadilla -- Jonathan Scott>
  User<david25 -- Abigail Alvarez>
  User<jacksonjason -- John Perry>
  User<chasevang -- Leah Miller>
  User<frankhall -- Stephanie Fisher>
  User<nmitchell -- Amanda Green>
  User<tmartinez -- Kristin Stevens>
  User<natasha87 -- Walter Carlson>
  User<geoffrey32 -- Mary Martin>

  Code snippet copied

  Copy

  Note that you are now dealing with User entities rather than Friendship entities. The User entity will have the most complete, up-to-date information about your user. While it took two requests to get there, it may still be a better option than full denormalization and the data integrity issues that result from it
  

Conclusion