title: Randomly select DynamoDB entry
body: <p>I'm have a DynamoDB table called <em>URLArray</em> that contains a list of URL's (myURL) and a unique video name (myKey).</p>
  <p><a href="https://i.stack.imgur.com/RsUPS.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/RsUPS.png" alt="See URLArray table here" /></a></p>
  <p>I need to do two things:</p>
  <ol>
  <li>When a user clicks the next video button, a random entry needs to be selected from this URLArray. There could be potentially tens of thousands of rows.</li>
  </ol>
  <p>The user is logged into the app. Everytime they finish watching a video, the video's unique video name is recorded. So....when the user has seen a video, its added to a list in a table called <em>Users</em>  under the user's info row.</p>
  <ol start="2">
  <li>Soo...This random entry that gets selected when the user clicks the next video button in point 1, has to be compared to the list of videos they've already seen. To make sure that it doesn't randomly appear again for that particular user.</li>
  </ol>
  <p>I do something woefully inefficient so far, that works, but it's not great:</p>
  <p>By the way i'm using AppSync + GraphQL to interact with the DynamoDB table. I first get a local copy of the URLArray:</p>
  <pre><code> //Gets a list of the Key/URL pairs in the UrlArrays table in GraphQL   ****IN CONSTRUCTOR, so we have this URLArray data when componentDidMount()****
    listUrlArrays = async () =&gt; {  
      try {
  
        URLData = await API.graphql(graphqlOperation(ListUrlArrays)); //GraphQL query
        //URLData[] is available in the entire class
       
        this.setState({urlArrayLength: apiData.data.listURLArrays.items.length}); //gets the length of URLArray (i.e. how many videos are in the database)
        }
     }
  </code></pre>
  <p>As an overview, when user clicks for the next video:</p>
  <pre><code>     //When clicking next video
        async nextVideo(){
          
          await this.logVideosSeen(); //add myKey to the list of videos in *Users* table the logged in user has now seen
      
          await this.getURL();  //get the NEXT upcoming video's details, for Video Player to play and make sure it's not been seen before
      
        }
      
  
        //This will update the 'listOfVideosSeen[]' in Users table with videos unique myKey, the logged in user has seen
        logVideosSeen = async () =&gt; {     
             .......
        }
  
      async getURL() {  
          var dbIndex = this.getUniqueRandomNumber(this.state.urlArrayLength);  //Choose a number between 0 and N number of videos in URLArray
          
          //the hasVideoBeenSeen() basically gets the list of videos a user has already seen from `Users` table with the GraphQL getusers command, and creates a local copy of this list (can get big). I use javascripts indexOf() to check whether myKey already exists in the list 
          while(await this.hasVideoBeenSeen(this.state.URLData[dbIndex].myKey))  //while true i.e. user has seen that video before
          {
            dbIndex = this.getUniqueRandomNumber(this.state.urlArrayLength);  //get another random number to fetch a new myKey
          }
          
          //If false, we'll exit the loop and know we've got a not seen before myKey, proceed to set to play...
          if(dbIndex != null){
            this.setState({ playURL: this.state.URLData[dbIndex].vidURL });   //Retrieve the URL from the local URLArray that we're going to play (i.e. the next video to come)
            
          }   
        }
  </code></pre>
  <p>I can share a little more code if needed, but essentially I wanted to know how to:</p>
  <ol>
  <li><p>Let a Lambda function select a random number based on the current URLArray size (i may need to keep a local copy of URLArray anyway). But i think point 2 here is where it's really inefficient..</p>
  </li>
  <li><p>Let a Lambda function check (the while loop) against the Users table whether myKey has already been seen. Mainly to shift this computational burden to the cloud instead of the local device the app runs on.</p>
  </li>
  </ol>
  <p><strong>AFTER A THINK................</strong></p>
  <p>Thanks for the suggestion Seth. I have been thinking about it for some time, and while the randomness requirement still holds true, I think there is some truth in what you’ve suggested. The reason I need randomness, is so that 2 users sat side by side for example, can’t predict which video is coming next. It shouldn’t be a predictable sequence of videos. I'm not sure I can use <code>Scan</code> function with AWS Amplify/GraphQL. So remember there’s 2 things going on here: <em>(1) a video upload, recording it in the URLArray sensibly for future reference. (2) users viewing a previously unseen random video and then moving onto another unseen random video</em></p>
  <p>*(1)
  I like your idea of using a number to index the URLArray, and it’s helped to make life a bit easier. So the first URL being at index 0, the next at 1 etc…</p>
  <p>My thinking here (to avoid me doing a <code>ListUrlArrays()</code> and bringing the WHOLE array locally to the phone), is to create a GSI called <code>VideoNumber</code> for the URLArray table. This will be the unique VideoNumber column with a number 0-N. So imagine the diagram above having another column called VideoNumber. Row 1 having VideoNumber set to 0, Row 2 having VideoNumber set to 1 etc… THEN all I would need to do, is locally on the device, generate a random number between 0-N, call a <code>getURLArrayIdbyVideoNumber()</code> query specific for that GSI, with the number that we just generated, and it’ll unlock the information I need from the row. Voila! I think that shifts most of that heavy burden away now.</p>
  <p><strong>Question:</strong> Before each video is uploaded, how do I easily get the current total number of rows N in the table (or row count)? I would then increment it by one.</p>
  <p>The other thing I can do is save this current count number in another DynamoDB table that I use for persisted data, read the number from there before upload, and write an N+1 after upload to increment it (2 DynamoDB operations per upload). It’s not ideal.</p>
  <p>*(2)
  When a user has finished watching a video, I can log in a list (under the users information in DynamoDB), which video’s they’ve already seen. So for example this could now be a seen list: [3,12,73,108,57] for the 5 videos they’ve seen so far. When the user clicks nextVideo() we’ll generate a random newNumber, and straight away compare that with any number in the seen list. I use <code>seenlist.indexOf(newNumber)</code> and it will, either go again or stop if the newNumber doesn’t exist in the list. THEN I can go through the GSI query, and retrieve the relevant information to display the video from URLArray.</p>
  <p>I think that this <code>indexOf()</code> is the biggest computational burden on the device, and obviously gets a little slower as the <code>seenList</code> increases. But it should be quicker with pure integer numbers then an alphanumeric <code>myKey</code> as I was using before. Any other suggestion would be welcome :)</p>
  <p>I’ve yet to try it, but it was just an idea, as I need to keep the random element. But first, do you know how I can easily find the number of rows or table count of URLArray?</p>