Skip to content

Instantly share code, notes, and snippets.

@ruanbekker
Last active February 13, 2023 04:47
Show Gist options
  • Save ruanbekker/33a912fe7cbb2108df6a9cdd02f62b9a to your computer and use it in GitHub Desktop.
Save ruanbekker/33a912fe7cbb2108df6a9cdd02f62b9a to your computer and use it in GitHub Desktop.

Revisions

  1. ruanbekker revised this gist May 14, 2018. 1 changed file with 20 additions and 3 deletions.
    23 changes: 20 additions & 3 deletions dynamodb_aws_movies_example.md
    Original file line number Diff line number Diff line change
    @@ -1,8 +1,25 @@
    Download the Dataset:
    ## Get DynamoDB Local on Docker:

    This will get it going:

    ```
    $ docker run -itd --name dynamodb-local -p 8000:8000 rbekker87/dynamodb-local:latest
    ```

    For Data Persistence:

    ```
    $ docker run -itd --name dynamodb-local \
    -p 8000:8000 \
    -v /tmp/shared-local-instance.db:/shared-local-instance.db \
    rbekker87/dynamodb-local:latest
    ```

    ## Download the Dataset:

    ```
    wget https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/moviedata.zip
    unzip moviedata.zip
    $ wget https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/moviedata.zip
    $ unzip moviedata.zip
    ```

    ## Create the Table:
  2. ruanbekker created this gist May 12, 2018.
    480 changes: 480 additions & 0 deletions dynamodb_aws_movies_example.md
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,480 @@
    Download the Dataset:

    ```
    wget https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/moviedata.zip
    unzip moviedata.zip
    ```

    ## Create the Table:

    ```
    # create the table with year (HASH) and title (STRING) attributes
    from __future__ import print_function
    import boto3
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.create_table(
    TableName='Movies',
    KeySchema=[
    {
    'AttributeName': 'year',
    'KeyType': 'HASH'
    },
    {
    'AttributeName': 'title',
    'KeyType': 'RANGE'
    }
    ],
    AttributeDefinitions=[
    {
    'AttributeName': 'year',
    'AttributeType': 'N'
    },
    {
    'AttributeName': 'title',
    'AttributeType': 'S'
    },
    ],
    ProvisionedThroughput={
    'ReadCapacityUnits': 10,
    'WriteCapacityUnits': 10
    }
    )
    print("Table status:", table.table_status)
    ```

    ## Load the Bulk Data from Json and Insert:


    ```
    # Bulk load data from json to dynamodb
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    import json
    import decimal
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    with open("moviedata.json") as json_file:
    movies = json.load(json_file, parse_float = decimal.Decimal)
    for movie in movies:
    year = int(movie['year'])
    title = movie['title']
    info = movie['info']
    print("Adding movie:", year, title)
    table.put_item(
    Item={
    'year': year,
    'title': title,
    'info': info,
    }
    )
    ```

    ## Single PutItem:

    ```
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    import json
    import decimal
    class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
    if isinstance(o, decimal.Decimal):
    if abs(o) % 1 > 0:
    return float(o)
    else:
    return int(o)
    return super(DecimalEncoder, self).default(o)
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    title = "The Big New Movie"
    year = 2015
    response = table.put_item(
    Item={
    'year': year,
    'title': title,
    'info': {
    'plot':"Nothing happens at all.",
    'rating': decimal.Decimal(0)
    }
    }
    )
    print("PutItem succeeded:")
    print(json.dumps(response, indent=4, cls=DecimalEncoder))
    ```

    ## Single GetItem:

    ```
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    import json
    import decimal
    from boto3.dynamodb.conditions import Key, Attr
    from botocore.exceptions import ClientError
    # Helper class to convert a DynamoDB item to JSON.
    class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
    if isinstance(o, decimal.Decimal):
    if o % 1 > 0:
    return float(o)
    else:
    return int(o)
    return super(DecimalEncoder, self).default(o)
    dynamodb = boto3.resource("dynamodb", region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    title = "The Big New Movie"
    year = 2015
    try:
    response = table.get_item(
    Key={
    'year': year,
    'title': title
    }
    )
    except (ClientError, KeyError) as e:
    print_(e)
    #print(e.response['Error']['Message'])
    else:
    item = response['Item']
    print("GetItem succeeded:")
    print(json.dumps(item, indent=4, cls=DecimalEncoder))
    ```

    ## Update Item:

    ```
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    import json
    import decimal
    # Helper class to convert a DynamoDB item to JSON.
    class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
    if isinstance(o, decimal.Decimal):
    if o % 1 > 0:
    return float(o)
    else:
    return int(o)
    return super(DecimalEncoder, self).default(o)
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    title = "The Big New Movie"
    year = 2015
    response = table.update_item(
    Key={
    'year': year,
    'title': title
    },
    UpdateExpression="set info.rating = :r, info.plot = :p, info.actors = :a",
    ExpressionAttributeValues={
    ':r': decimal.Decimal(5.5),
    ':p': "Everything happens all at once.",
    ':a': ["Larry", "Moe", "Curly"]
    },
    ReturnValues="UPDATED_NEW"
    )
    print("UpdateItem succeeded:")
    print(json.dumps(response, indent=4, cls=DecimalEncoder))
    ```

    ## Atomic Updates:

    ```
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    import json
    import decimal
    # Helper class to convert a DynamoDB item to JSON.
    class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
    if isinstance(o, decimal.Decimal):
    if o % 1 > 0:
    return float(o)
    else:
    return int(o)
    return super(DecimalEncoder, self).default(o)
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    title = "The Big New Movie"
    year = 2015
    response = table.update_item(
    Key={
    'year': year,
    'title': title
    },
    UpdateExpression="set info.rating = info.rating - :val",
    ExpressionAttributeValues={
    ':val': decimal.Decimal(1)
    },
    ReturnValues="UPDATED_NEW"
    )
    print("UpdateItem succeeded:")
    print(json.dumps(response, indent=4, cls=DecimalEncoder))
    ```

    ## Conditional Updates:

    ```
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    from botocore.exceptions import ClientError
    import json
    import decimal
    # Helper class to convert a DynamoDB item to JSON.
    class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
    if isinstance(o, decimal.Decimal):
    if o % 1 > 0:
    return float(o)
    else:
    return int(o)
    return super(DecimalEncoder, self).default(o)
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    title = "The Big New Movie"
    year = 2015
    # Conditional update (will fail)
    print("Attempting conditional update...")
    try:
    response = table.update_item(
    Key={
    'year': year,
    'title': title
    },
    UpdateExpression="remove info.actors[0]",
    ConditionExpression="size(info.actors) = :num",
    ExpressionAttributeValues={
    ':num': 3
    },
    ReturnValues="UPDATED_NEW"
    )
    except ClientError as e:
    if e.response['Error']['Code'] == "ConditionalCheckFailedException":
    print(e.response['Error']['Message'])
    else:
    raise
    else:
    print("UpdateItem succeeded:")
    print(json.dumps(response, indent=4, cls=DecimalEncoder))
    ```

    ## Conditional Delete:

    ```
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    from botocore.exceptions import ClientError
    import json
    import decimal
    # Helper class to convert a DynamoDB item to JSON.
    class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
    if isinstance(o, decimal.Decimal):
    if o % 1 > 0:
    return float(o)
    else:
    return int(o)
    return super(DecimalEncoder, self).default(o)
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    title = "The Big New Movie"
    year = 2015
    print("Attempting a conditional delete...")
    try:
    response = table.delete_item(
    Key={
    'year': year,
    'title': title
    },
    ConditionExpression="info.rating <= :val",
    ExpressionAttributeValues= {
    ":val": decimal.Decimal(5)
    }
    )
    except ClientError as e:
    if e.response['Error']['Code'] == "ConditionalCheckFailedException":
    print(e.response['Error']['Message'])
    else:
    raise
    else:
    print("DeleteItem succeeded:")
    print(json.dumps(response, indent=4, cls=DecimalEncoder))
    ```

    ## Query by Year:

    ```
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    import json
    import decimal
    from boto3.dynamodb.conditions import Key, Attr
    # Helper class to convert a DynamoDB item to JSON.
    class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
    if isinstance(o, decimal.Decimal):
    if o % 1 > 0:
    return float(o)
    else:
    return int(o)
    return super(DecimalEncoder, self).default(o)
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    print("Movies from 1985")
    response = table.query(
    KeyConditionExpression=Key('year').eq(1985)
    )
    for i in response['Items']:
    print(i['year'], ":", i['title'])
    ```

    ## Query by Year and Title between two letters:

    ```
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    import json
    import decimal
    from boto3.dynamodb.conditions import Key, Attr
    # Helper class to convert a DynamoDB item to JSON.
    class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
    if isinstance(o, decimal.Decimal):
    return str(o)
    return super(DecimalEncoder, self).default(o)
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    print("Movies from 1992 - titles A-L, with genres and lead actor")
    response = table.query(
    ProjectionExpression="#yr, title, info.genres, info.actors[0]",
    ExpressionAttributeNames={ "#yr": "year" }, # Expression Attribute Names for Projection Expression only.
    KeyConditionExpression=Key('year').eq(1992) & Key('title').between('A', 'L')
    )
    for i in response[u'Items']:
    print(json.dumps(i, cls=DecimalEncoder))
    ```

    ## Scan and Filter:

    ```
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    import json
    import decimal
    from boto3.dynamodb.conditions import Key, Attr
    # Helper class to convert a DynamoDB item to JSON.
    class DecimalEncoder(json.JSONEncoder):
    def default(self, o):
    if isinstance(o, decimal.Decimal):
    if o % 1 > 0:
    return float(o)
    else:
    return int(o)
    return super(DecimalEncoder, self).default(o)
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    fe = Key('year').between(1950, 1959);
    pe = "#yr, title, info.rating"
    # Expression Attribute Names for Projection Expression only.
    ean = { "#yr": "year", }
    esk = None
    response = table.scan(
    FilterExpression=fe,
    ProjectionExpression=pe,
    ExpressionAttributeNames=ean
    )
    for i in response['Items']:
    print(json.dumps(i, cls=DecimalEncoder))
    while 'LastEvaluatedKey' in response:
    response = table.scan(
    ProjectionExpression=pe,
    FilterExpression=fe,
    ExpressionAttributeNames= ean,
    ExclusiveStartKey=response['LastEvaluatedKey']
    )
    for i in response['Items']:
    print(json.dumps(i, cls=DecimalEncoder))
    ```

    ## Delete the Table:

    ```
    from __future__ import print_function # Python 2/3 compatibility
    import boto3
    dynamodb = boto3.resource('dynamodb', region_name='us-west-2', endpoint_url="http://localhost:8000")
    table = dynamodb.Table('Movies')
    table.delete()
    ```

    ## Resources:

    - https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.Python.02.html#GettingStarted.Python.02.01