packages/modeldb: enable composite indices

canvasxyz · Jan 15, 2025 · 7412cc9 · 7412cc9
1 parent 833e058
commit 7412cc9
Show file tree

Hide file tree

Showing 6 changed files with 98 additions and 125 deletions.
diff --git a/packages/modeldb-durable-objects/src/api.ts b/packages/modeldb-durable-objects/src/api.ts
@@ -84,10 +84,7 @@ export class ModelAPI {
 	readonly #primaryKeyName: string
 	columnNames: `"${string}"`[]
 
-	public constructor(
-		readonly db: SqlStorage,
-		readonly model: Model,
-	) {
+	public constructor(readonly db: SqlStorage, readonly model: Model) {
 		// in the cloudflare runtime, `this` cannot be used when assigning default values to private properties
 		this.#table = model.name
 		this.#properties = Object.fromEntries(model.properties.map((property) => [property.name, property]))
@@ -336,18 +333,17 @@ export class ModelAPI {
 		if (query.orderBy !== undefined) {
 			const orders = Object.entries(query.orderBy)
 			assert(orders.length === 1, "cannot order by multiple properties at once")
-			const [[name, direction]] = orders
-			const property = this.#properties[name]
-			assert(property !== undefined, "property not found")
-			assert(
-				property.kind === "primary" || property.kind === "primitive" || property.kind === "reference",
-				"cannot order by relation properties",
-			)
+			const [[indexName, direction]] = orders
+			const index = indexName.split("/")
+
+			assert(!index.some((name) => this.#properties[name]?.kind === "relation"), "cannot order by relation properties")
 
 			if (direction === "asc") {
-				sql.push(`ORDER BY "${name}" ASC`)
+				const orders = index.map((name) => `"${name}" ASC`).join(", ")
+				sql.push(`ORDER BY ${orders}`)
 			} else if (direction === "desc") {
-				sql.push(`ORDER BY "${name}" DESC`)
+				const orders = index.map((name) => `"${name}" DESC`).join(", ")
+				sql.push(`ORDER BY ${orders}`)
 			} else {
 				throw new Error("invalid orderBy direction")
 			}
@@ -601,14 +597,11 @@ export class RelationAPI {
 	readonly #insert: Method<{ _source: string; _target: string }>
 	readonly #delete: Method<{ _source: string }>
 
-	public constructor(
-		readonly db: SqlStorage,
-		readonly relation: Relation,
-	) {
+	public constructor(readonly db: SqlStorage, readonly relation: Relation) {
 		this.table = `${relation.source}/${relation.property}`
 		this.sourceIndex = `${relation.source}/${relation.property}/source`
 		this.targetIndex = `${relation.source}/${relation.property}/target`
-		
+
 		const columns = [`_source TEXT NOT NULL`, `_target TEXT NOT NULL`]
 		db.exec(`CREATE TABLE IF NOT EXISTS "${this.table}" (${columns.join(", ")})`)
 

diff --git a/packages/modeldb-pg/src/api.ts b/packages/modeldb-pg/src/api.ts
@@ -388,18 +388,18 @@ export class ModelAPI {
 		if (query.orderBy !== undefined) {
 			const orders = Object.entries(query.orderBy)
 			assert(orders.length === 1, "cannot order by multiple properties at once")
-			const [[name, direction]] = orders
-			const property = this.#properties[name]
-			assert(property !== undefined, "property not found")
-			assert(
-				property.kind === "primary" || property.kind === "primitive" || property.kind === "reference",
-				"cannot order by relation properties",
-			)
+
+			const [[indexName, direction]] = orders
+			const index = indexName.split("/")
+
+			assert(!index.some((name) => this.#properties[name]?.kind === "relation"), "cannot order by relation properties")
 
 			if (direction === "asc") {
-				sql.push(`ORDER BY "${name}" ASC NULLS FIRST`)
+				const orders = index.map((name) => `"${name}" ASC NULLS FIRST`).join(", ")
+				sql.push(`ORDER BY ${orders}`)
 			} else if (direction === "desc") {
-				sql.push(`ORDER BY "${name}" DESC NULLS LAST`)
+				const orders = index.map((name) => `"${name}" DESC NULLS LAST`).join(", ")
+				sql.push(`ORDER BY ${orders}`)
 			} else {
 				throw new Error("invalid orderBy direction")
 			}
@@ -663,10 +663,7 @@ export class RelationAPI {
 	public readonly sourceIndex: string
 	public readonly targetIndex: string
 
-	public constructor(
-		readonly client: pg.Client,
-		readonly relation: Relation,
-	) {
+	public constructor(readonly client: pg.Client, readonly relation: Relation) {
 		this.table = `${relation.source}/${relation.property}`
 		this.sourceIndex = `${relation.source}/${relation.property}/source`
 		this.targetIndex = `${relation.source}/${relation.property}/target`

diff --git a/packages/modeldb-sqlite-expo/src/api.ts b/packages/modeldb-sqlite-expo/src/api.ts
@@ -85,14 +85,11 @@ export class ModelAPI {
 
 	columnNames: `"${string}"`[]
 
-	public constructor(
-		readonly db: SQLiteDatabase,
-		readonly model: Model,
-	) {
+	public constructor(readonly db: SQLiteDatabase, readonly model: Model) {
 		this.#table = model.name
 		this.#params = {}
 		this.#properties = Object.fromEntries(model.properties.map((property) => [property.name, property]))
-		
+
 		const columns: string[] = []
 		this.columnNames = [] // quoted column names for non-relation properties
 		const columnParams: `:p${string}`[] = [] // query params for non-relation properties
@@ -313,18 +310,17 @@ export class ModelAPI {
 		if (query.orderBy !== undefined) {
 			const orders = Object.entries(query.orderBy)
 			assert(orders.length === 1, "cannot order by multiple properties at once")
-			const [[name, direction]] = orders
-			const property = this.#properties[name]
-			assert(property !== undefined, "property not found")
-			assert(
-				property.kind === "primary" || property.kind === "primitive" || property.kind === "reference",
-				"cannot order by relation properties",
-			)
+			const [[indexName, direction]] = orders
+			const index = indexName.split("/")
+
+			assert(!index.some((name) => this.#properties[name]?.kind === "relation"), "cannot order by relation properties")
 
 			if (direction === "asc") {
-				sql.push(`ORDER BY "${name}" ASC`)
+				const orders = index.map((name) => `"${name}" ASC`).join(", ")
+				sql.push(`ORDER BY ${orders}`)
 			} else if (direction === "desc") {
-				sql.push(`ORDER BY "${name}" DESC`)
+				const orders = index.map((name) => `"${name}" DESC`).join(", ")
+				sql.push(`ORDER BY ${orders}`)
 			} else {
 				throw new Error("invalid orderBy direction")
 			}
@@ -592,14 +588,11 @@ export class RelationAPI {
 	readonly #insert: Method<{ _source: string; _target: string }>
 	readonly #delete: Method<{ _source: string }>
 
-	public constructor(
-		readonly db: SQLiteDatabase,
-		readonly relation: Relation,
-	) {
+	public constructor(readonly db: SQLiteDatabase, readonly relation: Relation) {
 		this.table = `${relation.source}/${relation.property}`
 		this.sourceIndex = `${relation.source}/${relation.property}/source`
 		this.targetIndex = `${relation.source}/${relation.property}/target`
-		
+
 		const columns = [`_source TEXT NOT NULL`, `_target TEXT NOT NULL`]
 		db.execSync(`CREATE TABLE IF NOT EXISTS "${this.table}" (${columns.join(", ")})`)
 

diff --git a/packages/modeldb-sqlite-wasm/src/ModelAPI.ts b/packages/modeldb-sqlite-wasm/src/ModelAPI.ts
@@ -83,10 +83,7 @@ export class ModelAPI {
 
 	columnNames: string[]
 
-	public constructor(
-		readonly db: OpfsDatabase,
-		readonly model: Model,
-	) {
+	public constructor(readonly db: OpfsDatabase, readonly model: Model) {
 		this.#table = model.name
 		this.#params = {}
 		this.#properties = Object.fromEntries(model.properties.map((property) => [property.name, property]))
@@ -343,18 +340,17 @@ export class ModelAPI {
 		if (query.orderBy !== undefined) {
 			const orders = Object.entries(query.orderBy)
 			assert(orders.length === 1, "cannot order by multiple properties at once")
-			const [[name, direction]] = orders
-			const property = this.#properties[name]
-			assert(property !== undefined, "property not found")
-			assert(
-				property.kind === "primary" || property.kind === "primitive" || property.kind === "reference",
-				"cannot order by relation properties",
-			)
+			const [[indexName, direction]] = orders
+			const index = indexName.split("/")
+
+			assert(!index.some((name) => this.#properties[name]?.kind === "relation"), "cannot order by relation properties")
 
 			if (direction === "asc") {
-				sql.push(`ORDER BY "${name}" ASC`)
+				const orders = index.map((name) => `"${name}" ASC`).join(", ")
+				sql.push(`ORDER BY ${orders}`)
 			} else if (direction === "desc") {
-				sql.push(`ORDER BY "${name}" DESC`)
+				const orders = index.map((name) => `"${name}" DESC`).join(", ")
+				sql.push(`ORDER BY ${orders}`)
 			} else {
 				throw new Error("invalid orderBy direction")
 			}
@@ -621,10 +617,7 @@ export class RelationAPI {
 	readonly #insert: Method<{ _source: string; _target: string }>
 	readonly #delete: Method<{ _source: string }>
 
-	public constructor(
-		readonly db: OpfsDatabase,
-		readonly relation: Relation,
-	) {
+	public constructor(readonly db: OpfsDatabase, readonly relation: Relation) {
 		this.table = `${relation.source}/${relation.property}`
 		this.sourceIndex = `${relation.source}/${relation.property}/source`
 		this.targetIndex = `${relation.source}/${relation.property}/target`

diff --git a/packages/modeldb-sqlite/src/api.ts b/packages/modeldb-sqlite/src/api.ts
@@ -85,10 +85,7 @@ export class ModelAPI {
 
 	columnNames: `"${string}"`[]
 
-	public constructor(
-		readonly db: Database,
-		readonly model: Model,
-	) {
+	public constructor(readonly db: Database, readonly model: Model) {
 		this.#table = model.name
 		this.#params = {}
 		this.#properties = Object.fromEntries(model.properties.map((property) => [property.name, property]))
@@ -311,18 +308,17 @@ export class ModelAPI {
 		if (query.orderBy !== undefined) {
 			const orders = Object.entries(query.orderBy)
 			assert(orders.length === 1, "cannot order by multiple properties at once")
-			const [[name, direction]] = orders
-			const property = this.#properties[name]
-			assert(property !== undefined, "property not found")
-			assert(
-				property.kind === "primary" || property.kind === "primitive" || property.kind === "reference",
-				"cannot order by relation properties",
-			)
+			const [[indexName, direction]] = orders
+			const index = indexName.split("/")
+
+			assert(!index.some((name) => this.#properties[name]?.kind === "relation"), "cannot order by relation properties")
 
 			if (direction === "asc") {
-				sql.push(`ORDER BY "${name}" ASC`)
+				const orders = index.map((name) => `"${name}" ASC`).join(", ")
+				sql.push(`ORDER BY ${orders}`)
 			} else if (direction === "desc") {
-				sql.push(`ORDER BY "${name}" DESC`)
+				const orders = index.map((name) => `"${name}" DESC`).join(", ")
+				sql.push(`ORDER BY ${orders}`)
 			} else {
 				throw new Error("invalid orderBy direction")
 			}
@@ -590,10 +586,7 @@ export class RelationAPI {
 	readonly #insert: Method<{ _source: string; _target: string }>
 	readonly #delete: Method<{ _source: string }>
 
-	public constructor(
-		readonly db: Database,
-		readonly relation: Relation,
-	) {
+	public constructor(readonly db: Database, readonly relation: Relation) {
 		this.table = `${relation.source}/${relation.property}`
 		this.sourceIndex = `${relation.source}/${relation.property}/source`
 		this.targetIndex = `${relation.source}/${relation.property}/target`

diff --git a/packages/modeldb/test/indexes.test.ts b/packages/modeldb/test/indexes.test.ts
@@ -91,44 +91,48 @@ testOnModelDB("query (indexed order by)", async (t, openDB) => {
 	])
 })
 
-testOnModelDB("composite index", async (t, openDB) => {
-	const db = await openDB(t, {
-		user: {
-			id: "primary",
-			value: "integer",
-			$indexes: ["value/id"],
-		},
-	})
-
-	await db.set("user", { id: "a", value: 0 })
-	await db.set("user", { id: "b", value: 1 })
-	await db.set("user", { id: "c", value: 1 })
-	await db.set("user", { id: "d", value: 1 })
-	await db.set("user", { id: "e", value: 1 })
-	await db.set("user", { id: "f", value: 4 })
-
-	t.deepEqual(
-		await db.query("user", {
-			orderBy: { "value/id": "asc" },
-			where: { value: 1 },
-		}),
-		[
-			{ id: "b", value: 1 },
-			{ id: "c", value: 1 },
-			{ id: "d", value: 1 },
-			{ id: "e", value: 1 },
-		],
-	)
-
-	t.deepEqual(
-		await db.query("user", {
-			orderBy: { "value/id": "asc" },
-			where: { value: 1, id: { gt: "a", lte: "d" } },
-		}),
-		[
-			{ id: "b", value: 1 },
-			{ id: "c", value: 1 },
-			{ id: "d", value: 1 },
-		],
-	)
-})
+testOnModelDB(
+	"composite index",
+	async (t, openDB) => {
+		const db = await openDB(t, {
+			user: {
+				id: "primary",
+				value: "integer",
+				$indexes: ["value/id"],
+			},
+		})
+
+		await db.set("user", { id: "a", value: 0 })
+		await db.set("user", { id: "b", value: 1 })
+		await db.set("user", { id: "c", value: 1 })
+		await db.set("user", { id: "d", value: 1 })
+		await db.set("user", { id: "e", value: 1 })
+		await db.set("user", { id: "f", value: 4 })
+
+		t.deepEqual(
+			await db.query("user", {
+				orderBy: { "value/id": "asc" },
+				where: { value: 1 },
+			}),
+			[
+				{ id: "b", value: 1 },
+				{ id: "c", value: 1 },
+				{ id: "d", value: 1 },
+				{ id: "e", value: 1 },
+			],
+		)
+
+		t.deepEqual(
+			await db.query("user", {
+				orderBy: { "value/id": "asc" },
+				where: { value: 1, id: { gt: "a", lte: "d" } },
+			}),
+			[
+				{ id: "b", value: 1 },
+				{ id: "c", value: 1 },
+				{ id: "d", value: 1 },
+			],
+		)
+	},
+	// { sqlite: true },
+)