Connect Your App

import { drizzle } from "drizzle-orm/postgres-js";
import postgres from "postgres";
import {
  boolean,
  customType,
  date,
  integer,
  jsonb,
  pgTable,
  serial,
  text,
  time,
  timestamp,
  varchar,
  vector,
} from "drizzle-orm/pg-core";

export const client = postgres(
  "postgres://myuser:mypassword@localhost:5432/mydatabase",
);
export const db = drizzle({ client });

export const mockItems = pgTable("mock_items", {
  id: serial("id").primaryKey(),
  description: text("description"),
  rating: integer("rating"),
  category: varchar("category", { length: 255 }),
  inStock: boolean("in_stock"),
  metadata: jsonb("metadata"),
  createdAt: timestamp("created_at"),
  lastUpdatedDate: date("last_updated_date"),
  latestAvailableTime: time("latest_available_time"),
  weightRange: customType<{ data: string }>({
    dataType: () => "int4range",
  })("weight_range"),
  embedding: vector("embedding", { dimensions: 8 }),
});

INSTALLED_APPS = [
    ...,
    'django.contrib.postgres',
    'myapp',
]

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": "mydatabase",
        "USER": "myuser",
        "PASSWORD": "mypassword",
        "HOST": "localhost",
        "PORT": "5432",
    }
}

from django.db import models

from django.contrib.postgres.fields import IntegerRangeField
from paradedb.queryset import ParadeDBManager
from paradedb.vector import VectorField


class MockItem(models.Model):
    description = models.TextField(null=True, blank=True)
    rating = models.IntegerField(null=True, blank=True)
    category = models.CharField(max_length=255, null=True, blank=True)
    in_stock = models.BooleanField(null=True, blank=True)
    metadata = models.JSONField(null=True, blank=True)
    created_at = models.DateTimeField(null=True, blank=True)
    last_updated_date = models.DateField(null=True, blank=True)
    latest_available_time = models.TimeField(null=True, blank=True)
    weight_range = IntegerRangeField(null=True, blank=True)
    embedding = VectorField(dimensions=8, null=True, blank=True)

    objects = ParadeDBManager()

    class Meta:
        db_table = "mock_items"

sqlalchemy.url = postgresql+psycopg://myuser:mypassword@localhost:5432/mydatabase

from logging.config import fileConfig

from sqlalchemy import engine_from_config, text
from sqlalchemy import pool

from alembic import context
from models import Base

config = context.config

if config.config_file_name is not None:
    fileConfig(config.config_file_name)

target_metadata = Base.metadata

# The ParadeDB Docker image comes pre-bundled with some popular
# extensions like PostGIS. PostGIS automatically creates a table
# called `spatial_ref_sys`. This tells Alembic not to drop it even
# though it isn't tracked in Alembic's metadata.
IGNORED_TABLES = {"spatial_ref_sys"}


def include_object(object, name, type_, reflected, compare_to):
    if type_ == "table" and reflected and name in IGNORED_TABLES:
        return False
    return True


def run_migrations_offline() -> None:
    url = config.get_main_option("sqlalchemy.url")
    context.configure(
        url=url,
        target_metadata=target_metadata,
        literal_binds=True,
        dialect_opts={"paramstyle": "named"},
    )

    with context.begin_transaction():
        context.run_migrations()


def run_migrations_online() -> None:
    connectable = engine_from_config(
        config.get_section(config.config_ini_section, {}),
        prefix="sqlalchemy.",
        poolclass=pool.NullPool,
    )

    with connectable.connect() as connection:
        # This prevents Alembic from modifying tables outside
        # of the `public` schema.
        connection.execute(text("SET search_path TO public"))
        connection.commit()
        context.configure(
            connection=connection,
            target_metadata=target_metadata,
            include_object=include_object,
        )

        with context.begin_transaction():
            context.run_migrations()


if context.is_offline_mode():
    run_migrations_offline()
else:
    run_migrations_online()

gem "rails-paradedb", "0.12.0", require: "parade_db"

development:
  adapter: postgresql
  encoding: unicode
  database: mydatabase
  username: myuser
  password: mypassword
  host: localhost
  port: 5432

def up
  execute <<~SQL
    CALL paradedb.create_bm25_test_table(
      schema_name => 'public',
      table_name => 'mock_items'
    );
  SQL
end

def down
  drop_table :mock_items, if_exists: true
end

class MockItem < ApplicationRecord
  include ParadeDB::Model

  self.table_name = "mock_items"
  self.primary_key = "id"
end

using System.Text.Json;
using Microsoft.EntityFrameworkCore;
using NpgsqlTypes;
using ParadeDB.EntityFrameworkCore;
using ParadeDB.EntityFrameworkCore.Extensions;

await using var dbContext = new AppDbContext();

// Replace this with the query you want to run.
var results = await dbContext
    .MockItems.Where(item =>
        EF.Functions.MatchAny(item.Description, "running shoes") && item.Rating > 2
    )
    .OrderBy(item => item.Rating)
    .Select(item => new { item.Description, item.Rating, item.Category })
    .Take(5)
    .ToListAsync();

PrintResults(results);

static void PrintResults<T>(IReadOnlyList<T> rows)
{
  var properties = typeof(T).GetProperties();

  foreach (var property in properties)
  {
      Console.Write($"{property.Name,-24}");
  }

  Console.WriteLine();
  Console.WriteLine(new string('-', properties.Length * 24));

  foreach (var row in rows)
  {
      foreach (var property in properties)
      {
          var value = property.GetValue(row)?.ToString() ?? "";
          value = value.Length > 21 ? value[..21] + "..." : value;

          Console.Write($"{value,-24}");
      }

      Console.WriteLine();
  }
}

public sealed class AppDbContext : DbContext
{
    public DbSet<MockItem> MockItems => Set<MockItem>();

    protected override void OnConfiguring(DbContextOptionsBuilder options) =>
        options.UseNpgsql("Host=localhost;Port=5432;Database=mydatabase;Username=myuser;Password=mypassword", npgsql => npgsql.UseParadeDb());

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<MockItem>(entity =>
        {
            entity.ToTable("mock_items");
            entity.HasKey(item => item.Id);

            entity.Property(item => item.Id).HasColumnName("id");
            entity.Property(item => item.Description).HasColumnName("description");
            entity.Property(item => item.Rating).HasColumnName("rating");
            entity.Property(item => item.Category).HasColumnName("category").HasColumnType("varchar(255)");
            entity.Property(item => item.InStock).HasColumnName("in_stock");
            entity.Property(item => item.Metadata).HasColumnName("metadata").HasColumnType("jsonb");
            entity.Property(item => item.CreatedAt).HasColumnName("created_at").HasColumnType("timestamp");
            entity.Property(item => item.LastUpdatedDate).HasColumnName("last_updated_date").HasColumnType("date");
            entity.Property(item => item.LatestAvailableTime).HasColumnName("latest_available_time").HasColumnType("time");
            entity.Property(item => item.WeightRange).HasColumnName("weight_range").HasColumnType("int4range");
            entity.Property(item => item.Embedding).HasColumnName("embedding").HasColumnType("vector(8)");
        });
    }
}

public sealed class MockItem
{
    public int Id { get; set; }
    public string? Description { get; set; }
    public int? Rating { get; set; }
    public string? Category { get; set; }
    public bool? InStock { get; set; }
    public JsonDocument? Metadata { get; set; }
    public DateTime? CreatedAt { get; set; }
    public DateOnly? LastUpdatedDate { get; set; }
    public TimeOnly? LatestAvailableTime { get; set; }
    public NpgsqlRange<int>? WeightRange { get; set; }
    public float[]? Embedding { get; set; }
}