ในโมดูลก่อนหน้านี้ เราได้กำหนดรูปแบบการเข้าถึงแอปพลิเคชันมือถือ มาในโมดูลนี้ เราจะออกแบบคีย์หลักสำหรับตาราง DynamoDB และเปิดใช้งานรูปแบบการเข้าถึงส่วนหลัก

ระยะเวลาที่ใช้ในการศึกษาโมดูล: 40 นาที


ขณะที่กำลังออกแบบคีย์หลักสำหรับตาราง DynamoDB โปรดคำนึงถึงวิธีปฏิบัติที่ดีที่สุดต่อไปนี้อยู่เสมอ

  • เริ่มต้นจากเอนทิตีที่ต่างกันในตาราง หากคุณกำลังเก็บค่าประเภทข้อมูลที่แตกต่างกันจำนวนมากในตารางเดียว เช่น พนักงาน แผนก ลูกค้า และใบสั่ง โปรดตรวจสอบให้แน่ใจว่าคีย์หลักของคุณสามารถระบุแต่ละเอนทิตีได้อย่างชัดเจน และสามารถดำเนินการหลักๆ กับไอเท็มแต่ละรายการได้
  • ใช้คำนำหน้าเพื่อแยกความแตกต่างระหว่างประเภทของเอนทิตี การใช้คำนำหน้าเพื่อแยกความแตกต่างระหว่างประเภทของเอนทิตีนั้น จะสามารถป้องกันการขัดแย้งกันและช่วยในการสืบค้นข้อมูล หากคุณมีทั้งลูกค้าและพนักงานในตารางเดียวกัน คีย์หลักสำหรับลูกค้าอาจจะเป็น CUSTOMER#<CUSTOMERID> ขณะที่คีย์หลักสำหรับพนักงานอาจจะเป็น EMPLOYEE#<EMPLOYEEID>
  • มุ่งเป้าไปที่การดำเนินการกับไอเท็มเดียวก่อน จากนั้น จึงเพิ่มการดำเนินการกับไอเท็มจำนวนมาก หากทำได้ สำหรับคีย์หลักนั้น สิ่งที่สำคัญก็คือ คุณต้องสามารถตอบสนองตัวเลือกในการอ่านและเขียนบนไอเท็มเดียวโดยใช้ API ไอเท็มเดียว: GetItem, PutItem, UpdateItem และ DeleteItem จะดียิ่งขึ้นหากคุณสามารถตอบสนองรูปแบบการอ่านไอเท็มจำนวนมากของคุณด้วยคีย์หลักโดยใช้การสืบค้นได้ด้วย หากทำไม่ได้ คุณสามารถเพิ่มดัชนีรองเพื่อจัดการกรณีการใช้การสืบค้นได้เสมอ

เรามาออกแบบคีย์หลักและดำเนินการขั้นพื้นฐานบางอย่างโดยคำนึงถึงวิธีปฏิบัติที่ดีที่สุดเหล่านี้กัน


  • ขั้นตอนที่ 1 ออกแบบคีย์หลัก

    เรามาพิจารณาเอนทิตีที่แตกต่างกันตามที่แนะนำไว้ในส่วนข้อมูลเบื้องต้นกัน ในแอปพลิเคชันมือถือ เรามีเอนทิตีดังต่อไปนี้

    • ผู้ใช้
    • รูปภาพ
    • การโต้ตอบ
    • มิตรภาพ

    เอนทิตีเหล่านี้แสดงให้เห็นถึงความสัมพันธ์ของข้อมูลที่แตกต่างกันสามประเภท

    ประการแรก ผู้ใช้แต่ละรายของแอปพลิเคชันจะมีโปรไฟล์ผู้ใช้เดียวที่แทนด้วยเอนทิตีผู้ใช้ในตาราง

    ถัดจากนั้น ผู้ใช้จะมีรูปภาพมากมายที่ปรากฏอยู่ในแอปพลิเคชันของคุณ และรูปภาพก็จะมีการโต้ตอบที่หลากหลาย ทั้งคู่เป็นความสัมพันธ์แบบหนึ่งต่อกลุ่ม

    ท้ายที่สุด เอนทิตีมิตรภาพคือตัวแทนของความสัมพันธ์แบบกลุ่มต่อกลุ่ม เอนทิตีมิตรภาพแสดงถึงกรณีที่ผู้ใช้หนึ่งรายติดตามผู้ใช้อีกรายในแอปพลิเคชันของคุณ ซึ่งเป็นความสัมพันธ์แบบกลุ่มต่อกลุ่มเพราะผู้ใช้หนึ่งรายอาจติดตามผู้ใช้อื่นๆ หลายราย และผู้ใช้ก็อาจมีผู้ติดตามหลายรายเช่นกัน

    โดยทั่วไปนั้น การแมปความสัมพันธ์แบบกลุ่มต่อกลุ่มคือตัวบ่งบอกว่าคุณจะต้องการที่จะตอบสนองต่อการสืบค้นสองรูปแบบ และแอปพลิเคชันของเราก็ไม่มีข้อยกเว้น ในเอนทิตีมิตรภาพ เรามีรูปแบบการเข้าถึงที่ต้องค้นหาผู้ใช้ทุกรายซึ่งติดตามผู้ใช้รายหนึ่ง รวมถึงรูปแบบการเข้าถึงที่ต้องค้นหาผู้ใช้ทุกรายที่ผู้ใช้รายใดรายหนึ่งติดตามอยู่

    ด้วยเหตุนี้ เราจึงจะใช้คีย์หลักแบบรวมที่มีทั้งค่า HASH และ RANGE คีย์หลักแบบรวมจะให้ความสามารถในการสืบค้นบนคีย์ HASH เพื่อตอบสนองรูปแบบการสืบค้นแบบใดแบบหนึ่งที่เราต้องการ ในส่วนข้อมูลจำเพาะของ API DynamoDB นั้น คีย์การแบ่งแยกจะเรียกว่า HASH และคีย์การจัดเรียงจะเรียกว่า RANGE และในคู่มือนี้ เราจะใช้อภิธานศัพท์ API สลับกันได้ และโดยเฉพาะอย่างยิ่ง เมื่อเราพูดถึงโค้ดหรือรูปแบบผ่านสาย JSON ใน DynamoDB

    โปรดทราบว่าเอนทิตีแบบหนึ่งต่อหนึ่ง -- User -- ไม่มีคุณสมบัติตามธรรมชาติสำหรับค่า RANGE เนื่องจากเป็นการแมปความสัมพันธ์แบบหนึ่งต่อหนึ่ง รูปแบบการเข้าถึงจึงจะเป็นการค้นหาค่าคีย์ขั้นพื้นฐาน ด้วยรูปแบบตารางของคุณที่ต้องใช้คุณสมบัติ RANGE คุณสามารถใส่ค่าตัวเสริมสำหรับคีย์ RANGE ได้

    เรามาใช้รูปแบบต่อไปนี้กับค่า HASH และค่า RANGE สำหรับเอนทิตีแต่ละประเภทโดยคำนึงถึงเรื่องนี้กัน

    เอนทิตี

    HASH

    RANGE

    ผู้ใช้

    USER#<USERNAME>

    #METADATA#<USERNAME>

    รูปภาพ

    USER#<USERNAME>

    PHOTO#<USERNAME>#<TIMESTAMP>

    การโต้ตอบ

    REACTION#<USERNAME>#<TYPE>

    PHOTO#<USERNAME>#<TIMESTAMP>

    มิตรภาพ

    USER#<USERNAME>

    #FRIEND#<FRIEND_USERNAME>

    เรามาตรวจดูตารางก่อนหน้านี้กัน

    ประการแรก สำหรับเอนทิตีผู้ใช้ ค่า HASH จะเป็น USER#<USERNAME> โปรดสังเกตว่า คุณใช้คำนำหน้าเพื่อระบุเอนทิตีและป้องกันการขัดแย้งกันที่อาจเกิดขึ้นได้กับเอนทิตีประเภทต่างๆ

    สำหรับค่า RANGE บนเอนทิตีผู้ใช้ เราจะใช้คำนำหน้าคงที่ #METADATA# แล้วตามด้วยค่าชื่อผู้ใช้ สำหรับค่า RANGE คุณควรต้องมีค่าที่รู้จัก เช่น ชื่อผู้ใช้ ซึ่งอนุญาตให้กับการดำเนินการรายการเดียว เช่น GetItem, PutItem และ DeleteItem

    อย่างไรก็ตาม เรายังต้องการค่า RANGE ที่มีค่าที่แตกต่างกันทั่วเอนทิตีผู้ใช้ เพื่อให้สามารถใช้การแบ่งแบบเท่ากันได้หากเราใช้คอลัมน์นี้เป็นคีย์ HASH สำหรับดัชนี ด้วยเหตุนี้ คุณจึงต่อท้ายชื่อผู้ใช้ด้วยค่า RANGE

    ประการที่สอง เอนทิตีรูปภาพคือเอนทิตีย่อยของเอนทิตีผู้ใช้รายใดรายหนึ่ง รูปแบบการเข้าถึงหลักสำหรับรูปภาพคือการเรียกดูรูปภาพของผู้ใช้โดยเรียงลำดับตามวันที่ เมื่อใดก็ตามที่คุณต้องการเรียงลำดับบางอย่างตามคุณสมบัติข้อใดข้อหนึ่ง คุณจะต้องใส่คุณสมบัตินั้นลงในคีย์ RANGE เพื่อให้สามารถจัดเรียงได้ สำหรับเอนทิตีรูปภาพ ให้ใช้คีย์ HASH เดียวกันกับเอนทิตีผู้ใช้ ซึ่งจะทำให้คุณเรียกดูทั้งโปรไฟล์ผู้ใช้และรูปภาพของผู้ใช้นั้นได้ด้วยการส่งคำขอเดียว สำหรับคีย์ RANGE ให้ใช้ PHOTO#<USERNAME>#<TIMESTAMP> เพื่อระบุรูปภาพในตารางของคุณด้วยข้อมูลที่ไม่ซ้ำกัน

    ประการที่สาม เอนทิตีการโต้ตอบคือเอนทิตีย่อยของเอนทิตีรูปภาพใดภาพหนึ่ง เอนทิตีรูปภาพมีความสัมพันธ์แบบหนึ่งต่อกลุ่ม จึงจะใช้การให้เหตุผลแบบเดียวกันกับเอนทิตีรูปภาพ ในโมดูลถัดไป คุณจะได้เห็นวิธีการเรียกดูรูปภาพและการโต้ตอบทั้งหมดของรูปภาพนั้นในการสืบค้นครั้งเดียวด้วยดัชนีรอง สำหรับตอนนี้ โปรดทราบว่าคีย์ RANGE ของเอนทิตีการโต้ตอบมีรูปแบบเดียวกันกับคีย์ RANGE ของเอนทิตีรูปภาพ ในส่วนของคีย์ HASH เราจะใช้ชื่อผู้ใช้ของผู้ใช้ที่สร้างการโต้ตอบและประเภทการโต้ตอบที่สร้างขึ้น การต่อท้ายประเภทของการโต้ตอบช่วยให้ผู้ใช้สามารถเพิ่มประเภทการโต้ตอบจำนวนมากลงในรูปภาพเดียวได้

    ท้ายที่สุด เอนทิตีมิตรภาพใช้คีย์ HASH เดียวกันกับเอนทิตีผู้ใช้ ซึ่งจะทำให้คุณสามารถดึงได้ทั้งข้อมูลเมตาของผู้ใช้และผู้ติดตามทั้งหมดของผู้ใช้ด้วยการสืบค้นครั้งเดียว คีย์ RANGE ของเอนทิตีมิตรภาพคือ #FRIEND#<FRIEND_USERNAME> ในขั้นตอนที่ 4 ด้านล่าง คุณจะได้เรียนรู้เหตุผลที่ต้องขึ้นต้นคีย์ RANGE ของเอนทิตีมิตรภาพด้วย “#”

    ในขั้นตอนถัดไป เราจะสร้างตารางด้วยรูปแบบคีย์หลักนี้

  • ขั้นที่ 2: สร้างตาราง

    ตอนนี้ เราได้สร้างคีย์หลักขึ้นมาแล้ว เรามาสร้างตารางกันเถอะ

    โค้ดที่คุณดาวน์โหลดในขั้นตอนที่ 3 ของโมดูล 1 มีสคริปต์ Python รวมอยู่ในไดเรกทอรี scripts/ ที่ชื่อว่า create_table.py เนื้อหาของสคริปต์ Python มีดังนี้

    import boto3
    
    dynamodb = boto3.client('dynamodb')
    
    try:
        dynamodb.create_table(
            TableName='quick-photos',
            AttributeDefinitions=[
                {
                    "AttributeName": "PK",
                    "AttributeType": "S"
                },
                {
                    "AttributeName": "SK",
                    "AttributeType": "S"
                }
            ],
            KeySchema=[
                {
                    "AttributeName": "PK",
                    "KeyType": "HASH"
                },
                {
                    "AttributeName": "SK",
                    "KeyType": "RANGE"
                }
            ],
            ProvisionedThroughput={
                "ReadCapacityUnits": 5,
                "WriteCapacityUnits": 5
            }
        )
        print("Table created successfully.")
    except Exception as e:
        print("Could not create table. Error:")
        print(e)

    สคริปต์ก่อนหน้าใช้การดำเนินการ CreateTable โดยใช้ Boto 3 ซึ่งเป็น AWS SDK for Python การดำเนินการดังกล่าวจะกำหนดคำจำกัดความของแอตทริบิวต์สองรายการ ซึ่งเป็นประเภทแอตทริบิวต์ที่จะใช้ในคีย์หลัก ถึงแม้ว่า DynamoDB จะไม่มีโครงสร้าง แต่คุณต้องกำหนดชื่อและประเภทของแอตทริบิวต์ที่ใช้สำหรับคีย์หลัก แอตทริบิวต์ต้องรวมอยู่ในรายการทุกรายการที่เขียนลงในตาราง ดังนั้นจึงต้องมีการระบุแอตทริบิวต์ในขณะที่คุณกำลังสร้างตาราง

    เนื่องจากคุณจัดเก็บเอนทิตีที่แตกต่างกันไว้ในตารางเดียว คีย์หลักของคุณจึงไม่สามารถใช้แอตทริบิวต์ที่มีชื่ออย่างเช่น UserId แอตทริบิวต์หมายถึงบางสิ่งที่แตกต่างกันไปตามประเภทของเอนทิตีที่จัดเก็บ ตัวอย่างเช่น คีย์หลักสำหรับผู้ใช้อาจเป็น USERNAME และคีย์หลักสำหรับการโต้ตอบอาจเป็น TYPE ดังนั้น เราจึงใช้ชื่อสามัญสำหรับแอตทริบิวต์ ได้แก่ PK (สำหรับคีย์การแบ่งแยก) และ SK (สำหรับคีย์การจัดเรียง)

    หลังจากกำหนดค่าแอตทริบิวต์ในรูปแบบคีย์แล้ว เราจะระบุปริมาณการประมวลผลที่จัดเตรียมไว้ให้สำหรับตารางนั้น DynamoDB มีโหมดความจุอยู่สองโหมด: แบบเตรียมใช้งานและแบบตามความต้องการ ในโหมดความจุแบบเตรียมใช้งาน คุณจะระบุจำนวนปริมาณการประมวลผลการอ่านและการเขียนที่คุณต้องการ คุณจะต้องชำระค่าบริการสำหรับความจุนี้ ไม่ว่าจะมีการใช้งานหรือไม่ก็ตาม

    สำหรับโหมดความจุตามความต้องการของ DynamoDB คุณจะจ่ายค่าบริการต่อคำขอ ค่าใช้จ่ายต่อคำขอจะสูงกว่าเล็กน้อยหากคุณใช้ปริมาณการประมวลผลแบบเตรียมใช้งานอย่างเต็มที่ แต่คุณไม่ต้องเสียเวลาไปกับการวางแผนความจุหรือกังวลเกี่ยวกับการถูกบีบคั้น โหมดความจุตามความต้องการทำงานได้อย่างยอดเยี่ยมสำหรับปริมาณงานที่ไม่แน่นอนหรือไม่สามารถคาดการณ์ได้ เรากำลังใช้โหมดความจุแบบเตรียมใช้งานในห้องแล็บนี้เนื่องจากเป็นโหมดที่เหมาะสมกับ DynamoDB Free Tier

    หากต้องการสร้างตาราง ให้รันสคริปต์ Python ด้วยคำสั่งต่อไปนี้

    python scripts/create_table.py

    สคริปต์ดังกล่าวควรส่งข้อความนี้ “Table created successfully.” กลับมา

    ในขั้นตอนถัดไป เราจะโหลดข้อมูลตัวอย่างที่มีจำนวนมากลงในตาราง 

  • ขั้นตอนที่ 3: การโหลดข้อมูลจำนวนมากลงในตาราง

    ในขั้นตอนนี้ เราจะโหลดข้อมูลที่มีจำนวนมากลงในตาราง DynamoDB ที่เราสร้างขึ้นในขั้นตอนก่อนหน้านี้ ซึ่งหมายความว่าในขั้นตอนถัดไป เราจะมีข้อมูลตัวอย่างให้ใช้

    ในไดเรกทอรี scripts/ จะมีไฟล์ที่ชื่อว่า items.json ไฟล์นี้มีไอเท็มตัวอย่าง 967 รายการที่ถูกสร้างขึ้นแบบสุ่มสำหรับโปรเจกต์ของเรา รายการเหล่านี้ได้แก่ เอนทิตีผู้ใช้ รูปภาพ มิตรภาพ และการโต้ตอบ คุณสามารถเปิดไฟล์ดังกล่าวหากต้องการเห็นข้อมูลตัวอย่างบางรายการ

    นอกจากนี้ ไดเรกทอรี scripts/ ยังมีไฟล์ชื่อว่า bulk_load_table.py ที่จะอ่านรายการต่างๆ ใน items.json และเขียนรายการจำนวนมากลงในตาราง DynamoDB เนื้อหาในไฟล์มีดังต่อไปนี้:

    import json
    
    import boto3
    
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('quick-photos')
    
    items = []
    
    with open('scripts/items.json', 'r') as f:
        for row in f:
            items.append(json.loads(row))
    
    with table.batch_writer() as batch:
        for item in items:
            batch.put_item(Item=item)

    ในสคริปต์นี้ แทนที่จะใช้ไคลเอนต์ระดับต่ำใน Boto 3 เราจะใช้อ็อบเจ็กต์ Resource ระดับสูงกว่าแทน อ็อบเจ็กต์ Resource มีอินเทอร์เฟซสำหรับการใช้ AWS API ที่ง่ายกว่า อ็อบเจ็กต์ Resource มีประโยชน์ในสถานการณ์นี้ เนื่องจากว่าจะรวมคำขอของเราเป็นกลุ่ม การดำเนินการ BatchWriteItem API จะยอมรับรายการได้มากสุด 25 รายการในหนึ่งคำขอ อ็อบเจ็กต์ Resource จะจัดการการรวมกลุ่มให้กับเราแทนที่จะทำให้เราต้องแบ่งข้อมูลของเราเป็นคำขอมากสุดถึง 25 รายการ

    รันสคริปต์ bulk_load_table.py และโหลดข้อมูลลงในตารางของคุณโดยเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล

    python scripts/bulk_load_table.py

    คุณจะมั่นใจได้ว่าข้อมูลทั้งหมดถูกโหลดลงในตารางด้วยการเรียกใช้การดำเนินการ Scan และส่งขอมูลจำนวนกลับไป

    เรียกใช้คำสั่งดังต่อไปนี้เพื่อใช้ AWS CLI ในการนับจำนวน

    aws dynamodb scan \
     --table-name quick-photos \
     --select COUNT

    ซึ่งควรจะแสดงผลลัพธ์ดังต่อไปนี้

    {
        "Count": 967, 
        "ScannedCount": 967, 
        "ConsumedCapacity": null
    }
    

    คุณควรเห็นจำนวน 967 ซึ่งบ่งบอกว่ารายการทั้งหมดของคุณได้รับการโหลดสำเร็จแล้ว

    ในขั้นตอนถัดไป เราจะแสดงวิธีการเรียกดูประเภทเอนทิตีจำนวนมากในคำขอเดียว ซึ่งสามารถลดคำขอเครือข่ายรวมที่คุณสร้างในแอปพลิเคชันของคุณ และเพิ่มประสิทธิภาพให้กับแอปพลิเคชัน

  • ขั้นที่ 4: เรียกดูประเภทเอนทิตีจำนวนมากในคำขอเดียว

    ตามที่ได้กล่าวไว้ในโมดูลก่อนหน้า คุณควรปรับตาราง DynamoDB ให้เหมาะสมกับจำนวนคำขอที่ได้รับให้มากที่สุด นอกจากนี้ เรายังกล่าวด้วยว่า DynamoDB ไม่มีการเชื่อมโยงที่ฐานข้อมูลเชิงสัมพันธ์มี ดังนั้น คุณจึงออกแบบตารางเพื่อรองรับพฤติกรรมที่คล้ายกับการเชื่อมโยงในคำขอของคุณแทน

    ในขั้นตอนนี้ เราจะดูวิธีเรียกดูประเภทเอนทิตีจำนวนมากในคำขอเดียว ในแอปพลิเคชันของเรา เราอาจต้องการดึงข้อมูลเกี่ยวกับผู้ใช้ ซึ่งจะรวมข้อมูลทั้งหมดในโปรไฟล์ของผู้ใช้ของเอนทิตีผู้ใช้ รวมถึงรูปภาพทั้งหมดที่ผู้ใช้อัปโหลด

    คำขอนี้ขยายประเภทเอนทิตีสองประเภท ได้แก่ เอนทิตีผู้ใช้ และเอนทิตีรูปภาพ แต่ไม่ได้หมายความว่าเราต้องสร้างคำขอจำนวนมาก

    ในโค้ดที่คุณดาวน์โหลด จะมีไฟล์ในไดเรกทอรี application/ ที่ชื่อว่า fetch_user_and_photos.py สคริปต์นี้จะแสดงวิธีที่คุณสามารถจัดโครงสร้างโค้ดเพื่อเรียกดูทั้งเอนทิตีผู้ใช้และเอนทิตีรูปภาพที่ผู้ใช้อัปโหลดได้ในคำขอเดียว

    โค้ดต่อไปนี้ประกอบด้วยสคริปต์ fetch_user_and_photos.py

    import boto3
    
    from entities import User, Photo
    
    dynamodb = boto3.client('dynamodb')
    
    USER = "jacksonjason"
    
    
    def fetch_user_and_photos(username):
        resp = dynamodb.query(
            TableName='quick-photos',
            KeyConditionExpression="PK = :pk AND SK BETWEEN :metadata AND :photos",
            ExpressionAttributeValues={
                ":pk": { "S": "USER#{}".format(username) },
                ":metadata": { "S": "#METADATA#{}".format(username) },
                ":photos": { "S": "PHOTO$" },
            },
            ScanIndexForward=True
        )
    
        user = User(resp['Items'][0])
        user.photos = [Photo(item) for item in resp['Items'][1:]]
    
        return user
    
    
    user = fetch_user_and_photos(USER)
    
    print(user)
    for photo in user.photos:
        print(photo)

    ที่ด้านบนสุด เรานำเข้าไลบรารี Boto 3 และคลาสธรรมดาบางส่วนเพื่อแทนอ็อบเจ็กต์ในโค้ดแอปพลิเคชันของเรา หากสนใจ คุณสามารถดูคำจำกัดความของเอนทิตีเหล่านั้นได้ในไฟล์ application/entities.py

    การทำงานจริงจะเกิดขึ้นในฟังก์ชัน fetch_user_and_photos ที่ระบุไว้ในโมดูล ซึ่งคล้ายคลึงกับฟังก์ชันที่คุณอาจกำหนดไว้ในแอปพลิเคชันที่จะใช้โดยตำแหน่งข้อมูลใดๆ ที่ต้องการข้อมูลนี้

    ในฟังก์ชันนี้ คุณจะส่งคำขอการสืบค้นไปยัง DynamoDB ก่อน การสืบค้นจะระบุคีย์ HASH เป็น USER#<Username> เพื่อแยกรายการที่ส่งกลับให้เป็นของผู้ใช้รายใดรายหนึ่งโดยเฉพาะ

    จากนั้นการสืบค้นจะระบุการแสดงเงื่อนไขคีย์ RANGE ระหว่าง #METADATA#<Username> และ PHOTO$ การสืบค้นนี้จะส่งเอนทิตีผู้ใช้กลับมา เนื่องจากมีคีย์การจัดเรียงเป็น #METADATA#<Username> รวมถึงจะส่งกลับเอนทิตีรูปภาพทั้งหมดของผู้ใช้นี้ซึ่งมีคีย์การจัดเรียงขึ้นต้นด้วย PHOTO# คีย์การจัดเรียงของประเภทสตริงจะถูกจัดเรียงตามโค้ดอักขระ ASCII เครื่องหมายดอลลาร์ ($) จะใส่ไว้หลังเครื่องหมายปอนด์ (#) ใน ASCII เพื่อให้แน่ใจว่าเราจะได้รับเอนทิตีรูปภาพทั้งหมด

    เมื่อเราได้รับการโต้ตอบ เราก็จะรวบรายการของเราลงในอ็อบเจ็กต์ที่แอปพลิเคชันของเรารู้จัก เราทราบว่ารายการแรกที่ส่งกลับมาจะเป็นเอนทิตีผู้ใช้ เราจึงสร้างอ็อบเจ็กต์ผู้ใช้จากรายการดังกล่าว สำหรับรายการที่เหลือ เราสร้างอ็อบเจ็กต์รูปภาพให้กับแต่ละรายการ แล้วแนบอาร์เรย์ของผู้ใช้ไปกับอ็อบเจ็กต์ผู้ใช้

    จุดสิ้นสุดของสคริปต์แสดงการใช้ฟังก์ชันและพิมพ์อ็อบเจ็กต์ที่เป็นผลลัพธ์ออกมา คุณสามารถรันสคริปต์ในเทอร์มินัลด้วยคำสั่งต่อไปนี้

    python application/fetch_user_and_photos.py

    คำสั่งควรจะสั่งพิมพ์อ็อบเจ็กต์ผู้ใช้และอ็อบเจ็กต์รูปภาพทั้งหมดไปยังคอนโซล:

    User<jacksonjason -- John Perry>
    Photo<jacksonjason -- 2018-05-30T15:42:38>
    Photo<jacksonjason -- 2018-06-09T13:49:13>
    Photo<jacksonjason -- 2018-06-26T03:59:33>
    Photo<jacksonjason -- 2018-07-14T10:21:01>
    Photo<jacksonjason -- 2018-10-06T22:29:39>
    Photo<jacksonjason -- 2018-11-13T08:23:00>
    Photo<jacksonjason -- 2018-11-18T15:37:05>
    Photo<jacksonjason -- 2018-11-26T22:27:44>
    Photo<jacksonjason -- 2019-01-02T05:09:04>
    Photo<jacksonjason -- 2019-01-23T12:43:33>
    Photo<jacksonjason -- 2019-03-03T02:00:01>
    Photo<jacksonjason -- 2019-03-03T18:20:10>
    Photo<jacksonjason -- 2019-03-11T15:18:22>
    Photo<jacksonjason -- 2019-03-30T02:28:42>
    Photo<jacksonjason -- 2019-04-14T21:52:36>

    สคริปต์นี้จะแสดงวิธีทำโมเดลตารางและเขียนการสืบค้นเพื่อเรียกดูประเภทเอนทิตีจำนวนมากในคำขอ DynamoDB คำขอเดียว ในฐานข้อมูลเชิงสัมพันธ์ คุณใช้การเชื่อมโยงเพื่อเรียกดูประเภทเอนทิตีจำนวนมากจากตารางต่างๆ ในคำขอเดียว ด้วย DynamoDB คุณสามารถทำโมเดลข้อมูลของคุณอย่างเฉพาะเจาะจง เพื่อให้เอนทิตีที่คุณควรเข้าถึงร่วมกันอยู่ถัดจากกันและกันในตารางเดียว วิธีนี้จะช่วยทดแทนความจำเป็นต้องมีการเชื่อมโยงในฐานข้อมูลเชิงสัมพันธ์ทั่วไปและทำให้แอปพลิเคชันของคุณมีประสิทธิภาพสูงอยู่เสมอขณะที่คุณขยายขนาด


    ในโมดูลนี้ เราได้ออกแบบคีย์หลักและสร้างตาราง จากนั้น เราจะโหลดข้อมูลจำนวนมากลงในตารางและดูวิธีการสืบค้นประเภทเอนทิตีจำนวนมากในคำขอเดียว

    ด้วยรูปแบบคีย์หลักในปัจจุบัน เราสามารถตอบสนองรูปแบบการเข้าถึงต่อไปนี้ได้

    • สร้างโปรไฟล์ผู้ใช้ (เขียน)
    • อัปเดตโปรไฟล์ผู้ใช้ (เขียน)
    • ดูโปรไฟล์ผู้ใช้ (อ่าน)
    • อัปโหลดรูปภาพ (เขียน)
    • ดูรูปภาพของผู้ใช้ (อ่าน)
    • ดูเพื่อนของผู้ใช้ (อ่าน)

    ในโมดูลถัดไป เราจะเพิ่มดัชนีรองและเรียนรู้เกี่ยวกับเทคนิคดัชนีย้อนกลับ ดัชนีรองช่วยให้คุณสนับสนุนรูปแบบการเข้าถึงเพิ่มเติมบนตาราง DynamoDB ของคุณ