Columnar Storage

CREATE INDEX search_idx ON mock_items
USING paradedb (id, description, rating)
WITH (key_field = 'id');

import { indexing } from "@paradedb/drizzle-paradedb";

indexing
  .paradedbIndex("search_idx")
  .on(mockItems.id, mockItems.description, mockItems.rating);

from django.db import connection
from paradedb.indexes import ParadeDBIndex

with connection.schema_editor() as schema_editor:
    schema_editor.add_index(
        MockItem,
        ParadeDBIndex(
            fields={
                "id": {},
                "description": {},
                "rating": {},
            },
            key_field="id",
            name="search_idx",
        ),
    )

from sqlalchemy import Index
from paradedb.sqlalchemy import indexing

idx = Index(
    "search_idx",
    indexing.ParadeDBField(MockItem.id),
    indexing.ParadeDBField(MockItem.description),
    indexing.ParadeDBField(MockItem.rating),
    postgresql_using="paradedb",
    postgresql_with={"key_field": "id"},
)

with engine.begin() as conn:
    idx.create(conn)

ActiveRecord::Base.connection.add_paradedb_index(
  :mock_items,
  fields: {
    id: {},
    description: {},
    rating: {}
  },
  key_field: :id,
  name: :search_idx
)

modelBuilder.Entity<MockItem>()
    .HasParadeDbIndex("search_idx", e => e.Id)
    .HasField(e => e.Description)
    .HasField(e => e.Rating);

CREATE INDEX search_idx ON mock_items
USING paradedb (id, (description::pdb.unicode_words('columnar=true')), rating)
WITH (key_field = 'id');

import { indexing, tokenizer } from "@paradedb/drizzle-paradedb";

indexing
  .paradedbIndex("search_idx")
  .on(
    mockItems.id,
    indexing.paradedbField(
      mockItems.description,
      tokenizer.unicodeWords({ columnar: true }),
    ),
    mockItems.rating,
  );

from django.db import connection
from paradedb.indexes import ParadeDBIndex
from paradedb.search import Tokenizer

with connection.schema_editor() as schema_editor:
    schema_editor.add_index(
        MockItem,
        ParadeDBIndex(
            fields={
                "id": {},
                "description": {
                    "tokenizer": Tokenizer.unicode_words(
                        options={"columnar": True}
                    ),
                },
                "rating": {},
            },
            key_field="id",
            name="search_idx",
        ),
    )

from sqlalchemy import Index
from paradedb.sqlalchemy import indexing, tokenizer

idx = Index(
    "search_idx",
    indexing.ParadeDBField(MockItem.id),
    indexing.ParadeDBField(
        MockItem.description,
        tokenizer=tokenizer.unicode_words(options={"columnar": True}),
    ),
    indexing.ParadeDBField(MockItem.rating),
    postgresql_using="paradedb",
    postgresql_with={"key_field": "id"},
)

with engine.begin() as conn:
    idx.create(conn)

ActiveRecord::Base.connection.add_paradedb_index(
  :mock_items,
  fields: {
    id: {},
    description: {
      tokenizer: ParadeDB::Tokenizer.unicode_words(options: { columnar: true })
    },
    rating: {}
  },
  key_field: :id,
  name: :search_idx
)

modelBuilder.Entity<MockItem>()
    .HasParadeDbIndex("search_idx", e => e.Id)
    .HasField(e => e.Description, Tokenizer.Unicode(new() { ["columnar"] = true }))
    .HasField(e => e.Rating);