pgkiln 0.67.0 → 0.69.0

package/src/builder/fulltext.ts

@@ -0,0 +1,160 @@
+import type { FastifyInstance, FastifyReply } from 'fastify';
+import pg from 'pg';
+import { html, type Raw } from '../html.ts';
+import { icon } from '../icons.ts';
+import { clientIp, logActivity } from '../session.ts';
+import { joinStatements, recordChanges } from '../changelog.ts';
+import { readTable } from '../tabledef.ts';
+import { tsConfigFor } from '../runtime/search.ts';
+import { builderLanguage, tr } from './i18n.ts';
+import { SYSTEM_SCHEMAS } from './object-browser.ts';
+import { clearCompletions } from './code-editor.ts';
+import { back, BASE, csrf, developer, flash, send, shell, workshopTabs, type Body, type Req } from './ui.ts';
+import { currentWorkspace, usableSchemas, workshopDb } from './workspaces.ts';
+
+// (sprint 135, AP-2) SQL Workshop › Table Properties › Add full-text search: a stored generated tsvector column over
+// the text columns the developer picks (each with a weight A–D) in a text search configuration from pg_ts_config,
+// and a GIN index on it. 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 table, its columns and
+// the configuration are read from the catalog on every request; only names found there reach the DDL (quoted).
+
+type Db = Awaited<ReturnType<typeof workshopDb>>;
+const NAME = /^[a-z_][a-z0-9_]{0,62}$/;
+const WEIGHTS = ['A', 'B', 'C', 'D'] as const;
+const ident = (n: string) => (/^[a-z_][a-z0-9_$]*$/.test(n) ? n : pg.escapeIdentifier(n));
+
+interface Col { name: string; type: string; texty: boolean; tsv: boolean; gin: 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, a.atttypid = 'tsvector'::regtype as tsv,
+            exists (select from pg_index i join pg_class ic on ic.oid = i.indexrelid join pg_am am on am.oid = ic.relam
+                     where i.indrelid = a.attrelid and am.amname = 'gin' and a.attnum = any (i.indkey::int2[])) as gin
+       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 text search configurations the connection sees by name (english, dutch, simple…). */
+async function tsConfigs(db: Db) {
+  return (await db.query<{ n: string }>(`select cfgname as n from pg_ts_config where pg_ts_config_is_visible(oid) order by 1`)).rows.map((r) => r.n);
+}
+
+/** The statements: the generated column and its GIN index. */
+export function fulltextDdl(table: string, column: string, index: string, config: string, cols: { name: string; weight: string }[]) {
+  const cfg = `${pg.escapeLiteral(config)}::regconfig`;
+  const parts = cols.map((c) => `setweight(to_tsvector(${cfg}, coalesce(${ident(c.name)}::text, '')), '${c.weight}')`);
+  return [
+    `alter table ${table}\n  add column ${ident(column)} tsvector generated always as (\n    ${parts.join(' ||\n    ')}) stored`,
+    `create index ${ident(index)} on ${table} using gin (${ident(column)})`,
+  ];
+}
+
+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 oid = (await db.one<{ oid: number }>('select $1::regclass::oid as oid', [table]))!.oid;
+  const cols = await columnsOf(db, oid);
+  const texty = cols.filter((c) => c.texty);
+  const configs = await tsConfigs(db);
+  const defaultConfig = configs.includes(tsConfigFor(builderLanguage(s))) ? tsConfigFor(builderLanguage(s)) : configs.includes('simple') ? 'simple' : configs[0] ?? 'simple';
+  // the form's values (defaults: every text column, A for the first, B for the rest)
+  const picked = new Map<string, string>();
+  const column = isPost ? String(b.column ?? '').trim() : 'search_vector';
+  const index = isPost ? String(b.index ?? '').trim() : `${t.name.replace(/[^a-z0-9_]+/gi, '_').toLowerCase().slice(0, 40)}_search_vector_idx`;
+  const config = isPost ? String(b.config ?? '') : defaultConfig;
+  if (isPost) {
+    for (const c of texty) {
+      const i = texty.indexOf(c);
+      if (b[`c.${i}.use`] === 'on' && b[`c.${i}.name`] === c.name) picked.set(c.name, WEIGHTS.find((w) => w === b[`c.${i}.w`]) ?? 'B');
+    }
+  } else texty.forEach((c, i) => picked.set(c.name, i === 0 ? 'A' : 'B'));
+
+  const errors: string[] = [];
+  let ddl: string[] = [];
+  let output: Raw | '' = '';
+  if (isPost) {
+    if (!picked.size) errors.push(tx('fts.pick'));
+    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 }));
+    if (!configs.includes(config)) errors.push(tx('fts.bad_config', { name: config }));
+    if (!errors.length) ddl = fulltextDdl(table, column, index, config, [...picked].map(([name, weight]) => ({ name, weight })));
+    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)] });
+        flash(s, tx('fts.added', { table, column, index }));
+        return back(reply, s, `${BASE}/sql/objects/table?${new URLSearchParams({ o: table })}`);
+      }
+      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>`;
+    }
+  }
+
+  const title = tx('fts.title', { table });
+  const existing = cols.filter((c) => c.tsv);
+  const sel = (a: string, v: string) => (a === v ? ' selected' : '');
+  const main = html`<h1 class="u-mb1">${title}</h1>${workshopTabs('objects', s)}
+    <p class="muted">${tx('fts.intro')}</p>
+    ${existing.length ? html`<p>${tx('fts.existing')} ${existing.map((c) => html`<code>${c.name}</code> (${c.gin ? tx('fts.gin_yes') : tx('fts.gin_no')}) `)}</p>` : ''}
+    ${errors.length ? html`<div class="alert alert-error" role="alert"><ul>${errors.map((e) => html`<li>${e}</li>`)}</ul></div>` : ''}
+    ${output}
+    ${texty.length ? html`<form method="post" action="${BASE}/sql/objects/fulltext" class="fts-form">${csrf(s)}
+      <input type="hidden" name="o" value="${table}">
+      <fieldset class="prop-group"><legend>${tx('fts.columns')}</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><th>${tx('fts.weight')}</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="fts-c${i}" name="c.${i}.use"${picked.has(c.name) ? ' checked' : ''}></td>
+          <td><label for="fts-c${i}">${c.name}</label></td><td><code>${c.type}</code></td>
+          <td><select name="c.${i}.w" aria-label="${tx('fts.weight')} ${c.name}">${WEIGHTS.map((w) => html`<option${sel(w, picked.get(c.name) ?? 'B')}>${w}</option>`)}</select></td></tr>`)}
+        </tbody></table></div>
+        <small class="help">${tx('fts.weight_help')}</small></fieldset>
+      <div class="form-grid u-mt1">
+        <div class="field"><label class="label" for="fts-config">${tx('fts.config')}</label><select id="fts-config" name="config">${configs.map((n) => html`<option${sel(n, config)}>${n}</option>`)}</select><small class="help">${tx('fts.config_help')}</small></div>
+        <div class="field"><label class="label" for="fts-column">${tx('fts.column')}</label><input id="fts-column" name="column" value="${column}" required autocomplete="off" spellcheck="false" class="code"></div>
+        <div class="field"><label class="label" for="fts-index">${tx('fts.index')}</label><input id="fts-index" name="index" value="${index}" required autocomplete="off" spellcheck="false" class="code"></div>
+      </div>
+      ${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>` : html`<p class="alert alert-info">${tx('fts.no_text')}</p>`}`;
+  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('fts.add')]], main, 'sql'));
+}
+
+export async function fulltextRoutes(app: FastifyInstance) {
+  app.get(`${BASE}/sql/objects/fulltext`, page);
+  app.post(`${BASE}/sql/objects/fulltext`, page);
+}

package/src/builder/i18n/de.ts

@@ -1045,6 +1045,26 @@ export const de: BuilderMessages = {
   'te.failed_stmt': 'Fehlgeschlagene Anweisung',
   'te.title_table': 'Tabelle {table}',
   'te.title_create': 'Tabelle erstellen',
+  'fts.add': "Volltextsuche hinzufügen",
+  'fts.title': "Volltextsuche für {table}",
+  'fts.intro': "Fügt eine gespeicherte generierte tsvector-Spalte über die gewählten Textspalten hinzu, mit einem GIN-Index darauf. Eine Suchkonfiguration vom Suchtyp fulltext (Gemeinsame Komponenten › Suchkonfigurationen) oder die Suche eines Berichts findet dann Wortformen (\"running\" findet \"run\") schnell. Die Spalte aktualisiert sich selbst; das Hinzufügen schreibt die Tabelle neu.",
+  'fts.columns': "Textspalten",
+  'fts.include': "Einbeziehen",
+  'fts.weight': "Gewichtung",
+  'fts.weight_help': "A zählt in der Rangfolge am meisten, D am wenigsten: z. B. A für einen Titel, B für eine Beschreibung.",
+  'fts.config': "Textsuchkonfiguration",
+  'fts.config_help': "Die Sprache, deren Wortstämme verwendet werden (german: Läufer → läuf); simple: keine Stammformen. Mit derselben Konfiguration suchen.",
+  'fts.column': "tsvector-Spalte",
+  'fts.index': "Indexname",
+  'fts.no_text': "Diese Tabelle hat keine Textspalten zum Durchsuchen.",
+  'fts.pick': "Wählen Sie mindestens eine Textspalte.",
+  'fts.bad_name': "\"{name}\" ist kein gültiger Name: Kleinbuchstaben, Ziffern und _.",
+  'fts.exists': "{name} existiert bereits.",
+  'fts.bad_config': "{name} ist keine Textsuchkonfiguration.",
+  'fts.existing': "Vorhandene tsvector-Spalten:",
+  'fts.gin_yes': "GIN-Index",
+  'fts.gin_no': "kein GIN-Index",
+  'fts.added': "Volltextsuche zu {table} hinzugefügt: Spalte {column} mit Index {index}.",
   // ------------------------------------------------------------ Shared Components (sprint 124)
   'comp.nav_entry': 'Navigationseintrag',
   'comp.nav_entry.plural': 'Navigationsmenü',

package/src/builder/i18n/en.ts

@@ -1,6 +1,6 @@
 // The builder's own texts in English (sprint 121, WS-7): the keys of every builder message file (i18n.ts).
 // A key is <screen>.<what>; {name} is a placeholder (filled by tx(key, { name })). Keep the other languages
-// (de, es, fr, nl, pt) in step: TypeScript and test/builder-i18n.test.ts refuse a missing or an extra key.
+// (de, es, fr, it, nl, pt, zh-cn, zh-tw, ja, ko) in step: TypeScript and test/builder-i18n.test.ts refuse a missing or an extra key.
 // Keys made at run time (gallery.*, pos.*, slot.*, comp.*, pd.new.* …, sql.tool.*, sql.group.*) are listed here
 // too; the test checks that every region type, item type, button action, position, slot and SQL Workshop tool has one.
 
@@ -1048,6 +1048,27 @@ export const en = {
   'te.failed_stmt': 'Failed statement',
   'te.title_table': 'Table {table}',
   'te.title_create': 'Create table',
+  // (sprint 135, AP-2) Table Properties › Add full-text search
+  'fts.add': "Add full-text search",
+  'fts.title': "Full-text search on {table}",
+  'fts.intro': "Adds a stored generated tsvector column over the text columns you choose, and a GIN index on it. A search configuration of search type fulltext (Shared Components › Search configurations) or a report search then finds stemmed words (\"running\" finds \"run\") fast. The column keeps itself up to date; adding it rewrites the table.",
+  'fts.columns': "Text columns",
+  'fts.include': "Include",
+  'fts.weight': "Weight",
+  'fts.weight_help': "A counts most in the ranking, D least: e.g. A for a title, B for a description.",
+  'fts.config': "Text search configuration",
+  'fts.config_help': "The language whose stemming is used (english: running → run); simple: no stemming. Search with the same configuration.",
+  'fts.column': "tsvector column",
+  'fts.index': "Index name",
+  'fts.no_text': "This table has no text columns to search.",
+  'fts.pick': "Choose at least one text column.",
+  'fts.bad_name': "\"{name}\" is not a valid name: lowercase letters, digits and _.",
+  'fts.exists': "{name} already exists.",
+  'fts.bad_config': "{name} is not a text search configuration.",
+  'fts.existing': "tsvector columns now:",
+  'fts.gin_yes': "GIN index",
+  'fts.gin_no': "no GIN index",
+  'fts.added': "Added full-text search to {table}: column {column} with index {index}.",
   // ------------------------------------------------------------ Shared Components (sprint 124)
   'comp.nav_entry': 'Navigation entry',
   'comp.nav_entry.plural': 'Navigation menu',

package/src/builder/i18n/es.ts

@@ -1045,6 +1045,26 @@ export const es: BuilderMessages = {
   'te.failed_stmt': 'Sentencia con error',
   'te.title_table': 'Tabla {table}',
   'te.title_create': 'Crear tabla',
+  'fts.add': "Añadir búsqueda de texto completo",
+  'fts.title': "Búsqueda de texto completo en {table}",
+  'fts.intro': "Añade una columna tsvector generada y almacenada sobre las columnas de texto que elija, con un índice GIN. Una configuración de búsqueda de tipo fulltext (Componentes compartidos › Configuraciones de búsqueda) o la búsqueda de un informe encuentra entonces rápidamente las formas de las palabras (\"running\" encuentra \"run\"). La columna se mantiene al día; añadirla reescribe la tabla.",
+  'fts.columns': "Columnas de texto",
+  'fts.include': "Incluir",
+  'fts.weight': "Peso",
+  'fts.weight_help': "A cuenta más en la clasificación, D menos: p. ej. A para un título, B para una descripción.",
+  'fts.config': "Configuración de búsqueda de texto",
+  'fts.config_help': "El idioma cuya lematización se usa (spanish: corriendo → corr); simple: sin lematización. Busque con la misma configuración.",
+  'fts.column': "Columna tsvector",
+  'fts.index': "Nombre del índice",
+  'fts.no_text': "Esta tabla no tiene columnas de texto en las que buscar.",
+  'fts.pick': "Elija al menos una columna de texto.",
+  'fts.bad_name': "\"{name}\" no es un nombre válido: minúsculas, dígitos y _.",
+  'fts.exists': "{name} ya existe.",
+  'fts.bad_config': "{name} no es una configuración de búsqueda de texto.",
+  'fts.existing': "Columnas tsvector actuales:",
+  'fts.gin_yes': "índice GIN",
+  'fts.gin_no': "sin índice GIN",
+  'fts.added': "Búsqueda de texto completo añadida a {table}: columna {column} con el índice {index}.",
   // ------------------------------------------------------------ Shared Components (sprint 124)
   'comp.nav_entry': 'Entrada de navegación',
   'comp.nav_entry.plural': 'Menú de navegación',

package/src/builder/i18n/fr.ts

@@ -1045,6 +1045,26 @@ export const fr: BuilderMessages = {
   'te.failed_stmt': 'Instruction en échec',
   'te.title_table': 'Table {table}',
   'te.title_create': 'Créer une table',
+  'fts.add': "Ajouter la recherche plein texte",
+  'fts.title': "Recherche plein texte sur {table}",
+  'fts.intro': "Ajoute une colonne tsvector générée et stockée sur les colonnes de texte choisies, avec un index GIN. Une configuration de recherche de type fulltext (Composants partagés › Configurations de recherche) ou la recherche d'un rapport trouve alors rapidement les formes des mots (\"running\" trouve \"run\"). La colonne se tient à jour ; l'ajouter réécrit la table.",
+  'fts.columns': "Colonnes de texte",
+  'fts.include': "Inclure",
+  'fts.weight': "Poids",
+  'fts.weight_help': "A compte le plus dans le classement, D le moins : par ex. A pour un titre, B pour une description.",
+  'fts.config': "Configuration de recherche de texte",
+  'fts.config_help': "La langue dont la racinisation est utilisée (french : courir → cour) ; simple : sans racinisation. Recherchez avec la même configuration.",
+  'fts.column': "Colonne tsvector",
+  'fts.index': "Nom de l'index",
+  'fts.no_text': "Cette table n'a pas de colonnes de texte à rechercher.",
+  'fts.pick': "Choisissez au moins une colonne de texte.",
+  'fts.bad_name': "« {name} » n'est pas un nom valide : minuscules, chiffres et _.",
+  'fts.exists': "{name} existe déjà.",
+  'fts.bad_config': "{name} n'est pas une configuration de recherche de texte.",
+  'fts.existing': "Colonnes tsvector actuelles :",
+  'fts.gin_yes': "index GIN",
+  'fts.gin_no': "pas d'index GIN",
+  'fts.added': "Recherche plein texte ajoutée à {table} : colonne {column} avec l'index {index}.",
   // ------------------------------------------------------------ Shared Components (sprint 124)
   'comp.nav_entry': 'Entrée de navigation',
   'comp.nav_entry.plural': 'Menu de navigation',