Usando expressões com o Amazon DynamoDB e o AWS SDK for .NET - AWS SDK for .NET
Dados de exemploObtenha um único item usando expressões e a chave principal do itemObtenha vários itens usando expressões e a chave principal da tabelaObtenha vários itens usando expressões e outros atributos do itemImprimir um itemCriar ou substituir um item usando expressõesAtualização de um item usando expressõesExclusão de um item usando expressõesMais informações

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Usando expressões com o Amazon DynamoDB e o AWS SDK for .NET

nota

As informações neste tópico são específicas para projetos baseados no.NET Framework e na AWS SDK for .NET versão 3.3 e anteriores.

Os exemplos de código a seguir demonstram como usar o para AWS SDK for .NET programar o DynamoDB com expressões. As expressões denotam os atributos que você deseja ler de um item na tabela do DynamoDB. Você também usa expressões ao gravar um item, de forma a indicar quaisquer condições devam ser atendidas (também conhecido como atualização condicional) e como os atributos devem ser atualizados. Alguns exemplos de atualização substituem o atributo por um valor novo ou adicionam novos dados a uma lista ou um mapa. Para obter mais informações, consulte Reading and Writing Items Using Expressions (Leitura e gravação de itens usando expressões).

Dados de exemplo

Os exemplos de código neste tópico dependem dos dois itens de exemplo a seguir em uma tabela do DynamoDB chamada ProductCatalog. Esses itens descrevem as informações sobre entradas do produto em um catálogo fictício de loja de bicicleta. Esses itens são baseados no exemplo fornecido em Estudo de caso: um ProductCatalog item. Os descritores de tipos de dados, como BOOL, L, M, N, NS, S e SS, corresponde aos em JSON Data Format (Formato de dados JSON).

{
  "Id": {
    "N": "205"
  },
  "Title": {
    "S": "20-Bicycle 205"
  },
  "Description": {
    "S": "205 description"
  },
  "BicycleType": {
    "S": "Hybrid"
  },
  "Brand": {
    "S": "Brand-Company C"
  },
  "Price": {
    "N": "500"
  },
  "Gender": {
    "S": "B"
  },
  "Color": {
    "SS": [
      "Red",
      "Black"
    ]
  },
  "ProductCategory": {
    "S": "Bike"
  },
  "InStock": {
    "BOOL": true
  },
  "QuantityOnHand": {
    "N": "1"
  },
  "RelatedItems": {
    "NS": [
      "341",
      "472",
      "649"
    ]
  },
  "Pictures": {
    "L": [
      {
        "M": {
          "FrontView": {
            "S": "http://example/products/205_front.jpg"
          }
        }
      },
      {
        "M": {
          "RearView": {
            "S": "http://example/products/205_rear.jpg"
          }
        }
      },
      {
        "M": {
          "SideView": {
            "S": "http://example/products/205_left_side.jpg"
          }
        }
      }
    ]
  },
  "ProductReviews": {
    "M": {
      "FiveStar": {
        "SS": [
          "Excellent! Can't recommend it highly enough! Buy it!",
          "Do yourself a favor and buy this."
        ]
      },
      "OneStar": {
        "SS": [
          "Terrible product! Do not buy this."
        ]
      }
    }
  }
},
{
  "Id": {
    "N": "301"
  },
  "Title": {
    "S": "18-Bicycle 301"
  },
  "Description": {
    "S": "301 description"
  },
  "BicycleType": {
    "S": "Road"
  },
  "Brand": {
    "S": "Brand-Company C"
  },
  "Price": {
    "N": "185"
  },
  "Gender": {
    "S": "F"
  },
  "Color": {
    "SS": [
      "Blue",
      "Silver"
    ]
  },
  "ProductCategory": {
    "S": "Bike"
  },
  "InStock": {
    "BOOL": true
  },
  "QuantityOnHand": {
    "N": "3"
  },
  "RelatedItems": {
    "NS": [
      "801",
      "822",
      "979"
    ]
  },
  "Pictures": {
    "L": [
      {
        "M": {
          "FrontView": {
            "S": "http://example/products/301_front.jpg"
          }
        }
      },
      {
        "M": {
          "RearView": {
            "S": "http://example/products/301_rear.jpg"
          }
        }
      },
      {
        "M": {
          "SideView": {
            "S": "http://example/products/301_left_side.jpg"
          }
        }
      }
    ]
  },
  "ProductReviews": {
    "M": {
      "FiveStar": {
        "SS": [
          "My daughter really enjoyed this bike!"
        ]
      },
      "ThreeStar": {
        "SS": [
          "This bike was okay, but I would have preferred it in my color.",
	      "Fun to ride."
        ]
      }
    }
  }
}

Obtenha um único item usando expressões e a chave principal do item

O exemplo a seguir apresenta o método Amazon.DynamoDBv2.AmazonDynamoDBClient.GetItem e um conjunto de expressões para obter e imprimir o item que tem um Id of 205. Somente os atributos a seguir do item são retornados: Id, Title, Description, Color, RelatedItems, Pictures e ProductReviews.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new GetItemRequest
{
  TableName = "ProductCatalog",
  ProjectionExpression = "Id, Title, Description, Color, #ri, Pictures, #pr",
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#pr", "ProductReviews" },
    { "#ri", "RelatedItems" }
  },
  Key = new Dictionary<string, AttributeValue>
  {
    { "Id", new AttributeValue { N = "205" } }
  },
};
var response = client.GetItem(request);

// PrintItem() is a custom function.
PrintItem(response.Item);

No exemplo anterior, a propriedade ProjectionExpression especifica os atributos a serem retornados. A propriedade ExpressionAttributeNames especifica o placeholder #pr para representar o atributo ProductReviews e o placeholder #ri para representar o atributo RelatedItems. A chamada para PrintItem refere-se uma função personalizada, como descrito em Imprimir um item.

Obtenha vários itens usando expressões e a chave principal da tabela

O exemplo a seguir caracteriza o método Amazon.DynamoDBv2.AmazonDynamoDBClient.Query e uma série de expressões para obter e imprimir o item que tenha um Id of 301, mas somente se o valor de Price for maior que 150. Somente os atributos a seguir do item são retornados: Id, Title e todos os atributos ThreeStar em ProductReviews.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new QueryRequest
{
  TableName = "ProductCatalog",
  KeyConditions = new Dictionary<string,Condition>
  {
    { "Id", new Condition()
      {
        ComparisonOperator = ComparisonOperator.EQ,
        AttributeValueList = new List<AttributeValue>
        {
          new AttributeValue { N = "301" }
        }
      }
    }
  },
  ProjectionExpression = "Id, Title, #pr.ThreeStar",
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#pr", "ProductReviews" },
    { "#p", "Price" }
  },
  ExpressionAttributeValues = new Dictionary<string,AttributeValue>
  {
    { ":val", new AttributeValue { N = "150" } }
  },
  FilterExpression = "#p > :val"
};
var response = client.Query(request);

foreach (var item in response.Items)
{
  // Write out the first page of an item's attribute keys and values.
  // PrintItem() is a custom function.
  PrintItem(item);
  Console.WriteLine("=====");
}

No exemplo anterior, a propriedade ProjectionExpression especifica os atributos a serem retornados. A propriedade ExpressionAttributeNames especifica o espaço reservado #pr para representar o atributo ProductReviews e o espaço reservado #p para representar o atributo Price. #pr.ThreeStar especifica para retornar somente o atributo ThreeStar. A propriedade ExpressionAttributeValues especifica o placeholder :val para representar o valor 150. A propriedade FilterExpression especifica que #p (Price) deve ser maior que :val (150). A chamada para PrintItem refere-se uma função personalizada, como descrito em Imprimir um item.

Obtenha vários itens usando expressões e outros atributos do item

O exemplo a seguir apresenta o método Amazon.DynamoDBv2.AmazonDynamoDBClient.Scan e um conjunto de expressões para obter e imprimir todos os itens que tenham ProductCategory of Bike. Somente os atributos a seguir do item são retornados: Id, Title e todos os atributos em ProductReviews.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new ScanRequest
{
  TableName = "ProductCatalog",
  ProjectionExpression = "Id, Title, #pr",
  ExpressionAttributeValues = new Dictionary<string,AttributeValue>
  {
    { ":catg", new AttributeValue { S = "Bike" } }
  },
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#pr", "ProductReviews" },
    { "#pc", "ProductCategory" }
  },
  FilterExpression = "#pc = :catg",  
};
var response = client.Scan(request);

foreach (var item in response.Items)
{
  // Write out the first page/scan of an item's attribute keys and values.
  // PrintItem() is a custom function.
  PrintItem(item);
  Console.WriteLine("=====");
}

No exemplo anterior, a propriedade ProjectionExpression especifica os atributos a serem retornados. A propriedade ExpressionAttributeNames especifica o placeholder #pr para representar o atributo ProductReviews e o placeholder #pc para representar o atributo ProductCategory. A propriedade ExpressionAttributeValues especifica o placeholder :catg para representar o valor Bike. A propriedade FilterExpression especifica que #pc (ProductCategory) deve ser igual a :catg (Bike). A chamada para PrintItem refere-se uma função personalizada, como descrito em Imprimir um item.

Imprimir um item

O exemplo a seguir mostra como imprimir os atributos e os valores de um item. Este exemplo é usado nos exemplos anteriores que mostram como Obter um único item usando expressões e a chave principal do item, Obter vários itens usando expressões e a chave principal da tabela e Obter vários itens usando expressões e outros atributos do item.

// using Amazon.DynamoDBv2.Model;

// Writes out an item's attribute keys and values.
public static void PrintItem(Dictionary<string, AttributeValue> attrs)
{
  foreach (KeyValuePair<string, AttributeValue> kvp in attrs)
  {
    Console.Write(kvp.Key + " = ");
    PrintValue(kvp.Value);
  }
}

// Writes out just an attribute's value.
public static void PrintValue(AttributeValue value)
{
  // Binary attribute value.
  if (value.B != null)
  {
    Console.Write("Binary data");
  }
  // Binary set attribute value.
  else if (value.BS.Count > 0)
  {
    foreach (var bValue in value.BS)
    {
      Console.Write("\n  Binary data");
    }
  }
  // List attribute value.
  else if (value.L.Count > 0)
  {
    foreach (AttributeValue attr in value.L)
    {
      PrintValue(attr);
    }
  }
  // Map attribute value.
  else if (value.M.Count > 0)
  {
    Console.Write("\n");
    PrintItem(value.M);
  }
  // Number attribute value.
  else if (value.N != null)
  {
    Console.Write(value.N);
  }
  // Number set attribute value.
  else if (value.NS.Count > 0)
  {
    Console.Write("{0}", string.Join("\n", value.NS.ToArray()));
  }
  // Null attribute value.
  else if (value.NULL)
  {
    Console.Write("Null");
  }
  // String attribute value.
  else if (value.S != null)
  {
    Console.Write(value.S);
  }
  // String set attribute value.
  else if (value.SS.Count > 0)
  {
    Console.Write("{0}", string.Join("\n", value.SS.ToArray()));
  }
  // Otherwise, boolean value.
  else
  {
    Console.Write(value.BOOL);
  }
 
  Console.Write("\n");
}

No exemplo anterior, cada valor de atributo tem várias data-type-specific propriedades que podem ser avaliadas para determinar o formato correto para imprimir o atributo. Essas propriedades incluem B, BOOL, BS, L, M, N, NS, NULL, S e SS, que correspondem às no formato de dados JSON. Para propriedades como B, N, NULL e S, se a propriedade correspondente não for null, o atributo será o tipo de dados não null correspondente. Para propriedades comoBS,,L, MNS, eSS, se Count for maior que zero, o atributo será do tipo de non-zero-value dados correspondente. Se todas as data-type-specific propriedades do atributo forem iguais null ou Count iguais a zero, o atributo corresponderá ao tipo de BOOL dados.

Criar ou substituir um item usando expressões

O exemplo a seguir apresenta o método Amazon.DynamoDBv2.AmazonDynamoDBClient.PutItem e um conjunto de expressões para atualizar o item com Title of 18-Bicycle 301. Se o item não existir ainda, será adicionado um novo item.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new PutItemRequest
{
  TableName = "ProductCatalog",
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#title", "Title" }
  },
  ExpressionAttributeValues = new Dictionary<string, AttributeValue>
  {
    { ":product", new AttributeValue { S = "18-Bicycle 301" } }
  },
  ConditionExpression = "#title = :product", 
  // CreateItemData() is a custom function.
  Item = CreateItemData()
};
client.PutItem(request);

No exemplo anterior, a propriedade ExpressionAttributeNames especifica o placeholder #title para representar o atributo Title. A propriedade ExpressionAttributeValues especifica o placeholder :product para representar o valor 18-Bicycle 301. A propriedade ConditionExpression especifica que #title (Title) deve ser igual a :product (18-Bicycle 301). A chamada para CreateItemData refere-se à seguinte função personalizada:

// using Amazon.DynamoDBv2.Model;

// Provides a sample item that can be added to a table.
public static Dictionary<string, AttributeValue> CreateItemData()
{
  var itemData = new Dictionary<string, AttributeValue>
  {
    { "Id", new AttributeValue { N = "301" } },
    { "Title", new AttributeValue { S = "18\" Girl's Bike" } },
    { "BicycleType", new AttributeValue { S = "Road" } },
    { "Brand" , new AttributeValue { S = "Brand-Company C" } },
    { "Color", new AttributeValue { SS = new List<string>{ "Blue", "Silver" } } },
    { "Description", new AttributeValue { S = "301 description" } },
    { "Gender", new AttributeValue { S = "F" } },
    { "InStock", new AttributeValue { BOOL = true } },
    { "Pictures", new AttributeValue { L = new List<AttributeValue>{ 
      { new AttributeValue { M = new Dictionary<string,AttributeValue>{
        { "FrontView", new AttributeValue { S = "http://example/products/301_front.jpg" } } } } },
      { new AttributeValue { M = new Dictionary<string,AttributeValue>{
        { "RearView", new AttributeValue {S = "http://example/products/301_rear.jpg" } } } } },
      { new AttributeValue { M = new Dictionary<string,AttributeValue>{
        { "SideView", new AttributeValue { S = "http://example/products/301_left_side.jpg" } } } } }
    } } },
    { "Price", new AttributeValue { N = "185" } },
    { "ProductCategory", new AttributeValue { S = "Bike" } },
    { "ProductReviews", new AttributeValue { M = new Dictionary<string,AttributeValue>{
      { "FiveStar", new AttributeValue { SS = new List<string>{
        "My daughter really enjoyed this bike!" } } },
      { "OneStar", new AttributeValue { SS = new List<string>{
        "Fun to ride.",
        "This bike was okay, but I would have preferred it in my color." } } }
    } } },
    { "QuantityOnHand", new AttributeValue { N = "3" } },
    { "RelatedItems", new AttributeValue { NS = new List<string>{ "979", "822", "801" } } }
  };

  return itemData;
}

No exemplo anterior, um item de exemplo com dados de exemplo é retornado ao chamador. Uma série de atributos e valores correspondentes é construída usando os tipos de dados como BOOL, L, M, N, NS, S e SS, que correspondem aos do JSON Data Format (formato de dados JSON).

Atualização de um item usando expressões

O exemplo a seguir apresenta o método Amazon.DynamoDBv2.AmazonDynamoDBClient.UpdateItem e um conjunto de expressões para alterar Title para 18" Girl's Bike para o item com Id de 301.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new UpdateItemRequest
{
  TableName = "ProductCatalog",
  Key = new Dictionary<string,AttributeValue>
  {
     { "Id", new AttributeValue { N = "301" } }
  },
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#title", "Title" }
  },
  ExpressionAttributeValues = new Dictionary<string, AttributeValue>
  {
    { ":newproduct", new AttributeValue { S = "18\" Girl's Bike" } }
  },
  UpdateExpression = "SET #title = :newproduct"
};
client.UpdateItem(request);

No exemplo anterior, a propriedade ExpressionAttributeNames especifica o placeholder #title para representar o atributo Title. A propriedade ExpressionAttributeValues especifica o placeholder :newproduct para representar o valor 18" Girl's Bike. A propriedade UpdateExpression especifica a alteração de #title (Title) para :newproduct (18" Girl's Bike).

Exclusão de um item usando expressões

O exemplo a seguir caracteriza o método Amazon.DynamoDBv2.AmazonDynamoDBClient.DeleteItem e um conjunto de expressões para excluir o item com Id de 301, mas somente se o Title do item for 18-Bicycle 301.

// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new DeleteItemRequest
{
  TableName = "ProductCatalog",
  Key = new Dictionary<string,AttributeValue>
  {
     { "Id", new AttributeValue { N = "301" } }
  },
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#title", "Title" }
  },
  ExpressionAttributeValues = new Dictionary<string, AttributeValue>
  {
    { ":product", new AttributeValue { S = "18-Bicycle 301" } }
  },
  ConditionExpression = "#title = :product"
};
client.DeleteItem(request);

No exemplo anterior, a propriedade ExpressionAttributeNames especifica o placeholder #title para representar o atributo Title. A propriedade ExpressionAttributeValues especifica o placeholder :product para representar o valor 18-Bicycle 301. A propriedade ConditionExpression especifica que #title (Title) deve ser igual a :product (18-Bicycle 301).

Mais informações

Para obter mais informações e exemplos de código, consulte: