如何通过DynamoDB扫描操作查询表数据？附Swift代码

Hey there! You've got a solid start with your DynamoDB scan code in Swift. Let me help you complete it, optimize some rough edges, and cover common pitfalls to make your scan operation work smoothly.

Complete & Optimized Scan Code #

import AWSDynamoDB

// First, ensure your MyTable model is properly configured for DynamoDB mapping
class MyTable: AWSDynamoDBModel, AWSDynamoDBModeling {
    var id: String?
    var name: String?
    var status: String?

    // Match your actual DynamoDB table name here
    static func dynamoDBTableName() -> String {
        return "YourRealTableName"
    }

    // Define your table's hash key attribute
    static func hashKeyAttribute() -> String {
        return "id"
    }
}

// Your improved scan operation function
func fetchItemsFromDynamoDB() {
    let dynamoDbMapper = AWSDynamoDBObjectMapper.default()
    let scanExpression = AWSDynamoDBScanExpression()
    
    // Optional: Optimize scan with filters/projections to reduce data load
    scanExpression.filterExpression = "status = :activeStatus"
    scanExpression.expressionAttributeValues = [":activeStatus": "active"]
    scanExpression.projectionExpression = "id, name" // Only fetch needed attributes
    scanExpression.limit = 50 // Limit items per page to avoid overload
    
    dynamoDbMapper.scan(MyTable.self, expression: scanExpression) { [weak self] output, error in
        // Handle errors first with detailed feedback
        if let error = error {
            if let dynamoError = error as? AWSDynamoDBErrorType {
                switch dynamoError {
                case .resourceNotFound:
                    print("Error: Target DynamoDB table doesn't exist")
                case .accessDenied:
                    print("Error: No permission to scan this table")
                default:
                    print("Scan failed: \(dynamoError.localizedDescription)")
                }
            } else {
                print("Unexpected error: \(error.localizedDescription)")
            }
            return
        }
        
        // Safely unwrap the scan output to avoid crashes
        guard let scanOutput = output else {
            print("No items returned from the scan")
            return
        }
        
        print("Items in current page: \(scanOutput.items.count)")
        
        // Complete your for-loop with proper type casting
        for rawItem in scanOutput.items {
            if let tableItem = rawItem as? MyTable {
                // Access your item's properties here
                print("Found item: ID = \(tableItem.id ?? "N/A"), Name = \(tableItem.name ?? "N/A")")
            } else {
                print("Skipping item with invalid format")
            }
        }
        
        // Handle pagination for large datasets
        if let lastKey = scanOutput.lastEvaluatedKey {
            print("More items available. Fetching next page...")
            scanExpression.exclusiveStartKey = lastKey
            self?.fetchItemsFromDynamoDB() // Recursively fetch next page
        } else {
            print("Scan complete: all items fetched")
        }
    }
}

// Trigger the scan when needed
fetchItemsFromDynamoDB()

Key Fixes & Explanations #

• Model Class Compliance: Your MyTable must conform to AWSDynamoDBModeling to map DynamoDB items to Swift objects. Double-check the table name and hash key match your actual DynamoDB setup.
• Safe Unwrapping: Replaced forced unwrapping (!) with guard let to avoid runtime crashes if the scan returns no output.
• Type Casting: Fixed your incomplete for item loop by casting each raw item to your MyTable model—this lets you access the item's properties directly.
• Detailed Error Handling: Added specific DynamoDB error type checks to give you clear feedback (e.g., missing table, permission issues) instead of a generic error message.
• Pagination Support: DynamoDB returns results in pages for large tables. The code checks lastEvaluatedKey to recursively fetch all pages until all items are loaded.
• Scan Optimization: Added optional filters and projections to reduce data transfer and speed up the scan. Using limit helps control the number of items returned per request.

Common Scan Operation Pitfalls to Avoid #

• Performance: Full table scans (Scan) are slower than Query operations (which use primary keys). If possible, refactor to use Query instead. If you must use Scan, always add filters to narrow results.
• Permissions: Ensure your app's IAM role has the dynamodb:Scan permission for the target table—without this, you'll get an access denied error.
• Consistency: By default, Scan uses eventually consistent reads. If you need up-to-date data immediately, set scanExpression.consistentRead = true (note this uses more read capacity units).

内容的提问来源于stack exchange，提问作者Michel