Node.js 如何使用DynamoDB批量删除?

Node.js 如何使用DynamoDB批量删除?,node.js,amazon-dynamodb,Node.js,Amazon Dynamodb,我得到一个错误,“提供的键元素与模式不匹配”uuid是我的主分区键。我还有一个主排序键用于版本。我想我可以使用batchWrite()删除所有具有相同uuid的项目 我的ES6代码如下: delete(uuid) { const promise = new Promise(); const params = { RequestItems: { [this.TABLE]: [ { DeleteRequest: {

我得到一个错误,“提供的键元素与模式不匹配”
uuid
是我的主分区键。我还有一个主排序键用于
版本
。我想我可以使用
batchWrite
()删除所有具有相同
uuid
的项目

我的ES6代码如下:

delete(uuid) {
  const promise = new Promise();
  const params = {
    RequestItems: {
      [this.TABLE]: [
        {
          DeleteRequest: {
            Key: { uuid: uuid }
          }
        }
      ]
    }
  };


  // this._client references the DocumentClient
  this._client.batchWrite(params, function(err, data) {
    if (err) {
      // this gets hit with error
      console.log(err);
      return promise.reject(err);
    }

    console.log(result);
    return promise.resolve(result);
  });

  return promise;
}

不知道为什么它是错误的关键是主要的。我曾多次看到过关于需要其他索引的帖子,当我在搜索非键的内容时。但我不认为这里是这样。

这是批写删除请求示例。这段代码已经过测试,运行良好。如果您根据自己的需求更改此代码,它应该可以工作

表格定义:-

var AWS = require("aws-sdk");

AWS.config.update({
    region : "us-west-2",
    endpoint : "http://localhost:8000"
});

var documentclient = new AWS.DynamoDB.DocumentClient();

var itemsArray = [];

var item1 = {
    DeleteRequest : {
        Key : {
            'bag' : 'b1'    
        }
    }
};

itemsArray.push(item1);

var item2 = {
    DeleteRequest : {
        Key : {
            'bag' : 'b2'    
        }
    }
};

itemsArray.push(item2);

var params = {
    RequestItems : {
        'Bag' : itemsArray
    }
};
documentclient.batchWrite(params, function(err, data) {
    if (err) {
        console.log('Batch delete unsuccessful ...');
        console.log(err, err.stack); // an error occurred
    } else {
        console.log('Batch delete successful ...');
        console.log(data); // successful response
    }

});
Batch delete successful ...
{ UnprocessedItems: {} }
包-表名

包散列密钥

“Bag”表中没有分区键

批写代码:-

var AWS = require("aws-sdk");

AWS.config.update({
    region : "us-west-2",
    endpoint : "http://localhost:8000"
});

var documentclient = new AWS.DynamoDB.DocumentClient();

var itemsArray = [];

var item1 = {
    DeleteRequest : {
        Key : {
            'bag' : 'b1'    
        }
    }
};

itemsArray.push(item1);

var item2 = {
    DeleteRequest : {
        Key : {
            'bag' : 'b2'    
        }
    }
};

itemsArray.push(item2);

var params = {
    RequestItems : {
        'Bag' : itemsArray
    }
};
documentclient.batchWrite(params, function(err, data) {
    if (err) {
        console.log('Batch delete unsuccessful ...');
        console.log(err, err.stack); // an error occurred
    } else {
        console.log('Batch delete successful ...');
        console.log(data); // successful response
    }

});
Batch delete successful ...
{ UnprocessedItems: {} }
输出:-

var AWS = require("aws-sdk");

AWS.config.update({
    region : "us-west-2",
    endpoint : "http://localhost:8000"
});

var documentclient = new AWS.DynamoDB.DocumentClient();

var itemsArray = [];

var item1 = {
    DeleteRequest : {
        Key : {
            'bag' : 'b1'    
        }
    }
};

itemsArray.push(item1);

var item2 = {
    DeleteRequest : {
        Key : {
            'bag' : 'b2'    
        }
    }
};

itemsArray.push(item2);

var params = {
    RequestItems : {
        'Bag' : itemsArray
    }
};
documentclient.batchWrite(params, function(err, data) {
    if (err) {
        console.log('Batch delete unsuccessful ...');
        console.log(err, err.stack); // an error occurred
    } else {
        console.log('Batch delete successful ...');
        console.log(data); // successful response
    }

});
Batch delete successful ...
{ UnprocessedItems: {} }

请注意,您需要遵循以下说明:

src:

DeleteRequest-对指定项执行DeleteItem操作。要删除的项目由一个关键子元素标识:

键-唯一标识项的主键属性值的映射。此映射中的每个条目都由一个属性名称和一个属性值组成。对于每个主键,必须提供所有键属性。例如,对于一个简单的主键,您只需要为分区键提供一个值。对于复合主键,必须同时提供分区键和排序键的值


<>这完全是可能的,你有一个节点lambda更好,你需要考虑一些关于大型数据库的事情:

  • 在从辅助索引查询所有匹配元素时处理分页
  • 根据批写入/删除要求,分成25个请求的
  • 超过40000个匹配项时,两个周期之间可能需要1秒的延迟
const AWS=require(“AWS sdk”),
dynamodb=新的AWS.dynamodb.DocumentClient(),
log=console.log;
exports.handler=异步(事件)=>{
日志(事件);
var TableName=event.TableName,
参数={
表名,
FilterExpression:“userId=:uid”,
表达式属性值:{
“:uid”:event.userId,
},
},
getItems=async(lastKey,items)=>{
如果(lastKey)params.ExclusiveStartKey=lastKey;
var resp=等待dynamodb.scan(params.promise();
项目=相应的项目长度
?项目目录(分别为项目映射((x)=>x.id))
:项目;
if(分别为LastEvaluatedKey)
返回等待获取项目(分别为LastEvaluatedKey、项目);
其他退货项目;
},
ids=await-getItems(null,[]),
idGroups=[];
对于(变量i=0;ilog(e));
//日志(d)
}
日志(id.length+“已处理项目”);
返回{};
};

不知道为什么没有人给出正确的答案

这是我在nodeJS做的lambda。它将对表执行一次完整扫描,然后每请求一次,每25项就批量删除一次

记住更改
表的名称

const AWS = require('aws-sdk');

const docClient = new AWS.DynamoDB.DocumentClient({ apiVersion: '2012-08-10' });

//const { TABLE_NAME } = process.env;
TABLE_NAME = "CHANGE ME PLEASE"

exports.handler = async (event) => {
    let params = {
        TableName: TABLE_NAME,
    };

    let items = [];
    let data = await docClient.scan(params).promise();
    items = [...items, ...data.Items];

    while (typeof data.LastEvaluatedKey != 'undefined') {
        params.ExclusiveStartKey = data.LastEvaluatedKey;

        data = await docClient.scan(params).promise();
        items = [...items, ...data.Items];
    }

    let leftItems = items.length;
    let group = [];
    let groupNumber = 0;

    console.log('Total items to be deleted', leftItems);

    for (const i of items) {
        const deleteReq = {
            DeleteRequest: {
                Key: {
                    id: i.id,
                },
            },
        };

        group.push(deleteReq);
        leftItems--;

        if (group.length === 25 || leftItems < 1) {
            groupNumber++;

            console.log(`Batch ${groupNumber} to be deleted.`);

            const params = {
                RequestItems: {
                    [TABLE_NAME]: group,
                },
            };

            await docClient.batchWrite(params).promise();

            console.log(
                `Batch ${groupNumber} processed. Left items: ${leftItems}`
            );

            // reset
            group = [];
        }
    }

    const response = {
        statusCode: 200,
        //  Uncomment below to enable CORS requests
        //  headers: {
        //      "Access-Control-Allow-Origin": "*"
        //  },
        body: JSON.stringify('Hello from Lambda!'),
    };
    return response;
};

const AWS=require('AWS-sdk');
const docClient=new AWS.DynamoDB.DocumentClient({apiVersion:'2012-08-10'});
//const{TABLE_NAME}=process.env;
TABLE_NAME=“请换我”
exports.handler=异步(事件)=>{
设params={
TableName:TABLE_NAME,
};
设项目=[];
让data=wait docClient.scan(params.promise();
items=[…items,…data.items];
while(typeof data.LastEvaluatedKey!=“未定义”){
params.ExclusiveStartKey=data.LastEvaluatedKey;
data=wait docClient.scan(params.promise();
items=[…items,…data.items];
}
让leftItems=items.length;
设群=[];
设groupNumber=0;
log('要删除的项目总数',leftItems);
用于(项目的常数i){
常量deleteReq={
删除请求:{
关键:{
id:i.id,
},
},
};
分组推送(deleteReq);
左项--;
if(group.length==25 | | leftItems<1){
groupNumber++;
log(`Batch${groupNumber}要删除。`);
常量参数={
请求项目:{
[表名称]:组,
},
};
等待docClient.batchWrite(params.promise();
console.log(
`已处理批处理${groupNumber}。左侧项目:${leftItems}`
);
//重置
组=[];
}
}
常数响应={
状态代码:200,
//取消下面的注释以启用CORS请求
//标题:{
//“访问控制允许来源”:“*”
//  },
body:JSON.stringify('Hello from Lambda!'),
};
返回响应;
};

对于批量删除,我们可以将batchWrite与DeleteRequest一起使用。这里是一个例子,在这里,我们提供了要删除其数据的tableName,有效负载是我们需要删除的id数组。 在单个请求中,可以删除25个项目。
const AWS=require('AWS-sdk');
const dynamodb=新的AWS.dynamodb.DocumentClient({apiVersion:'2012-08-10'});
const tableName=“PlayerData”;
常量有效载荷=[{id=101},{id=105},{id=106}];
const deleteBatchData=async(表名、有效负载、dynamodb)=>{
试一试{
等待dynamodb.batchWrite({
请求项目:{
[表名]:payload.map(项=>{
返回{