List all with id as unique partition key?

[brandonpsmith]

I'm trying to query all locations. How do I query begins with LOCATION# and get all locations? ...

{
    model: {
      version: "1",
      entity: "location",
      service: "service",
    },
    attributes: {
      locationId: {
        type: "string",
        required: true,
        readOnly: true,
      },
      name: {
        type: "string",
        required: true,
      },
      coordinate: {
        type: "map",
        required: true,
        properties: {
          latitude: {
            type: "string",
            required: true,
          },
          longitude: {
            type: "string",
            required: true,
          },
        },
      },
      address: {
        type: "map",
        properties: {
          street: {
            type: "string",
          },
          city: {
            type: "string",
          },
          state: {
            type: "string",
          },
          zip: {
            type: "string",
          },
          county: {
            type: "string",
          },
        },
      },
    },
    indexes: {
      primary: {
        pk: {
          field: "pk",
          casing: "upper",
          template: "LOCATION#${locationId}",
          composite: ["locationId"],
        },
        sk: {
          field: "sk",
          casing: "upper",
          template: "LAT#${coordinate.latitude}#LON#${coordinate.longitude}",
          composite: ["coordinate.latitude", "coordinate.longitude"],
        },
      },
    },
  }

static async list() {
    const { data } = await LocationEntity.query.primary({ ???? }).begins({ ???? }).go();
    return data;
  }

[tywalch]

Hi @brandonpsmith 👋

With ElectroDB, you only have to interact with the individual PK and SK composite attributes themselves -- how you provide these to ElectroDB means different things:

// Access queries on the `query` object
await LocationEntity.query
  // The "Access Pattern Method"
  // Must at a minimum include the attributes that make up the PK, but also accepts sort key attributes
  // If you provide a sort key attribute, ElectroDB will treat this value as being complete (e.g. The "complete" for the location "Texas", not "Tex")
  // Lastly, you still must provide your sort keys in the order they are defined in your "composite". ElectroDB is building a string after all, and it can't 
  // build a key out of left-to-right order.
  .primary({ location: 'Georgia', latitude: '33.753746' }) 
  // The "Sort Key Condition Methods" allow for partial sort keys or unique conditions on sort keys (e.g. 'between', 'begins', 'gte', 'gt', 'lte', 'lt')
  .begins({ Longitude: '-8' })
  // complete the query
  .go()

Let me know if this helps, you can find more detail on this here: https://electrodb.dev/en/queries/query/

[brandonpsmith]

It helps but doesn't solve listing all locations with zero params. Is there a way to query this or is this just a scan? In this case. I don't have a state or coordinate to start with. I just need to query all locations.

[ikushlianski]

I saw one guy posting this playground at electrodb.fun

Line 92. You could create a PK with an empty array, and some SK. So your PK will be generated as the name of service. So when querying that service you could get all the items with that PK, thus "listing" all the items belonging to that service.

[chrisfitkin]

Is that a good practice? I saw a similar config in this github example.

indexes: {
      primary: {
        pk: {
          field: "pk",
          composite: [],
        },
        sk: {
          field: "sk",
          composite: ["articleID"],
        },
      },
    },

And then accessed like this to fetch all.

export async function list() {
  return ArticleEntity.query.primary({}).go();
}

[tywalch]

I saw one guy posting this playground at electrodb.fun

Line 92. You could create a PK with an empty array, and some SK. So your PK will be generated as the name of service. So when querying that service you could get all the items with that PK, thus "listing" all the items belonging to that service.

It actually is still tied to the entity through the sort key, so would be "listing" all items that belong to that entity 👍

[tywalch]

Is that a good practice? I saw a similar config in this github example.

indexes: {

      primary: {

        pk: {

          field: "pk",

          composite: [],

        },

        sk: {

          field: "sk",

          composite: ["articleID"],

        },

      },

    },

And then accessed like this to fetch all.

export async function list() {

  return ArticleEntity.query.primary({}).go();

}

It's definitely supported by ElectroDB 👍 Whether or not it makes sense to do with your data in particular depends on the cardinality of what you assign to the sort key. Hot partitions can still cause throughput problems. That said for something like "accountId", or something that has known bounds, it can be super useful to use this pattern. It allows me to create an initial query (for example, get all accountIds) and then use those values to seed a second round of queries.