pgkiln 0.68.0 → 0.70.0

package/src/builder/i18n/ko.ts

@@ -1045,6 +1045,60 @@ export const ko: BuilderMessages = {
   'te.failed_stmt': '실패한 문장',
   'te.title_table': '테이블 {table}',
   'te.title_create': '테이블 생성',
+  'fts.add': "전체 텍스트 검색 추가",
+  'fts.title': "{table}의 전체 텍스트 검색",
+  'fts.intro': "선택한 텍스트 열에 대한 저장된 생성 tsvector 열과 그 위의 GIN 인덱스를 추가합니다. 그러면 검색 유형이 fulltext인 검색 구성(공유 구성 요소 › 검색 구성)이나 보고서 검색이 어형 변화(\"running\"으로 \"run\")를 빠르게 찾습니다. 열은 자동으로 최신 상태를 유지하며, 추가할 때 테이블이 다시 작성됩니다.",
+  'fts.columns': "텍스트 열",
+  'fts.include': "포함",
+  'fts.weight': "가중치",
+  'fts.weight_help': "순위에서 A가 가장 중요하고 D가 가장 덜 중요합니다. 예: 제목은 A, 설명은 B.",
+  'fts.config': "텍스트 검색 구성",
+  'fts.config_help': "어간 처리에 사용할 언어(english: running → run). simple: 어간 처리 없음. 검색할 때도 같은 구성을 사용하십시오.",
+  'fts.column': "tsvector 열",
+  'fts.index': "인덱스 이름",
+  'fts.no_text': "이 테이블에는 검색할 텍스트 열이 없습니다.",
+  'fts.pick': "텍스트 열을 하나 이상 선택하십시오.",
+  'fts.bad_name': "\"{name}\"은(는) 올바른 이름이 아닙니다: 소문자, 숫자, _만 사용할 수 있습니다.",
+  'fts.exists': "{name}이(가) 이미 있습니다.",
+  'fts.bad_config': "{name}은(는) 텍스트 검색 구성이 아닙니다.",
+  'fts.existing': "현재 tsvector 열:",
+  'fts.gin_yes': "GIN 인덱스",
+  'fts.gin_no': "GIN 인덱스 없음",
+  'fts.added': "{table}에 전체 텍스트 검색을 추가했습니다: 열 {column}, 인덱스 {index}.",
+  // (sprint 136, AP-1) Table Properties › Add vector column
+  'vec.add': "벡터 열 추가",
+  'vec.title': "{table}의 벡터 열",
+  'vec.intro': "임베딩 열 vector(n)(n: 벡터 공급자의 차원 수), 거리용 HNSW 인덱스, 그리고 소스 열이 바뀌면 행을 다시 임베딩하는 트리거를 추가합니다. 그러면 검색 유형 vector 또는 hybrid의 검색 구성이나 AI 에이전트의 Retrieve 도구가 의미로 행을 찾습니다. 지금 있는 행은 바로 임베딩 대기열에 들어갑니다.",
+  'vec.existing': "현재 벡터 열",
+  'vec.provider': "벡터 공급자",
+  'vec.provider_help': "이 작업 영역 애플리케이션의 공유 구성 요소 › 벡터 공급자. 검색할 때도 같은 공급자를 사용하십시오.",
+  'vec.keep': "최신 상태 유지",
+  'vec.keep_help': "함수 공급자는 트리거에서 바로 임베딩을 설정할 수 있습니다. AI 서비스는 서버가 호출합니다: 트리거가 행을 대기열에 넣고, 서버가 공급자의 분당 요청 수와 애플리케이션의 일일 AI 한도 안에서 대기열의 행을 일괄로 임베딩합니다.",
+  'vec.mode_set': "트리거가 바로 설정",
+  'vec.mode_queue': "서버용 대기열에 넣음",
+  'vec.sources': "소스 열",
+  'vec.sources_help': "임베딩할 텍스트: 이 열들, 한 줄에 하나씩. 그중 하나가 바뀌면 행을 다시 임베딩합니다.",
+  'vec.distance': "거리",
+  'vec.distance_help': "대부분의 임베딩 모델에는 cosine; 검색 구성도 같은 거리를 사용합니다.",
+  'vec.column': "벡터 열",
+  'vec.no_key': "테이블에 열 하나로 된 기본 키가 필요합니다: 대기열은 그것으로 행을 찾습니다.",
+  'vec.pick_provider': "벡터 공급자를 선택하십시오.",
+  'vec.no_providers': "이 작업 영역의 애플리케이션에는 아직 벡터 공급자가 없습니다: 공유 구성 요소 › 벡터 공급자에서 추가하십시오.",
+  'vec.missing': "이 데이터베이스에 pgvector 확장이 설치되어 있지 않아 아직 벡터 열을 추가할 수 없습니다.",
+  'vec.missing_create': "데이터베이스 서버에 pgvector {version}이(가) 있습니다: 작업 영역 유틸리티 › 벡터 공급자에서 확장을 만드십시오.",
+  'vec.missing_admin': "데이터베이스 서버에 pgvector {version}이(가) 있습니다: 관리자가 확장을 만듭니다(작업 영역 유틸리티 › 벡터 공급자).",
+  'vec.missing_package': "데이터베이스 서버에 pgvector 패키지가 없습니다: 설치한 다음(예: apt install postgresql-17-pgvector 또는 Docker 이미지 pgvector/pgvector) 확장을 만드십시오.",
+  'vec.utilities': "작업 영역 유틸리티 › 벡터 공급자",
+  'vec.kept_by': "{provider}이(가) {columns}에서 유지",
+  'vec.not_kept': "최신 상태로 유지하는 트리거가 없음",
+  'vec.progress': "{column}의 임베딩된 행",
+  'vec.counts': "{total}행 중 {done}행 임베딩됨, {queued}행 대기 중",
+  'vec.failing': "{n}건 실패",
+  'vec.reembed_all': "임베딩이 없는 행만이 아니라 모든 행",
+  'vec.backfill': "채우기",
+  'vec.refresh': "새로 고침",
+  'vec.backfill_queued': "{column}의 {n}행을 임베딩 대기열에 넣었습니다.",
+  'vec.added': "{table}에 벡터 열 {column}을(를) 추가했습니다. {n}행이 임베딩 대기열에 있습니다.",
   // ------------------------------------------------------------ Shared Components (sprint 124)
   'comp.nav_entry': '탐색 항목',
   'comp.nav_entry.plural': '탐색 메뉴',

package/src/builder/i18n/nl.ts

@@ -1045,6 +1045,60 @@ export const nl: BuilderMessages = {
   'te.failed_stmt': 'Mislukt statement',
   'te.title_table': 'Tabel {table}',
   'te.title_create': 'Tabel maken',
+  'fts.add': "Volledige-tekstzoeken toevoegen",
+  'fts.title': "Volledige-tekstzoeken op {table}",
+  'fts.intro': "Voegt een opgeslagen gegenereerde tsvector-kolom toe over de tekstkolommen die u kiest, met een GIN-index erop. Een zoekconfiguratie van zoektype fulltext (Gedeelde componenten › Zoekconfiguraties) of het zoeken in een rapport vindt dan snel woorden in al hun vormen (\"running\" vindt \"run\"). De kolom houdt zichzelf bij; toevoegen herschrijft de tabel.",
+  'fts.columns': "Tekstkolommen",
+  'fts.include': "Meenemen",
+  'fts.weight': "Gewicht",
+  'fts.weight_help': "A telt het zwaarst in de rangorde, D het minst: bijvoorbeeld A voor een titel, B voor een omschrijving.",
+  'fts.config': "Tekstzoekconfiguratie",
+  'fts.config_help': "De taal waarvan de woordstammen worden gebruikt (dutch: lopen → loop); simple: geen stammen. Zoek met dezelfde configuratie.",
+  'fts.column': "tsvector-kolom",
+  'fts.index': "Indexnaam",
+  'fts.no_text': "Deze tabel heeft geen tekstkolommen om in te zoeken.",
+  'fts.pick': "Kies ten minste één tekstkolom.",
+  'fts.bad_name': "\"{name}\" is geen geldige naam: kleine letters, cijfers en _.",
+  'fts.exists': "{name} bestaat al.",
+  'fts.bad_config': "{name} is geen tekstzoekconfiguratie.",
+  'fts.existing': "tsvector-kolommen nu:",
+  'fts.gin_yes': "GIN-index",
+  'fts.gin_no': "geen GIN-index",
+  'fts.added': "Volledige-tekstzoeken toegevoegd aan {table}: kolom {column} met index {index}.",
+  // (sprint 136, AP-1) Table Properties › Add vector column
+  'vec.add': "Vectorkolom toevoegen",
+  'vec.title': "Vectorkolom op {table}",
+  'vec.intro': "Voegt een embeddingkolom vector(n) toe (n: de dimensies van de vectorprovider), een HNSW-index voor de afstand, en een trigger die een rij opnieuw embedt als de bronkolommen veranderen. Een zoekconfiguratie van het type vector of hybrid, of de Retrieve-tool van een AI-agent, vindt rijen dan op betekenis. De rijen die er nu zijn, komen meteen in de wachtrij voor hun embeddings.",
+  'vec.existing': "Vectorkolommen nu",
+  'vec.provider': "Vectorprovider",
+  'vec.provider_help': "Gedeelde componenten › Vectorproviders van de applicaties in deze werkruimte. Zoek met dezelfde provider.",
+  'vec.keep': "Actueel houden",
+  'vec.keep_help': "Een functieprovider kan de embedding meteen in de trigger zetten. Een AI-service wordt door de server aangeroepen: de trigger zet de rij in de wachtrij en de server embedt rijen in batches, binnen de verzoeken per minuut van de provider en de dagelijkse AI-limieten van de applicatie.",
+  'vec.mode_set': "door de trigger gezet, meteen",
+  'vec.mode_queue': "in de wachtrij voor de server",
+  'vec.sources': "Bronkolommen",
+  'vec.sources_help': "De tekst die wordt ge-embed: deze kolommen, één per regel. Een wijziging in een ervan embedt de rij opnieuw.",
+  'vec.distance': "Afstand",
+  'vec.distance_help': "cosine voor de meeste embeddingmodellen; de zoekconfiguratie gebruikt dezelfde afstand.",
+  'vec.column': "Vectorkolom",
+  'vec.no_key': "De tabel heeft een primaire sleutel van één kolom nodig: de wachtrij vindt rijen daarmee.",
+  'vec.pick_provider': "Kies een vectorprovider.",
+  'vec.no_providers': "Nog geen applicatie in deze werkruimte heeft een vectorprovider: voeg er een toe onder Gedeelde componenten › Vectorproviders.",
+  'vec.missing': "De extensie pgvector is niet geïnstalleerd in deze database, dus een vectorkolom kan nog niet worden toegevoegd.",
+  'vec.missing_create': "De databaseserver heeft pgvector {version}: maak de extensie aan onder Werkruimtehulpmiddelen › Vectorproviders.",
+  'vec.missing_admin': "De databaseserver heeft pgvector {version}: een beheerder maakt de extensie aan (Werkruimtehulpmiddelen › Vectorproviders).",
+  'vec.missing_package': "De databaseserver heeft het pakket pgvector niet: installeer het (bijv. apt install postgresql-17-pgvector, of het Docker-image pgvector/pgvector) en maak dan de extensie aan.",
+  'vec.utilities': "Werkruimtehulpmiddelen › Vectorproviders",
+  'vec.kept_by': "bijgehouden door {provider} uit {columns}",
+  'vec.not_kept': "geen trigger houdt hem actueel",
+  'vec.progress': "Ge-embede rijen van {column}",
+  'vec.counts': "{done} van {total} rijen ge-embed, {queued} in de wachtrij",
+  'vec.failing': "{n} mislukt",
+  'vec.reembed_all': "alle rijen, niet alleen die zonder embedding",
+  'vec.backfill': "Aanvullen",
+  'vec.refresh': "Vernieuwen",
+  'vec.backfill_queued': "{n} rijen van {column} in de wachtrij voor hun embeddings.",
+  'vec.added': "Vectorkolom {column} toegevoegd aan {table}; {n} rijen in de wachtrij voor hun embeddings.",
   // ------------------------------------------------------------ Shared Components (sprint 124)
   'comp.nav_entry': 'Navigatie-item',
   'comp.nav_entry.plural': 'Navigatiemenu',

package/src/builder/i18n/pt.ts

@@ -1045,6 +1045,60 @@ export const pt: BuilderMessages = {
   'te.failed_stmt': 'Instrução com falha',
   'te.title_table': 'Tabela {table}',
   'te.title_create': 'Criar tabela',
+  'fts.add': "Adicionar pesquisa de texto integral",
+  'fts.title': "Pesquisa de texto integral em {table}",
+  'fts.intro': "Adiciona uma coluna tsvector gerada e armazenada sobre as colunas de texto escolhidas, com um índice GIN. Uma configuração de pesquisa do tipo fulltext (Componentes partilhados › Configurações de pesquisa) ou a pesquisa de um relatório encontra então rapidamente as formas das palavras (\"running\" encontra \"run\"). A coluna mantém-se atualizada; adicioná-la reescreve a tabela.",
+  'fts.columns': "Colunas de texto",
+  'fts.include': "Incluir",
+  'fts.weight': "Peso",
+  'fts.weight_help': "A conta mais na classificação, D menos: p. ex. A para um título, B para uma descrição.",
+  'fts.config': "Configuração de pesquisa de texto",
+  'fts.config_help': "A língua cuja radicalização é usada (portuguese: correndo → corr); simple: sem radicalização. Pesquise com a mesma configuração.",
+  'fts.column': "Coluna tsvector",
+  'fts.index': "Nome do índice",
+  'fts.no_text': "Esta tabela não tem colunas de texto para pesquisar.",
+  'fts.pick': "Escolha pelo menos uma coluna de texto.",
+  'fts.bad_name': "\"{name}\" não é um nome válido: minúsculas, dígitos e _.",
+  'fts.exists': "{name} já existe.",
+  'fts.bad_config': "{name} não é uma configuração de pesquisa de texto.",
+  'fts.existing': "Colunas tsvector atuais:",
+  'fts.gin_yes': "índice GIN",
+  'fts.gin_no': "sem índice GIN",
+  'fts.added': "Pesquisa de texto integral adicionada a {table}: coluna {column} com o índice {index}.",
+  // (sprint 136, AP-1) Table Properties › Add vector column
+  'vec.add': "Adicionar coluna vetorial",
+  'vec.title': "Coluna vetorial em {table}",
+  'vec.intro': "Adiciona uma coluna de embedding vector(n) (n: as dimensões do fornecedor de vetores), um índice HNSW para a distância e um gatilho que recalcula o embedding de uma linha quando as colunas de origem mudam. Uma configuração de pesquisa do tipo vector ou hybrid, ou a ferramenta Retrieve de um agente de IA, encontra então as linhas pelo significado. As linhas que já existem entram logo na fila para os seus embeddings.",
+  'vec.existing': "Colunas vetoriais atuais",
+  'vec.provider': "Fornecedor de vetores",
+  'vec.provider_help': "Componentes partilhados › Fornecedores de vetores das aplicações deste espaço de trabalho. Pesquise com o mesmo fornecedor.",
+  'vec.keep': "Manter atualizada",
+  'vec.keep_help': "Um fornecedor do tipo função pode definir o embedding no gatilho, de imediato. Um serviço de IA é chamado pelo servidor: o gatilho põe a linha na fila e o servidor calcula os embeddings em lotes, dentro dos pedidos por minuto do fornecedor e dos limites diários de IA da aplicação.",
+  'vec.mode_set': "definido pelo gatilho, de imediato",
+  'vec.mode_queue': "na fila para o servidor",
+  'vec.sources': "Colunas de origem",
+  'vec.sources_help': "O texto de que se calcula o embedding: estas colunas, uma por linha. Uma alteração numa delas recalcula o embedding da linha.",
+  'vec.distance': "Distância",
+  'vec.distance_help': "cosine para a maioria dos modelos de embedding; a configuração de pesquisa usa a mesma distância.",
+  'vec.column': "Coluna vetorial",
+  'vec.no_key': "A tabela precisa de uma chave primária de uma só coluna: a fila encontra as linhas por ela.",
+  'vec.pick_provider': "Escolha um fornecedor de vetores.",
+  'vec.no_providers': "Nenhuma aplicação deste espaço de trabalho tem ainda um fornecedor de vetores: adicione um em Componentes partilhados › Fornecedores de vetores.",
+  'vec.missing': "A extensão pgvector não está instalada nesta base de dados, por isso ainda não é possível adicionar uma coluna vetorial.",
+  'vec.missing_create': "O servidor de base de dados tem o pgvector {version}: crie a extensão em Utilitários do espaço de trabalho › Fornecedores de vetores.",
+  'vec.missing_admin': "O servidor de base de dados tem o pgvector {version}: um administrador cria a extensão (Utilitários do espaço de trabalho › Fornecedores de vetores).",
+  'vec.missing_package': "O servidor de base de dados não tem o pacote pgvector: instale-o (p. ex. apt install postgresql-17-pgvector, ou a imagem Docker pgvector/pgvector) e depois crie a extensão.",
+  'vec.utilities': "Utilitários do espaço de trabalho › Fornecedores de vetores",
+  'vec.kept_by': "mantida por {provider} a partir de {columns}",
+  'vec.not_kept': "nenhum gatilho a mantém atualizada",
+  'vec.progress': "Linhas de {column} com embedding",
+  'vec.counts': "{done} de {total} linhas com embedding, {queued} na fila",
+  'vec.failing': "{n} com erro",
+  'vec.reembed_all': "todas as linhas, não só as que não têm embedding",
+  'vec.backfill': "Completar",
+  'vec.refresh': "Atualizar",
+  'vec.backfill_queued': "{n} linhas de {column} na fila para os seus embeddings.",
+  'vec.added': "Coluna vetorial {column} adicionada a {table}; {n} linhas na fila para os seus embeddings.",
   // ------------------------------------------------------------ Shared Components (sprint 124)
   'comp.nav_entry': 'Entrada de navegação',
   'comp.nav_entry.plural': 'Menu de navegação',

package/src/builder/i18n/zh-cn.ts

@@ -1045,6 +1045,60 @@ export const zhCN: BuilderMessages = {
   'te.failed_stmt': '失败的语句',
   'te.title_table': '表 {table}',
   'te.title_create': '创建表',
+  'fts.add': "添加全文搜索",
+  'fts.title': "{table} 的全文搜索",
+  'fts.intro': "在所选的文本列上添加一个存储的生成 tsvector 列，并在其上创建 GIN 索引。之后，搜索类型为 fulltext 的搜索配置（共享组件 › 搜索配置）或报表搜索即可快速找到词形变化（\"running\" 可找到 \"run\"）。该列会自动保持最新；添加时会重写该表。",
+  'fts.columns': "文本列",
+  'fts.include': "包含",
+  'fts.weight': "权重",
+  'fts.weight_help': "A 在排序中最重要，D 最不重要：例如标题用 A，描述用 B。",
+  'fts.config': "文本搜索配置",
+  'fts.config_help': "使用其词干规则的语言（english：running → run）；simple：不提取词干。搜索时请使用相同的配置。",
+  'fts.column': "tsvector 列",
+  'fts.index': "索引名称",
+  'fts.no_text': "此表没有可搜索的文本列。",
+  'fts.pick': "请至少选择一个文本列。",
+  'fts.bad_name': "\"{name}\" 不是有效名称：只能使用小写字母、数字和 _。",
+  'fts.exists': "{name} 已存在。",
+  'fts.bad_config': "{name} 不是文本搜索配置。",
+  'fts.existing': "现有 tsvector 列：",
+  'fts.gin_yes': "GIN 索引",
+  'fts.gin_no': "无 GIN 索引",
+  'fts.added': "已为 {table} 添加全文搜索：列 {column}，索引 {index}。",
+  // (sprint 136, AP-1) Table Properties › Add vector column
+  'vec.add': "添加向量列",
+  'vec.title': "{table} 的向量列",
+  'vec.intro': "添加一个嵌入列 vector(n)（n：向量提供者的维数）、一个用于该距离的 HNSW 索引，以及在源列变化时重新嵌入该行的触发器。之后，搜索类型为 vector 或 hybrid 的搜索配置，或 AI 代理的 Retrieve 工具，就能按含义找到行。现有的行会立即进入嵌入队列。",
+  'vec.existing': "当前的向量列",
+  'vec.provider': "向量提供者",
+  'vec.provider_help': "此工作区应用程序的共享组件 › 向量提供者。搜索时使用同一个提供者。",
+  'vec.keep': "保持最新",
+  'vec.keep_help': "函数提供者可以在触发器中立即设置嵌入。AI 服务由服务器调用：触发器把行放入队列，服务器在提供者的每分钟请求数和应用程序的每日 AI 限额内批量嵌入队列中的行。",
+  'vec.mode_set': "由触发器立即设置",
+  'vec.mode_queue': "放入服务器的队列",
+  'vec.sources': "源列",
+  'vec.sources_help': "要嵌入的文本：这些列，每行一个。其中任一列变化时会重新嵌入该行。",
+  'vec.distance': "距离",
+  'vec.distance_help': "大多数嵌入模型使用 cosine；搜索配置使用相同的距离。",
+  'vec.column': "向量列",
+  'vec.no_key': "该表需要一个单列主键：队列据此查找行。",
+  'vec.pick_provider': "请选择一个向量提供者。",
+  'vec.no_providers': "此工作区的应用程序还没有向量提供者：请在共享组件 › 向量提供者中添加。",
+  'vec.missing': "此数据库未安装 pgvector 扩展，因此暂时无法添加向量列。",
+  'vec.missing_create': "数据库服务器有 pgvector {version}：请在工作区实用工具 › 向量提供者中创建该扩展。",
+  'vec.missing_admin': "数据库服务器有 pgvector {version}：由管理员创建该扩展（工作区实用工具 › 向量提供者）。",
+  'vec.missing_package': "数据库服务器没有 pgvector 软件包：请先安装（例如 apt install postgresql-17-pgvector，或 Docker 镜像 pgvector/pgvector），再创建该扩展。",
+  'vec.utilities': "工作区实用工具 › 向量提供者",
+  'vec.kept_by': "由 {provider} 根据 {columns} 维护",
+  'vec.not_kept': "没有触发器保持其最新",
+  'vec.progress': "{column} 已嵌入的行",
+  'vec.counts': "{total} 行中已嵌入 {done} 行，{queued} 行在队列中",
+  'vec.failing': "{n} 行失败",
+  'vec.reembed_all': "所有行，而不仅是没有嵌入的行",
+  'vec.backfill': "回填",
+  'vec.refresh': "刷新",
+  'vec.backfill_queued': "已将 {column} 的 {n} 行放入嵌入队列。",
+  'vec.added': "已为 {table} 添加向量列 {column}；{n} 行已进入嵌入队列。",
   // ------------------------------------------------------------ Shared Components (sprint 124)
   'comp.nav_entry': '导航条目',
   'comp.nav_entry.plural': '导航菜单',

package/src/builder/i18n/zh-tw.ts

@@ -1045,6 +1045,60 @@ export const zhTW: BuilderMessages = {
   'te.failed_stmt': '失敗的敘述句',
   'te.title_table': '表格 {table}',
   'te.title_create': '建立表格',
+  'fts.add': "新增全文檢索",
+  'fts.title': "{table} 的全文檢索",
+  'fts.intro': "在所選的文字欄位上新增一個儲存的產生 tsvector 欄位，並在其上建立 GIN 索引。之後，搜尋類型為 fulltext 的搜尋設定（共用元件 › 搜尋設定）或報表搜尋即可快速找到詞形變化（\"running\" 可找到 \"run\"）。該欄位會自動保持最新；新增時會重寫該表格。",
+  'fts.columns': "文字欄位",
+  'fts.include': "包含",
+  'fts.weight': "權重",
+  'fts.weight_help': "A 在排序中最重要，D 最不重要：例如標題用 A，描述用 B。",
+  'fts.config': "文字搜尋設定",
+  'fts.config_help': "使用其詞幹規則的語言（english：running → run）；simple：不擷取詞幹。搜尋時請使用相同的設定。",
+  'fts.column': "tsvector 欄位",
+  'fts.index': "索引名稱",
+  'fts.no_text': "此表格沒有可搜尋的文字欄位。",
+  'fts.pick': "請至少選擇一個文字欄位。",
+  'fts.bad_name': "\"{name}\" 不是有效名稱：只能使用小寫字母、數字和 _。",
+  'fts.exists': "{name} 已存在。",
+  'fts.bad_config': "{name} 不是文字搜尋設定。",
+  'fts.existing': "現有 tsvector 欄位：",
+  'fts.gin_yes': "GIN 索引",
+  'fts.gin_no': "無 GIN 索引",
+  'fts.added': "已為 {table} 新增全文檢索：欄位 {column}，索引 {index}。",
+  // (sprint 136, AP-1) Table Properties › Add vector column
+  'vec.add': "新增向量欄位",
+  'vec.title': "{table} 的向量欄位",
+  'vec.intro': "新增一個嵌入欄位 vector(n)（n：向量提供者的維度數）、一個用於該距離的 HNSW 索引，以及在來源欄位變更時重新嵌入該列的觸發程序。之後，搜尋類型為 vector 或 hybrid 的搜尋組態，或 AI 代理的 Retrieve 工具，就能依含意找到資料列。現有的資料列會立即進入嵌入佇列。",
+  'vec.existing': "目前的向量欄位",
+  'vec.provider': "向量提供者",
+  'vec.provider_help': "此工作區應用程式的共用元件 › 向量提供者。搜尋時使用同一個提供者。",
+  'vec.keep': "保持最新",
+  'vec.keep_help': "函式提供者可以在觸發程序中立即設定嵌入。AI 服務由伺服器呼叫：觸發程序將資料列放入佇列，伺服器在提供者的每分鐘請求數與應用程式的每日 AI 上限內，批次嵌入佇列中的資料列。",
+  'vec.mode_set': "由觸發程序立即設定",
+  'vec.mode_queue': "放入伺服器的佇列",
+  'vec.sources': "來源欄位",
+  'vec.sources_help': "要嵌入的文字：這些欄位，每行一個。其中任一欄位變更時會重新嵌入該列。",
+  'vec.distance': "距離",
+  'vec.distance_help': "大多數嵌入模型使用 cosine；搜尋組態使用相同的距離。",
+  'vec.column': "向量欄位",
+  'vec.no_key': "此表格需要單一欄位的主索引鍵：佇列以此找出資料列。",
+  'vec.pick_provider': "請選擇一個向量提供者。",
+  'vec.no_providers': "此工作區的應用程式還沒有向量提供者：請在共用元件 › 向量提供者中新增。",
+  'vec.missing': "此資料庫未安裝 pgvector 擴充功能，因此暫時無法新增向量欄位。",
+  'vec.missing_create': "資料庫伺服器有 pgvector {version}：請在工作區公用程式 › 向量提供者中建立該擴充功能。",
+  'vec.missing_admin': "資料庫伺服器有 pgvector {version}：由管理員建立該擴充功能（工作區公用程式 › 向量提供者）。",
+  'vec.missing_package': "資料庫伺服器沒有 pgvector 套件：請先安裝（例如 apt install postgresql-17-pgvector，或 Docker 映像檔 pgvector/pgvector），再建立該擴充功能。",
+  'vec.utilities': "工作區公用程式 › 向量提供者",
+  'vec.kept_by': "由 {provider} 依 {columns} 維護",
+  'vec.not_kept': "沒有觸發程序讓它保持最新",
+  'vec.progress': "{column} 已嵌入的資料列",
+  'vec.counts': "{total} 列中已嵌入 {done} 列，{queued} 列在佇列中",
+  'vec.failing': "{n} 列失敗",
+  'vec.reembed_all': "所有資料列，而不只是沒有嵌入的資料列",
+  'vec.backfill': "回填",
+  'vec.refresh': "重新整理",
+  'vec.backfill_queued': "已將 {column} 的 {n} 列放入嵌入佇列。",
+  'vec.added': "已為 {table} 新增向量欄位 {column}；{n} 列已進入嵌入佇列。",
   // ------------------------------------------------------------ Shared Components (sprint 124)
   'comp.nav_entry': '導覽項目',
   'comp.nav_entry.plural': '導覽選單',

package/src/builder/object-actions.ts

@@ -32,6 +32,8 @@ export function objectMenu(schema: string, o: MenuObj): Raw {
       ${table ? item(`${BASE}/sql/objects/table?${new URLSearchParams({ schema, template: o.ref })}`, 'copy', 'Use as template') : ''}
       ${table ? item(`${BASE}/sql/objects/security?${new URLSearchParams({ o: o.ref })}`, 'shield', 'Security…') : ''}
       ${table ? item(`${BASE}/sql/load`, 'upload', 'Load data') : ''}
+      ${table ? item(`${BASE}/sql/objects/fulltext?${new URLSearchParams({ o: o.ref })}`, 'search', 'Add full-text search…') : ''}
+      ${table ? item(`${BASE}/sql/objects/vector?${new URLSearchParams({ o: o.ref })}`, 'search', 'Add vector column…') : ''}
       ${table ? html`${item(q('index'), 'list', 'Add index')}${item(q('trigger'), 'bolt', 'Add trigger')}${item(q('policy'), 'shield', 'Add policy')}` : ''}
       ${RELATIONS.has(o.type) ? item(`${BASE}/sql/rest/object?${new URLSearchParams({ schema, name: o.name })}`, 'globe', 'REST › Enable / Disable') : ''}
       ${item(q('ddl'), 'code', 'Quick DDL to the worksheet')}

package/src/builder/shared.ts

@@ -76,7 +76,7 @@ export function sharedGroups(appId: number): { key: string; title: string; icon:
     { key: 'data', title: 'Data Sources', icon: 'database', items: [t('rest_source', 'REST Data Sources'), t('web_credential', 'Web Credentials'), t('rest_module', 'RESTful Services'), t('data_load_def', 'Data Load Definitions')] },
     { key: 'workflows', title: 'Workflows and Automations', icon: 'activity', items: [t('workflow_definition', 'Workflows'), t('task_definition', 'Task Definitions'), t('automation', 'Automations')] },
     { key: 'globalization', title: 'Globalization', icon: 'globe', items: [page('globalization', 'Translations and Text Messages'), t('dynamic_translation', 'Dynamic Translations'), settings('globalization', 'Globalization Attributes')] },
-    { key: 'ai', title: 'Generative AI', icon: 'lightbulb', items: [page('ai', 'AI Services'), page('ai-agents', 'AI Agents')] },
+    { key: 'ai', title: 'Generative AI', icon: 'lightbulb', items: [page('ai', 'AI Services'), page('ai-agents', 'AI Agents'), page('vector-providers', 'Vector Providers')] },
   ];
 }
 

package/src/builder/sql.ts

@@ -19,6 +19,8 @@ import { sqlUtilityRoutes } from './sql-utilities.ts';
 import { createTemplate, objectBrowserRoutes } from './object-browser.ts';
 import { objectActionRoutes } from './object-actions.ts';
 import { tableEditorRoutes } from './table-editor.ts';
+import { fulltextRoutes } from './fulltext.ts';
+import { vectorColumnRoutes } from './vector-column.ts';
 import { dataSecurityRoutes } from './data-security.ts';
 import { dataModelerRoutes } from './data-modeler.ts';
 import { autoRestBuilderRoutes } from './autorest.ts';
@@ -134,6 +136,10 @@ export async function sqlRoutes(app: FastifyInstance) {
   await app.register(objectActionRoutes);
   // (sprint 95) Table Properties: create, edit or copy a table in a form
   await app.register(tableEditorRoutes);
+  // (sprint 135, AP-2) Table Properties › Add full-text search
+  await app.register(fulltextRoutes);
+  // (sprint 136, AP-1) Table Properties › Add vector column
+  await app.register(vectorColumnRoutes);
   await app.register(dataSecurityRoutes);
   // (sprint 98) the Data Modeler: relational diagrams, their DDL and data dictionary
   await app.register(dataModelerRoutes);

package/src/builder/table-editor.ts

@@ -142,6 +142,8 @@ function form(s: Session, def: TableDef, opts: { editing: TableDef | null; schem
       <button class="btn" name="mode" value="preview">${icon('eye')} ${tx('te.preview')}</button>
       <button class="btn btn-hot" name="mode" value="apply">${icon('check')} ${tx('te.apply')}</button>
       <button class="btn" name="mode" value="worksheet">${icon('code')} ${tx('te.open_ws')}</button>
+      ${editing ? html`<a class="btn" href="${BASE}/sql/objects/fulltext?${new URLSearchParams({ o: opts.ref })}">${icon('search')} ${tx('fts.add')}…</a>` : ''}
+      ${editing ? html`<a class="btn" href="${BASE}/sql/objects/vector?${new URLSearchParams({ o: opts.ref })}">${icon('search')} ${tx('vec.add')}…</a>` : ''}
       <a class="btn" href="${editing ? `${BASE}/sql/objects?${new URLSearchParams({ schema: def.schema, k: 'table', o: opts.ref })}` : `${BASE}/sql/objects?${new URLSearchParams({ schema: def.schema })}`}">${tx('common.cancel')}</a>
     </div></form>`;
 }

package/src/builder/vector-column.ts

@@ -0,0 +1,229 @@
+import type { FastifyInstance, FastifyReply } from 'fastify';
+import pg from 'pg';
+import { HNSW_MAX_DIMENSIONS, vectorProviderProblems, type VectorProvider } from '../ai/embeddings.ts';
+import { joinStatements, recordChanges } from '../changelog.ts';
+import { owner } from '../db.ts';
+import { html, type Raw } from '../html.ts';
+import { icon } from '../icons.ts';
+import { clientIp, logActivity } from '../session.ts';
+import { readTable } from '../tabledef.ts';
+import { backfill, DISTANCES, isDistance, kickEmbeddings, pgvectorStatus, queueState, vectorTriggers, type Distance } from '../vector.ts';
+import { clearCompletions } from './code-editor.ts';
+import { tr } from './i18n.ts';
+import { isAdmin } from './locks.ts';
+import { SYSTEM_SCHEMAS } from './object-browser.ts';
+import { back, BASE, csrf, developer, flash, send, shell, workshopTabs, type Body, type Req } from './ui.ts';
+import { appAllowed, currentWorkspace, inWorkspaceSql, usableSchemas, workshopDb } from './workspaces.ts';
+
+// (sprint 136, AP-1) SQL Workshop › Table Properties › Add vector column: an embedding column vector(n) (n: the
+// chosen vector provider's dimensions), an HNSW index for the distance (vector_cosine_ops …), and a trigger that
+// keeps it current when the source columns change:
+//  - a function provider: BEFORE INSERT OR UPDATE OF … → meta.embedding_set (the embedding at once);
+//  - an AI service (or a function, if chosen): AFTER INSERT OR UPDATE OF … → meta.embedding_enqueue (the row's key
+//    queued; the server embeds queued rows in batches, src/vector.ts).
+// Preview DDL shows the statements; Apply runs them in one transaction with the workshop's connection and records
+// them in the Change Log; Open in the worksheet puts them there. The page also lists the table's vector columns
+// with their progress (rows embedded, queued, failing) and a Backfill button that queues the rows without an
+// embedding (or all rows). Names come from the catalog or are checked as plain identifiers before they reach DDL.
+
+type Db = Awaited<ReturnType<typeof workshopDb>>;
+const NAME = /^[a-z_][a-z0-9_]{0,62}$/;
+const ident = (n: string) => (/^[a-z_][a-z0-9_$]*$/.test(n) ? n : pg.escapeIdentifier(n));
+
+interface Col { name: string; type: string; texty: boolean; dims: number | null; vector: boolean }
+
+async function columnsOf(db: Db, oid: number): Promise<Col[]> {
+  return (await db.query<Col>(
+    `select a.attname as name, format_type(a.atttypid, a.atttypmod) as type, t.typcategory = 'S' and a.attgenerated = '' as texty,
+            t.typname = 'vector' as vector, case when t.typname = 'vector' and a.atttypmod > 0 then a.atttypmod end as dims
+       from pg_attribute a join pg_type t on t.oid = a.atttypid
+      where a.attrelid = $1 and a.attnum > 0 and not a.attisdropped order by a.attnum`, [oid])).rows;
+}
+
+/** The single-column primary key of a table (the queue keys rows by it), or null. */
+async function keyOf(db: Db, oid: number) {
+  return (await db.one<{ k: string }>(
+    `select a.attname as k from pg_index i join pg_attribute a on a.attrelid = i.indrelid and a.attnum = i.indkey[0]
+      where i.indrelid = $1 and i.indisprimary and i.indnatts = 1`, [oid]))?.k ?? null;
+}
+
+/** The workspace's applications' vector providers, as options "appId:NAME". */
+async function providerChoices(s: Parameters<typeof currentWorkspace>[0]) {
+  const apps = (await owner.query<{ id: number; alias: string; vector_providers: VectorProvider[] }>(
+    `select id, alias, vector_providers from meta.app a where ${inWorkspaceSql('a', 1)} and jsonb_array_length(vector_providers) > 0 order by alias`, [currentWorkspace(s)])).rows;
+  return apps.flatMap((a) => a.vector_providers.filter((p) => !vectorProviderProblems(p).length).map((p) => ({ key: `${a.id}:${p.name}`, appId: a.id, alias: a.alias, p })));
+}
+
+/** The statements: the column, its HNSW index (up to 2,000 dimensions) and the trigger that keeps it. */
+export function vectorDdl(o: { table: string; vectorType: string; column: string; index: string; trigger: string; dims: number; distance: Distance; mode: 'set' | 'queue'; appId: number; provider: string; key: string; sources: string[] }) {
+  const args = [String(o.appId), o.provider, o.column, o.key, ...o.sources].map((x) => pg.escapeLiteral(x)).join(', ');
+  return [
+    `alter table ${o.table}\n  add column ${ident(o.column)} ${o.vectorType}(${o.dims})`,
+    ...(o.dims <= HNSW_MAX_DIMENSIONS ? [`create index ${ident(o.index)} on ${o.table} using hnsw (${ident(o.column)} ${DISTANCES[o.distance].opclass})`] : []),
+    o.mode === 'set'
+      ? `create trigger ${ident(o.trigger)}\n  before insert or update of ${o.sources.map(ident).join(', ')} on ${o.table}\n  for each row execute function meta.embedding_set(${args})`
+      : `create trigger ${ident(o.trigger)}\n  after insert or update of ${o.sources.map(ident).join(', ')} on ${o.table}\n  for each row execute function meta.embedding_enqueue(${args})`,
+  ];
+}
+
+async function page(req: Req, reply: FastifyReply) {
+  const s = await developer(req, reply);
+  if (!s) return;
+  const tx = tr(s);
+  const db = await workshopDb(s);
+  const isPost = req.method === 'POST';
+  const b: Body = (isPost ? req.body : req.query) ?? {};
+  const ref = String(b.o ?? '');
+  const t = ref ? await readTable(db, ref) : null;
+  const schemas = (await usableSchemas(db)).filter((n) => !SYSTEM_SCHEMAS.includes(n));
+  if (!t || !schemas.includes(t.schema)) return reply.code(404).send('Not found');
+  const table = `${ident(t.schema)}.${ident(t.name)}`;
+  const self = `${BASE}/sql/objects/vector?${new URLSearchParams({ o: table })}`;
+  const oid = (await db.one<{ oid: number }>('select $1::regclass::oid as oid', [table]))!.oid;
+  const st = await pgvectorStatus(db);
+  const cols = await columnsOf(db, oid);
+  const texty = cols.filter((c) => c.texty);
+  const key = await keyOf(db, oid);
+  const choices = await providerChoices(s);
+  const triggers = st.installed ? await vectorTriggers(db, table) : [];
+
+  // Backfill: queue the rows of a vector column that have no embedding (or all of them)
+  if (isPost && b.mode === 'backfill') {
+    const trg = triggers.find((x) => x.vectorColumn === String(b.column ?? ''));
+    if (!trg || !(await appAllowed(s, trg.appId))) return reply.code(404).send('Not found');
+    const n = await backfill(db, trg, b.all === 'on');
+    kickEmbeddings();
+    flash(s, tx('vec.backfill_queued', { n: String(n), column: trg.vectorColumn }));
+    return back(reply, s, self);
+  }
+
+  const pick = choices.find((c) => c.key === String(b.provider ?? '')) ?? (isPost ? undefined : choices[0]);
+  const column = isPost ? String(b.column ?? '').trim() : cols.some((c) => c.name === 'embedding') ? '' : 'embedding';
+  const base = t.name.replace(/[^a-z0-9_]+/gi, '_').toLowerCase().slice(0, 40);
+  const index = isPost ? String(b.index ?? '').trim() : `${base}_${column || 'embedding'}_idx`;
+  const distance: Distance = isDistance(b.distance) ? b.distance : 'cosine';
+  const mode: 'set' | 'queue' = pick?.p.type === 'function' && (isPost ? b.keep === 'set' : true) ? 'set' : 'queue';
+  const picked = new Set<string>();
+  if (isPost) texty.forEach((c, i) => b[`c.${i}.use`] === 'on' && b[`c.${i}.name`] === c.name && picked.add(c.name));
+  else texty.forEach((c) => picked.add(c.name));
+
+  const errors: string[] = [];
+  let ddl: string[] = [];
+  let output: Raw | '' = '';
+  if (isPost && st.installed) {
+    if (!pick) errors.push(tx('vec.pick_provider'));
+    if (!picked.size) errors.push(tx('fts.pick'));
+    if (!key) errors.push(tx('vec.no_key'));
+    for (const n of [column, index]) if (!NAME.test(n)) errors.push(tx('fts.bad_name', { name: n }));
+    if (NAME.test(column) && cols.some((c) => c.name === column)) errors.push(tx('fts.exists', { name: column }));
+    if (NAME.test(index) && (await db.one('select 1 as x from pg_class where relnamespace = $1::regnamespace and relname = $2', [ident(t.schema), index]))) errors.push(tx('fts.exists', { name: index }));
+    const trigger = `${column}_embed`.slice(0, 63);
+    if (!errors.length && pick && key) {
+      ddl = vectorDdl({ table, vectorType: `${ident(st.schema!)}.vector`, column, index, trigger, dims: pick.p.dimensions, distance, mode, appId: pick.appId, provider: pick.p.name, key, sources: [...picked] });
+    }
+    if (ddl.length && b.mode === 'worksheet') {
+      s.state.__SQLDRAFT = `${ddl.join(';\n\n')};`;
+      flash(s, tx('te.review'));
+      return back(reply, s, `${BASE}/sql/worksheet`);
+    }
+    if (ddl.length && b.mode === 'apply') {
+      const c = await db.pool.connect();
+      let failed = '';
+      let at = '';
+      try {
+        await c.query('begin');
+        for (const x of ddl) {
+          at = x;
+          await c.query(x);
+        }
+        await c.query('commit');
+      } catch (e) {
+        failed = (e as Error).message;
+        await c.query('rollback').catch(() => {});
+      } finally {
+        c.release(true);
+      }
+      await logActivity({ username: s.username, event: 'sql_command', ip: clientIp(req), detail: ddl.join(';\n').slice(0, 2000) });
+      clearCompletions();
+      if (!failed) {
+        await recordChanges({ workspaceId: currentWorkspace(s), author: s.username ?? '?', source: 'table', defaultSchema: t.schema, statements: [joinStatements(ddl)] });
+        // the rows there are now: queued at once (the server embeds them; a function provider too)
+        const trg = (await vectorTriggers(db, table)).find((x) => x.vectorColumn === column);
+        const n = trg ? await backfill(db, trg, true) : 0;
+        kickEmbeddings();
+        flash(s, tx('vec.added', { table, column, n: String(n) }));
+        return back(reply, s, self);
+      }
+      output = html`<div class="alert alert-error" role="alert"><p><strong>${tx('te.nothing_changed')}</strong>: ${tx('te.rolled_back')}</p><p>${failed}</p><pre class="source" data-code-view="sql" tabindex="0" aria-label="${tx('te.failed_stmt')}">${at}</pre></div>`;
+    }
+  }
+
+  // the table's vector columns now, with their progress
+  const existing: Raw[] = [];
+  for (const c of cols.filter((x) => x.vector)) {
+    const trg = triggers.find((x) => x.vectorColumn === c.name);
+    const counts = (await db.one<{ total: number; done: number }>(`select count(*)::int as total, count(${ident(c.name)})::int as done from ${table}`))!;
+    const q = await queueState(oid, c.name);
+    const pct = counts.total ? Math.round((counts.done / counts.total) * 100) : 100;
+    existing.push(html`<li class="vec-column"><p><code>${c.name}</code> <code>${c.type}</code>
+        ${trg ? html`· ${tx('vec.kept_by', { provider: trg.provider, columns: trg.sourceColumns.join(', ') })} (${trg.mode === 'set' ? tx('vec.mode_set') : tx('vec.mode_queue')})` : html`· <span class="muted">${tx('vec.not_kept')}</span>`}</p>
+      <p><progress max="100" value="${pct}" aria-label="${tx('vec.progress', { column: c.name })}">${pct}%</progress>
+        ${tx('vec.counts', { done: String(counts.done), total: String(counts.total), queued: String(q.queued) })}${q.failing ? html` · <span class="tag tag-error">${tx('vec.failing', { n: String(q.failing) })}</span>` : ''}</p>
+      ${q.message ? html`<p class="muted">${q.message}</p>` : ''}
+      ${trg ? html`<form method="post" action="${BASE}/sql/objects/vector" class="buttons">${csrf(s)}<input type="hidden" name="o" value="${table}"><input type="hidden" name="column" value="${c.name}">
+        <label class="check"><input type="checkbox" name="all"> ${tx('vec.reembed_all')}</label>
+        <button class="btn" name="mode" value="backfill">${icon('refresh')} ${tx('vec.backfill')}</button>
+        <a class="btn" href="${self}">${tx('vec.refresh')}</a></form>` : ''}</li>`);
+  }
+
+  const title = tx('vec.title', { table });
+  const sel = (a: string, v: string) => (a === v ? ' selected' : '');
+  const admin = await isAdmin(s.username);
+  const form = !st.installed
+    ? html`<div class="alert alert-info" role="status"><p>${tx('vec.missing')}</p>${st.available ? html`<p>${tx(admin && st.canCreate ? 'vec.missing_create' : 'vec.missing_admin', { version: st.availableVersion ?? '' })}</p>` : html`<p>${tx('vec.missing_package')}</p>`}
+        <p><a class="btn" href="${BASE}/vector-providers">${icon('search')} ${tx('vec.utilities')}</a></p></div>`
+    : !choices.length
+      ? html`<p class="alert alert-info">${tx('vec.no_providers')}</p>`
+      : !texty.length
+        ? html`<p class="alert alert-info">${tx('fts.no_text')}</p>`
+        : html`<form method="post" action="${BASE}/sql/objects/vector" class="fts-form">${csrf(s)}
+      <input type="hidden" name="o" value="${table}">
+      <div class="form-grid">
+        <div class="field"><label class="label" for="vec-provider">${tx('vec.provider')}</label><select id="vec-provider" name="provider">${choices.map((c) => html`<option value="${c.key}"${sel(c.key, pick?.key ?? '')}>${c.alias} · ${c.p.name} (${c.p.type === 'ai_service' ? c.p.model : c.p.function}, ${c.p.dimensions})</option>`)}</select>
+          <small class="help">${tx('vec.provider_help')}</small></div>
+        <div class="field"><label class="label" for="vec-keep">${tx('vec.keep')}</label><select id="vec-keep" name="keep"><option value="set"${sel(mode, 'set')}>${tx('vec.mode_set')}</option><option value="queue"${sel(mode, 'queue')}>${tx('vec.mode_queue')}</option></select>
+          <small class="help">${tx('vec.keep_help')}</small></div>
+      </div>
+      <fieldset class="prop-group"><legend>${tx('vec.sources')}</legend>
+        <div class="table-wrap"><table class="report"><thead><tr><th>${tx('fts.include')}</th><th>${tx('te.name')}</th><th>${tx('te.type')}</th></tr></thead><tbody>
+        ${texty.map((c, i) => html`<tr><td class="te-c"><input type="hidden" name="c.${i}.name" value="${c.name}"><input type="checkbox" id="vec-c${i}" name="c.${i}.use"${picked.has(c.name) ? ' checked' : ''}></td>
+          <td><label for="vec-c${i}">${c.name}</label></td><td><code>${c.type}</code></td></tr>`)}
+        </tbody></table></div>
+        <small class="help">${tx('vec.sources_help')}</small></fieldset>
+      <div class="form-grid u-mt1">
+        <div class="field"><label class="label" for="vec-distance">${tx('vec.distance')}</label><select id="vec-distance" name="distance">${(Object.keys(DISTANCES) as Distance[]).map((d) => html`<option${sel(d, distance)}>${d}</option>`)}</select><small class="help">${tx('vec.distance_help')}</small></div>
+        <div class="field"><label class="label" for="vec-column">${tx('vec.column')}</label><input id="vec-column" name="column" value="${column}" required autocomplete="off" spellcheck="false" class="code"></div>
+        <div class="field"><label class="label" for="vec-index">${tx('fts.index')}</label><input id="vec-index" name="index" value="${index}" required autocomplete="off" spellcheck="false" class="code"></div>
+      </div>
+      ${key ? '' : html`<p class="alert alert-error" role="alert">${tx('vec.no_key')}</p>`}
+      ${ddl.length ? html`<h2>DDL</h2><pre class="source te-ddl" data-code-view="sql" tabindex="0" aria-label="DDL">${ddl.map((x) => `${x};`).join('\n\n')}</pre>` : ''}
+      <div class="buttons te-buttons">
+        <button class="btn" name="mode" value="preview">${icon('eye')} ${tx('te.preview')}</button>
+        <button class="btn btn-hot" name="mode" value="apply">${icon('check')} ${tx('te.apply')}</button>
+        <button class="btn" name="mode" value="worksheet">${icon('code')} ${tx('te.open_ws')}</button>
+        <a class="btn" href="${BASE}/sql/objects/table?${new URLSearchParams({ o: table })}">${tx('common.cancel')}</a>
+      </div></form>`;
+  const main = html`<h1 class="u-mb1">${title}</h1>${workshopTabs('objects', s)}
+    <p class="muted">${tx('vec.intro')}</p>
+    ${existing.length ? html`<h2>${tx('vec.existing')}</h2><ul class="vec-columns">${existing}</ul>` : ''}
+    ${errors.length ? html`<div class="alert alert-error" role="alert"><ul>${errors.map((e) => html`<li>${e}</li>`)}</ul></div>` : ''}
+    ${output}
+    <h2>${tx('vec.add')}</h2>
+    ${form}`;
+  return send(reply, s, shell(s, title, [['SQL Workshop', `${BASE}/sql`], [tx('ob.title'), `${BASE}/sql/objects`], [tx('te.title_table', { table }), `${BASE}/sql/objects/table?${new URLSearchParams({ o: table })}`], [tx('vec.add')]], main, 'sql'));
+}
+
+export async function vectorColumnRoutes(app: FastifyInstance) {
+  app.get(`${BASE}/sql/objects/vector`, page);
+  app.post(`${BASE}/sql/objects/vector`, page);
+}