@gscdump/engine 0.6.1 → 0.6.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (40) hide show
  1. package/dist/_chunks/compiler.mjs +288 -0
  2. package/dist/_chunks/duckdb.d.mts +26 -0
  3. package/dist/_chunks/engine.mjs +578 -0
  4. package/dist/_chunks/pg-adapter.mjs +676 -0
  5. package/dist/_chunks/planner.d.mts +15 -0
  6. package/dist/_chunks/schema.d.mts +1258 -0
  7. package/dist/_chunks/schema.mjs +139 -0
  8. package/dist/_chunks/storage.d.mts +476 -0
  9. package/dist/_chunks/storage.mjs +39 -0
  10. package/dist/_chunks/types.d.mts +53 -0
  11. package/dist/adapters/duckdb-node.d.mts +1 -13
  12. package/dist/adapters/duckdb-node.mjs +1 -7
  13. package/dist/adapters/filesystem.d.mts +1 -193
  14. package/dist/adapters/filesystem.mjs +2 -9
  15. package/dist/adapters/http.d.mts +1 -193
  16. package/dist/adapters/http.mjs +1 -5
  17. package/dist/adapters/hyparquet.d.mts +6 -83
  18. package/dist/adapters/hyparquet.mjs +1 -105
  19. package/dist/adapters/inspection-sqlite-browser.d.mts +1 -7
  20. package/dist/adapters/inspection-sqlite-node.d.mts +1 -7
  21. package/dist/adapters/inspection-sqlite-node.mjs +1 -1
  22. package/dist/adapters/node-harness.d.mts +3 -306
  23. package/dist/adapters/node-harness.mjs +4 -1866
  24. package/dist/adapters/r2-manifest.d.mts +4 -149
  25. package/dist/adapters/r2-manifest.mjs +1 -8
  26. package/dist/adapters/r2.d.mts +1 -47
  27. package/dist/contracts.d.mts +1 -435
  28. package/dist/entities.d.mts +1 -47
  29. package/dist/index.d.mts +8 -1844
  30. package/dist/index.mjs +8 -1962
  31. package/dist/ingest.d.mts +1 -1
  32. package/dist/planner.d.mts +3 -16
  33. package/dist/planner.mjs +1 -320
  34. package/dist/resolver/index.d.mts +3 -51
  35. package/dist/resolver/index.mjs +2 -780
  36. package/dist/rollups.d.mts +6 -51
  37. package/dist/rollups.mjs +2 -209
  38. package/dist/schema.d.mts +2 -1258
  39. package/dist/schema.mjs +1 -138
  40. package/package.json +2 -2
package/dist/index.d.mts CHANGED
@@ -1,1849 +1,13 @@
1
- import * as _$drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
2
- import { ColumnDef, ColumnType, Row, Row as Row$1, TableName, TableName as TableName$1, TableSchema, TableSchema as TableSchema$1, TenantCtx, TenantCtx as TenantCtx$1 } from "gscdump/contracts";
3
- import { BuilderState, SearchType, SearchType as SearchType$1 } from "gscdump/query";
1
+ import { A as SyncStateFilter, B as dayPartition, C as QueryResult, D as StorageEngine, E as SearchType, F as Watermark, G as objectKey, H as inferSearchType, I as WatermarkFilter, J as weekPartition, K as quarterOfMonth, L as WatermarkScope, M as SyncStateScope, N as TableName, O as SyncState, P as TenantCtx, R as WriteCtx, S as QueryExecutor, T as RunSQLOptions, U as mondayOfWeek, V as inferLegacyTier, W as monthPartition, X as enumeratePartitions, Y as CompactionThresholds, _ as PurgeResult, a as DataSource, b as QueryExecuteOptions, c as FileSetRef, d as LockScope, f as ManifestEntry, g as PurgeFilter, h as ParquetCodec, i as DEFAULT_SEARCH_TYPE, j as SyncStateKind, k as SyncStateDetail, l as GcCtx, m as ManifestStore, n as CompactionTier, o as EngineOptions, p as ManifestPurgeResult, q as quarterPartition, r as ComparisonResult, s as ExtraResult, t as CodecCtx, u as ListLiveFilter, v as PurgeUrlsResult, w as Row, x as QueryExecuteResult, y as QueryCtx, z as WriteResult } from "./_chunks/storage.mjs";
2
+ import { a as createDuckDBExecutor, i as createDuckDBCodec, n as DuckDBHandle, r as canonicalEmptyParquetSchema, t as DuckDBFactory } from "./_chunks/duckdb.mjs";
3
+ import { _ as pages, a as allTables, c as inferTable, d as TABLE_METADATA, f as countries, g as page_keywords, h as keywords, i as TableSchema, m as drizzleSchema, n as ColumnType, o as currentSchemaVersion, p as devices, r as SCHEMAS, s as dimensionToColumn, t as ColumnDef, u as DrizzleSchema } from "./_chunks/schema.mjs";
4
+ import { CreateInspectionStoreSqliteOptions, InspectionSqlDriver, createInspectionStoreSqlite, inspectionSqliteKey } from "./entities.mjs";
5
+ import { GscApiRow, IngestOptions, RowAccumulator, RowAccumulatorOptions, createRowAccumulator, toPath, toSumPosition, transformGscRow } from "./ingest.mjs";
6
+ import { a as substituteNamedFiles, i as resolveToSQL, n as ResolvedQuery, t as FILES_PLACEHOLDER } from "./_chunks/planner.mjs";
7
+ import { bindLiterals, formatLiteral } from "./sql-bind.mjs";
8
+ import { Row as Row$1 } from "gscdump/contracts";
4
9
  declare function coerceRow(row: Row$1): Row$1;
5
10
  declare function coerceRows(rows: readonly Row$1[]): Row$1[];
6
- type ComparisonFilter = 'new' | 'lost' | 'improving' | 'declining';
7
- /**
8
- * Default `searchType` for entries written before the field landed and for
9
- * sync paths that don't request a specific type. GSC's own default; the
10
- * vast majority of stored data is web-search.
11
- */
12
- declare const DEFAULT_SEARCH_TYPE: SearchType$1;
13
- interface WriteCtx extends TenantCtx$1 {
14
- table: TableName$1;
15
- date?: string;
16
- now?: () => number;
17
- /**
18
- * GSC search-type partition this write belongs to. Defaults to `'web'`.
19
- * Non-web values (`discover`, `news`, `googleNews`, `image`, `video`)
20
- * cause the writer to insert the type into the object key path so files
21
- * for different search types coexist without colliding.
22
- */
23
- searchType?: SearchType$1;
24
- }
25
- interface QueryCtx extends TenantCtx$1 {
26
- table?: TableName$1;
27
- signal?: AbortSignal;
28
- }
29
- interface GcCtx {
30
- now?: () => number;
31
- userId?: string;
32
- siteId?: string;
33
- }
34
- /**
35
- * Compaction tier of a manifest entry. Determines which compactor stage may
36
- * pick it up as input:
37
- * - `raw`: per-day file produced by `writeDay`. Eligible for raw→d7 merge at 7d.
38
- * - `d7`: weekly compaction output. Eligible for d7→d30 merge at 30d.
39
- * - `d30`: monthly compaction output (matches the legacy `monthly/` partition
40
- * shape — pre-tier entries are read as `d30`). Eligible for d30→d90 at 90d.
41
- * - `d90`: quarterly cold-tier output. Terminal; never recompacted.
42
- *
43
- * Without an explicit tier, entries written before this field landed default
44
- * to `raw` for `daily/` partitions and `d30` for `monthly/` partitions, so
45
- * the tiered compactor picks the right inputs without a backfill rewrite.
46
- */
47
- type CompactionTier = 'raw' | 'd7' | 'd30' | 'd90';
48
- interface ManifestEntry {
49
- userId: string;
50
- siteId?: string;
51
- table: TableName$1;
52
- partition: string;
53
- objectKey: string;
54
- rowCount: number;
55
- bytes: number;
56
- createdAt: number;
57
- retiredAt?: number;
58
- /** Table schema version at write time. Omitted on pre-#27 entries — treat as 1. */
59
- schemaVersion?: number;
60
- /**
61
- * Compaction tier. Omitted on entries written before tiered compaction —
62
- * treat as `raw` for `daily/` partitions and `d30` for `monthly/` partitions
63
- * (see {@link inferLegacyTier}).
64
- */
65
- tier?: CompactionTier;
66
- /**
67
- * GSC search-type this entry covers (web | discover | news | googleNews |
68
- * image | video). Omitted on entries written before per-type partitioning
69
- * landed — treat as `web` (see {@link inferSearchType}). Compaction merges
70
- * only entries with the same searchType.
71
- */
72
- searchType?: SearchType$1;
73
- }
74
- /**
75
- * Resolve the search type for an entry, defaulting legacy entries to `web`.
76
- * Use this anywhere code needs to bucket entries by searchType.
77
- */
78
- declare function inferSearchType(entry: Pick<ManifestEntry, 'searchType'>): SearchType$1;
79
- /**
80
- * Infer the tier for an entry that pre-dates the `tier` field. Daily files
81
- * are `raw`; monthly files are `d30`. Anything else (already migrated, or
82
- * a partition shape we haven't seen) returns undefined and the caller must
83
- * decide how to handle it.
84
- */
85
- declare function inferLegacyTier(entry: Pick<ManifestEntry, 'partition' | 'tier'>): CompactionTier | undefined;
86
- interface ListLiveFilter {
87
- userId: string;
88
- siteId?: string;
89
- table?: TableName$1;
90
- partitions?: string[];
91
- /**
92
- * Narrow to a single compaction tier. Tier-aware compaction stages set this
93
- * so the store doesn't have to return (and the caller doesn't have to scan)
94
- * the entire manifest just to compact the raw cohort. Legacy entries without
95
- * an explicit `tier` field match on {@link inferLegacyTier}.
96
- */
97
- tier?: CompactionTier;
98
- }
99
- interface DataSource {
100
- read: (key: string, range?: {
101
- offset: number;
102
- length: number;
103
- }, signal?: AbortSignal) => Promise<Uint8Array>;
104
- write: (key: string, bytes: Uint8Array) => Promise<void>;
105
- delete: (keys: string[]) => Promise<void>;
106
- /**
107
- * One-shot listing under a prefix. Implementations may cap the number of
108
- * returned keys (typically 10k) — callers iterating full tenant space
109
- * should prefer `streamList` when available or narrow the prefix.
110
- */
111
- list: (prefix: string) => Promise<string[]>;
112
- /**
113
- * Per-key URI probe. Returns a URI string DuckDB's `httpfs` (or an
114
- * equivalent engine that fetches its own I/O) can read directly, or
115
- * `undefined` if the key isn't URI-resolvable on this backend and the
116
- * caller must fall back to `read(key)` for the bytes.
117
- *
118
- * Contracts:
119
- * - When defined, the returned URI MUST yield byte-identical content to
120
- * `read(key)`. Callers rely on this for correctness.
121
- * - Backends with a native URI for every key (filesystem: absolute path,
122
- * R2 via `httpfs`: signed URL) may always return a string.
123
- * - Backends without a native URI shape (in-memory) omit the method or
124
- * return `undefined` per call.
125
- * - Mixed-per-query is allowed: some keys in one query may return a URI,
126
- * others may not; the executor branches per key.
127
- */
128
- uri?: (key: string) => string | undefined;
129
- /**
130
- * Optional — probe the byte size of a key without reading it. Used by
131
- * the engine to fill in `WriteResult.bytes` when a codec reports 0 or
132
- * unknown but the file is non-trivial.
133
- */
134
- head?: (key: string) => Promise<{
135
- bytes: number;
136
- } | undefined>;
137
- /**
138
- * Optional streaming variant of `list`. Implementations that page
139
- * backing-store results (R2, S3) should implement this and yield keys
140
- * lazily. `list` may return up to an adapter-defined cap (typically
141
- * 10k keys); callers iterating full tenant space must prefer
142
- * `streamList` when available, or chunk by narrower prefixes.
143
- */
144
- streamList?: (prefix: string) => AsyncIterable<string>;
145
- }
146
- interface WatermarkScope {
147
- userId: string;
148
- siteId?: string;
149
- table: TableName$1;
150
- }
151
- interface Watermark extends WatermarkScope {
152
- newestDateSynced: string;
153
- oldestDateSynced: string;
154
- lastSyncAt: number;
155
- }
156
- interface WatermarkFilter {
157
- userId: string;
158
- siteId?: string;
159
- table?: TableName$1;
160
- }
161
- type SyncStateKind = 'pending' | 'inflight' | 'done' | 'failed';
162
- interface SyncStateScope {
163
- userId: string;
164
- siteId?: string;
165
- table: TableName$1;
166
- date: string;
167
- /**
168
- * GSC search-type this sync state covers. Omitted = `web` (the legacy
169
- * default; matches pre-#5 sync states stored before per-type sync landed).
170
- * Lookups must compare via {@link inferSearchType} so a missing field
171
- * matches an explicit `'web'` and vice versa.
172
- */
173
- searchType?: SearchType$1;
174
- }
175
- interface SyncState extends SyncStateScope {
176
- state: SyncStateKind;
177
- updatedAt: number;
178
- attempts: number;
179
- error?: string;
180
- }
181
- interface SyncStateFilter {
182
- userId: string;
183
- siteId?: string;
184
- table?: TableName$1;
185
- state?: SyncStateKind;
186
- searchType?: SearchType$1;
187
- }
188
- interface SyncStateDetail {
189
- at?: number;
190
- error?: string;
191
- }
192
- interface LockScope {
193
- userId: string;
194
- siteId?: string;
195
- table: TableName$1;
196
- partition: string;
197
- }
198
- interface PurgeFilter {
199
- userId: string;
200
- siteId?: string;
201
- }
202
- interface ManifestPurgeResult {
203
- entriesRemoved: number;
204
- watermarksRemoved: number;
205
- syncStatesRemoved: number;
206
- }
207
- interface PurgeResult {
208
- userId: string;
209
- siteId?: string;
210
- prefix: string;
211
- objectsDeleted: number;
212
- entriesRemoved: number;
213
- watermarksRemoved: number;
214
- syncStatesRemoved: number;
215
- at: number;
216
- }
217
- interface PurgeUrlsResult {
218
- userId: string;
219
- siteId?: string;
220
- urlsRequested: number;
221
- entriesRewritten: number;
222
- rowsRemoved: number;
223
- bytesAfter: number;
224
- at: number;
225
- }
226
- interface ManifestStore {
227
- listLive: (filter: ListLiveFilter) => Promise<ManifestEntry[]>;
228
- listAll: (filter: ListLiveFilter) => Promise<ManifestEntry[]>;
229
- registerVersion: (entry: ManifestEntry, superseding?: ManifestEntry[]) => Promise<void>;
230
- registerVersions: (entries: ManifestEntry[], superseding?: ManifestEntry[]) => Promise<void>;
231
- listRetired: (olderThan: number) => Promise<ManifestEntry[]>;
232
- delete: (entries: ManifestEntry[]) => Promise<void>;
233
- getWatermarks: (filter: WatermarkFilter) => Promise<Watermark[]>;
234
- bumpWatermark: (scope: WatermarkScope, date: string, at?: number) => Promise<void>;
235
- getSyncStates: (filter: SyncStateFilter) => Promise<SyncState[]>;
236
- setSyncState: (scope: SyncStateScope, state: SyncStateKind, detail?: SyncStateDetail) => Promise<void>;
237
- /**
238
- * Serialize concurrent writers against the same scope. Held across the
239
- * write+register window so GC (orphan sweep) won't delete bytes that are
240
- * midway between `dataSource.write` and `manifestStore.registerVersion`.
241
- * Scope = tenant × table × partition.
242
- */
243
- withLock: <T>(scope: LockScope, fn: () => Promise<T>) => Promise<T>;
244
- /**
245
- * GDPR-grade tenant purge. Removes every manifest entry, watermark, and
246
- * sync-state record matching the filter. Does NOT touch the underlying
247
- * data-source bytes; callers (typically {@link StorageEngine.purgeTenant})
248
- * must sweep the tenant prefix separately before invoking this so that
249
- * mid-flight failures can't leave orphan parquet with no manifest record.
250
- *
251
- * On stores with CAS-backed sharding (R2 manifest) this may issue one
252
- * mutation per shard. On read-only stores (HTTP) this throws.
253
- */
254
- purgeTenant: (filter: PurgeFilter) => Promise<ManifestPurgeResult>;
255
- }
256
- interface WriteResult {
257
- bytes: number;
258
- rowCount: number;
259
- }
260
- interface CodecCtx {
261
- table: TableName$1;
262
- }
263
- /**
264
- * Key-oriented codec. Each method owns its I/O through `dataSource`:
265
- * - Node / browser codecs read/write bytes via `dataSource.read` / `.write`.
266
- * - Workers codecs let DuckDB's httpfs read/write remote URIs directly (via
267
- * `dataSource.uri`) and never materialise bytes in JS.
268
- *
269
- * The engine never touches bytes; it just hands rows + keys to the codec.
270
- *
271
- * Invariants every implementation MUST uphold:
272
- * - `writeRows` with an empty `rows` array MUST still write a file
273
- * carrying the canonical column set for `ctx.table` — a schema-correct
274
- * empty file. No placeholder-column shortcuts; readers depend on the
275
- * schema being present for `union_by_name` merges.
276
- * - `WriteResult.bytes` MUST be the real byte size written to the
277
- * data source (not 0, not an estimate) so the engine can enforce the
278
- * payload ceiling without a second `head` round-trip.
279
- * - `WriteResult.rowCount` MUST equal `rows.length` (or, for
280
- * `compactRows`, the sum of input row counts).
281
- */
282
- interface ParquetCodec {
283
- writeRows: (ctx: CodecCtx, rows: Row$1[], key: string, dataSource: DataSource) => Promise<WriteResult>;
284
- readRows: (ctx: CodecCtx, key: string, dataSource: DataSource) => Promise<Row$1[]>;
285
- compactRows: (ctx: CodecCtx, inputKeys: string[], outputKey: string, dataSource: DataSource) => Promise<WriteResult>;
286
- }
287
- interface QueryResult {
288
- rows: Row$1[];
289
- sql: string;
290
- objectKeys: string[];
291
- }
292
- interface ComparisonResult {
293
- rows: Row$1[];
294
- totalCount: number;
295
- totals: Record<string, unknown>;
296
- }
297
- interface ExtraResult {
298
- key: string;
299
- rows: Row$1[];
300
- }
301
- interface QueryExecuteOptions {
302
- sql: string;
303
- params: unknown[];
304
- /**
305
- * Named placeholder → object keys. The executor substitutes `{{NAME}}`
306
- * occurrences in the SQL with the matching `read_parquet([...])` list,
307
- * choosing between virtual-FS names or native URIs based on whether
308
- * `dataSource.uri` is available.
309
- */
310
- fileKeys: Record<string, string[]>;
311
- dataSource: DataSource;
312
- table: TableName$1;
313
- signal?: AbortSignal;
314
- /**
315
- * Optional callback invoked by the executor when it detects the DuckDB
316
- * process is approaching a memory ceiling (e.g. ingesting rows after
317
- * httpfs decode, or materialising a large temp relation). Callers can
318
- * shed work, warm a spillover path, or warn the user. Advisory only —
319
- * not all executors implement it.
320
- */
321
- onMemoryPressure?: (info: {
322
- bytes?: number;
323
- reason: string;
324
- }) => void;
325
- }
326
- interface QueryExecuteResult {
327
- rows: Row$1[];
328
- /** The final SQL actually run (after placeholder substitution). */
329
- sql: string;
330
- /**
331
- * Optional diagnostics the executor may emit for observability + capacity
332
- * planning. Undefined on executors that don't instrument their runtime.
333
- *
334
- * - `peakBytes`: highest resident memory the engine reported during the
335
- * query. Callers may use this to decide whether to drop / compact state
336
- * before the next call.
337
- * - `resetRecommended`: executor thinks the underlying connection should
338
- * be recycled (fragmented, near ceiling). Caller-owned decision —
339
- * honored by `BrowserAnalysisRuntime` consumers but not enforced.
340
- */
341
- diagnostics?: {
342
- peakBytes?: number;
343
- resetRecommended?: boolean;
344
- };
345
- }
346
- interface QueryExecutor {
347
- execute: (opts: QueryExecuteOptions) => Promise<QueryExecuteResult>;
348
- }
349
- interface FileSetRef {
350
- table: TableName$1;
351
- partitions?: string[];
352
- }
353
- interface RunSQLOptions {
354
- ctx: TenantCtx$1;
355
- /**
356
- * Named partition references. Each name becomes a `{{NAME}}` placeholder
357
- * substituted into the SQL with the matching list of object keys. The
358
- * canonical name is `FILES`; analyzers also use `FILES_PREV` for a prior
359
- * window. Providing zero fileSets runs the SQL against no files.
360
- */
361
- fileSets: Record<string, FileSetRef>;
362
- /** Schema-bearing table; defaults to the first fileSet's table. */
363
- table?: TableName$1;
364
- sql: string;
365
- params?: unknown[];
366
- signal?: AbortSignal;
367
- }
368
- interface StorageEngine {
369
- writeDay: (ctx: WriteCtx, rows: Row$1[]) => Promise<void>;
370
- query: (ctx: QueryCtx, state: BuilderState) => Promise<QueryResult>;
371
- /**
372
- * Two-window comparison query (resolver-compiled). Joins a `current` and
373
- * `previous` window CTE on dimensions, applies an optional row filter
374
- * (`new`/`lost`/`improving`/`declining`), and returns the merged rows plus
375
- * total count and unfiltered totals.
376
- *
377
- * Tenant scoping comes from `ctx.userId`/`ctx.siteId` (manifest lookup) —
378
- * the SQL itself is single-tenant against the parquet adapter, which has
379
- * `includeSiteId: false`.
380
- *
381
- * Throws if `current` and `previous` resolve to different tables.
382
- */
383
- queryComparison: (ctx: QueryCtx, current: BuilderState, previous: BuilderState, filter?: ComparisonFilter) => Promise<ComparisonResult>;
384
- /**
385
- * Canonical-variant enrichment queries. Returns one result per extra
386
- * surface; today only `queryCanonical` triggers an extra. Empty array
387
- * when the state has no extras-eligible dimensions.
388
- */
389
- queryExtras: (ctx: QueryCtx, state: BuilderState) => Promise<ExtraResult[]>;
390
- /**
391
- * Run arbitrary SQL resolved against named partition sets. Composes
392
- * manifest lookup + object reads + placeholder substitution + execution
393
- * so callers don't need to reach into `ManifestStore`/`DataSource`
394
- * directly.
395
- */
396
- runSQL: (opts: RunSQLOptions) => Promise<QueryResult>;
397
- compactTiered: (ctx: WriteCtx, thresholds?: CompactionThresholds) => Promise<void>;
398
- gcOrphans: (ctx: GcCtx, graceMs: number) => Promise<{
399
- deleted: number;
400
- }>;
401
- /**
402
- * GDPR-grade tenant purge. Deletes every object under the tenant prefix
403
- * (parquet, rollups, entity stores), then removes manifest/watermark/
404
- * sync-state records via {@link ManifestStore.purgeTenant}.
405
- *
406
- * Order matters: bytes are deleted before manifest entries, so a
407
- * crash mid-purge leaves orphan manifest records (detectable via the
408
- * normal orphan sweep) rather than orphan bytes with no record.
409
- *
410
- * Returns counters suitable for an audit log. Caller is responsible
411
- * for persisting the audit entry.
412
- */
413
- purgeTenant: (ctx: TenantCtx$1) => Promise<PurgeResult>;
414
- /**
415
- * GDPR URL-matcher purge. Deletes rows whose `url` column matches one of
416
- * `urls` across every live parquet entry for the tenant in tables that
417
- * carry a `url` column (`pages`, `page_keywords`). Tables without a `url`
418
- * column (`keywords`, `countries`, `devices`, `search_appearance`) are
419
- * untouched — they never store per-URL data.
420
- *
421
- * For each affected entry the engine reads the file, filters the matching
422
- * rows out, writes a replacement parquet at a new object key, and registers
423
- * the new entry as a supersede of the old. Entries with no matches are
424
- * left untouched. Entries with all rows matching are replaced by a
425
- * schema-bearing empty-rows file.
426
- *
427
- * Narrower counterpart to {@link purgeTenant}: use this for a per-URL
428
- * takedown request; use `purgeTenant` for full-account deletion.
429
- */
430
- purgeUrls: (ctx: TenantCtx$1, urls: readonly string[]) => Promise<PurgeUrlsResult>;
431
- listLive: (filter: ListLiveFilter) => Promise<ManifestEntry[]>;
432
- listAll: (filter: ListLiveFilter) => Promise<ManifestEntry[]>;
433
- getWatermarks: (filter: WatermarkFilter) => Promise<Watermark[]>;
434
- getSyncStates: (filter: SyncStateFilter) => Promise<SyncState[]>;
435
- setSyncState: (scope: SyncStateScope, state: SyncStateKind, detail?: SyncStateDetail) => Promise<void>;
436
- /** Read the raw bytes of a single object. Rarely needed outside the `dump` CLI. */
437
- readObject: (key: string) => Promise<Uint8Array>;
438
- }
439
- interface EngineOptions {
440
- dataSource: DataSource;
441
- manifestStore: ManifestStore;
442
- codec: ParquetCodec;
443
- executor: QueryExecutor;
444
- now?: () => number;
445
- }
446
- declare function dayPartition(date: string): string;
447
- declare function monthPartition(month: string): string;
448
- /**
449
- * Weekly partition keyed by the Monday-of-week ISO date (e.g. `weekly/2026-04-20`
450
- * for the ISO week containing 2026-04-22). Names are stable + sortable; the
451
- * dashboard never parses them, only reads via the manifest.
452
- */
453
- declare function weekPartition(mondayIsoDate: string): string;
454
- /**
455
- * Quarterly partition (e.g. `quarterly/2026-Q2` for Apr-Jun 2026). Used as the
456
- * cold-tier shape for `d90` compaction outputs.
457
- */
458
- declare function quarterPartition(quarter: string): string;
459
- /**
460
- * Monday-of-week as a YYYY-MM-DD string for the ISO week containing `isoDate`.
461
- * Used by tiered compaction to bucket raw daily files into weekly groups.
462
- */
463
- declare function mondayOfWeek(isoDate: string): string;
464
- /** YYYY-Qq for the quarter containing the given YYYY-MM month string. */
465
- declare function quarterOfMonth(month: string): string;
466
- declare function objectKey(ctx: TenantCtx$1, table: TableName$1, partition: string, version: number, searchType?: SearchType$1): string;
467
- /**
468
- * Per-tier age threshold in days. Default ladder collapses on these gates:
469
- * - raw → d7 once a daily file is older than `raw` days (default 7).
470
- * - d7 → d30 once the entire weekly bucket sits behind `d7` days (default 30).
471
- * - d30 → d90 once the entire monthly bucket sits behind `d30` days (default 90).
472
- */
473
- interface CompactionThresholds {
474
- raw?: number;
475
- d7?: number;
476
- d30?: number;
477
- }
478
- declare function enumeratePartitions(startDate: string, endDate: string): string[];
479
- interface DuckDBHandle {
480
- query: (sql: string, params?: unknown[]) => Promise<Row[]>;
481
- registerFileBuffer: (name: string, bytes: Uint8Array) => Promise<void>;
482
- copyFileToBuffer: (name: string) => Promise<Uint8Array>;
483
- dropFiles: (names: string[]) => Promise<void>;
484
- /**
485
- * Returns a unique path suitable for `COPY TO '…'` + `copyFileToBuffer`.
486
- * In Node this is an absolute path under `os.tmpdir()` so DuckDB doesn't
487
- * litter the CWD; in browsers/Workers it's a plain virtual-FS name.
488
- */
489
- makeTempPath: (ext: string) => string;
490
- }
491
- interface DuckDBFactory {
492
- getDuckDB: () => Promise<DuckDBHandle>;
493
- }
494
- declare function createDuckDBCodec(factory: DuckDBFactory): ParquetCodec;
495
- declare function createDuckDBExecutor(factory: DuckDBFactory): QueryExecutor;
496
- /**
497
- * Canonical "empty-file" SELECT clause for a table. Codecs that need to
498
- * emit a schema-correct empty Parquet can wrap this in:
499
- * `COPY (SELECT * FROM <clause> WHERE FALSE) TO '<key>' (FORMAT PARQUET)`
500
- * to satisfy the ParquetCodec empty-rows invariant.
501
- */
502
- declare function canonicalEmptyParquetSchema(table: TableName): string;
503
11
  declare const MAX_DAY_BYTES: number;
504
12
  declare function createStorageEngine(opts: EngineOptions): StorageEngine;
505
- /**
506
- * GSC URL inspection result fields we persist. Mirrors the
507
- * `searchconsole_v1.Schema$UrlInspectionResult` shape but as plain JSON
508
- * so storage doesn't depend on the googleapis type tree.
509
- */
510
- interface InspectionRecord {
511
- url: string;
512
- /** ISO-8601 timestamp of when we ran the inspection. */
513
- inspectedAt: string;
514
- /** PASS / NEUTRAL / FAIL — the headline verdict from indexStatusResult. */
515
- indexStatus?: string;
516
- /** Last-crawl timestamp the API reports (ISO-8601). */
517
- lastCrawlTime?: string;
518
- /** Canonical URL Google selected. */
519
- googleCanonical?: string;
520
- /** Canonical URL the page declares. */
521
- userCanonical?: string;
522
- /** Crawl/index/serving disposition strings as the API returns them. */
523
- coverageState?: string;
524
- robotsTxtState?: string;
525
- indexingState?: string;
526
- pageFetchState?: string;
527
- mobileUsabilityVerdict?: string;
528
- richResultsVerdict?: string;
529
- /**
530
- * Free-form payload for fields we don't promote to first-class columns
531
- * (e.g. `referringUrls`, `crawledAs`). Keeps the wire format forward-compat
532
- * without bumping the schema for every API addition.
533
- */
534
- raw?: unknown;
535
- }
536
- /** Wire shape persisted to disk/R2. */
537
- interface InspectionIndex {
538
- version: 1;
539
- /** Map of urlHash → InspectionRecord (latest only). */
540
- records: Record<string, InspectionRecord>;
541
- }
542
- interface InspectionHistoryShard {
543
- version: 1;
544
- /** Append-only list of inspection records for the YYYY-MM bucket. */
545
- records: InspectionRecord[];
546
- }
547
- interface InspectionStore {
548
- /**
549
- * Persist a batch of fresh inspection results. Updates the index +
550
- * appends to the per-month history shard.
551
- */
552
- writeBatch: (ctx: TenantCtx$1, records: readonly InspectionRecord[]) => Promise<void>;
553
- /** Fetch the latest inspection record for a URL, or undefined. */
554
- getLatest: (ctx: TenantCtx$1, url: string) => Promise<InspectionRecord | undefined>;
555
- /**
556
- * Read the full index for a site (latest record per URL). Cheap on
557
- * Workers; on big tenants the dashboard reads this once per page load.
558
- */
559
- loadIndex: (ctx: TenantCtx$1) => Promise<InspectionIndex>;
560
- /** Read the per-month history shard if it exists. */
561
- loadHistory: (ctx: TenantCtx$1, yearMonth: string) => Promise<InspectionHistoryShard | undefined>;
562
- }
563
- interface InspectionSqlDriver {
564
- exec: (sql: string) => void | Promise<void>;
565
- run: (sql: string, params: unknown[]) => void | Promise<void>;
566
- all: (sql: string, params: unknown[]) => unknown[] | Promise<unknown[]>;
567
- serialize: () => Uint8Array | Promise<Uint8Array>;
568
- close: () => void | Promise<void>;
569
- }
570
- interface CreateInspectionStoreSqliteOptions {
571
- dataSource: DataSource;
572
- openDriver: (bytes: Uint8Array | undefined) => InspectionSqlDriver | Promise<InspectionSqlDriver>;
573
- hash?: (url: string) => string;
574
- }
575
- declare function inspectionSqliteKey(ctx: TenantCtx$1): string;
576
- declare function createInspectionStoreSqlite(opts: CreateInspectionStoreSqliteOptions): InspectionStore;
577
- interface GscApiRow {
578
- keys: string[];
579
- clicks: number;
580
- impressions: number;
581
- /** Unused by ingest — the `sum_position` column encodes weighted position. */
582
- ctr?: number;
583
- position: number;
584
- }
585
- interface IngestOptions {
586
- /**
587
- * Canonical form of a query string, stored alongside `query` as
588
- * `query_canonical`. Site-specific (e.g. synonym groups, stemming); if
589
- * omitted, `query_canonical` is null. Applied to `keywords` +
590
- * `page_keywords` tables only.
591
- */
592
- normalizeQuery?: (query: string) => string | null | undefined;
593
- }
594
- /**
595
- * Strip a GSC URL to its pathname. Core analytics stores pages by path so
596
- * queries don't carry origin-prefix filters.
597
- */
598
- declare function toPath(gscUrl: string): string;
599
- /**
600
- * Encode weighted average position as `sum_position`. The raw GSC position
601
- * is 1-indexed; subtract 1 and weight by impressions so a downstream
602
- * `SUM(sum_position) / SUM(impressions) + 1` recovers the true mean without
603
- * ever materialising per-row position values.
604
- */
605
- declare function toSumPosition(apiPosition: number, impressions: number): number;
606
- /**
607
- * Map one GSC API row into `{ date, row }` for the given table, or null if
608
- * the row has no keys (GSC occasionally emits empty-keys placeholders).
609
- */
610
- declare function transformGscRow(table: TableName, apiRow: GscApiRow, options?: IngestOptions): {
611
- date: string;
612
- row: Row;
613
- } | null;
614
- interface RowAccumulator {
615
- /**
616
- * Push a batch of GSC API rows into the accumulator. Returns `false` if
617
- * the batch pushed total row count past `maxRows`; subsequent pushes
618
- * become no-ops until `drain()` is called.
619
- */
620
- push: (table: TableName, rows: readonly GscApiRow[]) => boolean;
621
- /**
622
- * Consume accumulated rows, grouped by `table → date → rows`. Resets
623
- * internal state; subsequent pushes behave as on a fresh accumulator.
624
- */
625
- drain: () => Map<TableName, Map<string, Row[]>>;
626
- /**
627
- * Drain only buckets for dates strictly older than the most-recent date
628
- * seen for each table. Requires `trackDateBoundary` to be enabled — without
629
- * it, returns an empty map. GSC's date-as-dimension queries return rows
630
- * sorted by date, so any date older than the latest seen is logically
631
- * complete within the current job slice and safe to flush mid-job.
632
- *
633
- * Returned buckets are removed from internal state and `totalRows` is
634
- * decremented accordingly. Latest-date buckets stay in place for the
635
- * eventual `drain()` at job end.
636
- */
637
- drainCompleted: () => Map<TableName, Map<string, Row[]>>;
638
- /** Total row count across all tables/dates since last drain. */
639
- readonly totalRows: number;
640
- /** Whether the accumulator has overflowed since last drain. */
641
- readonly overflowed: boolean;
642
- }
643
- interface RowAccumulatorOptions extends IngestOptions {
644
- /**
645
- * Soft cap on total accumulated rows before `push` starts returning
646
- * `false` and dropping rows. Defaults to 500_000 — matches the
647
- * ~128 MB CF Workers isolate budget at ~200 bytes/row with headroom.
648
- */
649
- maxRows?: number;
650
- /**
651
- * Track the most-recent date seen per table so `drainCompleted()` can
652
- * return older-date buckets mid-job. Off by default — callers that don't
653
- * stream-flush pay zero overhead for the bookkeeping.
654
- *
655
- * Caller contract: only safe when GSC dimensions include `date` so the
656
- * API returns rows in date-ascending order; without that ordering,
657
- * "older than latest" doesn't mean "complete" and partial buckets would
658
- * be flushed prematurely.
659
- */
660
- trackDateBoundary?: boolean;
661
- }
662
- declare function createRowAccumulator(options?: RowAccumulatorOptions): RowAccumulator;
663
- interface ResolvedQuery {
664
- sql: string;
665
- params: unknown[];
666
- partitions: string[];
667
- table: TableName;
668
- filesPlaceholder: string;
669
- }
670
- declare const FILES_PLACEHOLDER = "{{FILES}}";
671
- declare function resolveToSQL(state: BuilderState, table?: TableName): ResolvedQuery;
672
- declare function substituteNamedFiles(sql: string, sets: Record<string, string[]>): string;
673
- declare const pages: _$drizzle_orm_pg_core0.PgTableWithColumns<{
674
- name: "pages";
675
- schema: undefined;
676
- columns: {
677
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
678
- name: string;
679
- tableName: "pages";
680
- dataType: "number";
681
- columnType: "PgInteger";
682
- data: number;
683
- driverParam: string | number;
684
- notNull: true;
685
- hasDefault: false;
686
- isPrimaryKey: false;
687
- isAutoincrement: false;
688
- hasRuntimeDefault: false;
689
- enumValues: undefined;
690
- baseColumn: never;
691
- identity: undefined;
692
- generated: undefined;
693
- }, {}, {}>;
694
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
695
- name: string;
696
- tableName: "pages";
697
- dataType: "number";
698
- columnType: "PgInteger";
699
- data: number;
700
- driverParam: string | number;
701
- notNull: true;
702
- hasDefault: false;
703
- isPrimaryKey: false;
704
- isAutoincrement: false;
705
- hasRuntimeDefault: false;
706
- enumValues: undefined;
707
- baseColumn: never;
708
- identity: undefined;
709
- generated: undefined;
710
- }, {}, {}>;
711
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
712
- name: string;
713
- tableName: "pages";
714
- dataType: "number";
715
- columnType: "PgDoublePrecision";
716
- data: number;
717
- driverParam: string | number;
718
- notNull: true;
719
- hasDefault: false;
720
- isPrimaryKey: false;
721
- isAutoincrement: false;
722
- hasRuntimeDefault: false;
723
- enumValues: undefined;
724
- baseColumn: never;
725
- identity: undefined;
726
- generated: undefined;
727
- }, {}, {}>;
728
- url: _$drizzle_orm_pg_core0.PgColumn<{
729
- name: "url";
730
- tableName: "pages";
731
- dataType: "string";
732
- columnType: "PgVarchar";
733
- data: string;
734
- driverParam: string;
735
- notNull: true;
736
- hasDefault: false;
737
- isPrimaryKey: false;
738
- isAutoincrement: false;
739
- hasRuntimeDefault: false;
740
- enumValues: [string, ...string[]];
741
- baseColumn: never;
742
- identity: undefined;
743
- generated: undefined;
744
- }, {}, {
745
- length: number | undefined;
746
- }>;
747
- date: _$drizzle_orm_pg_core0.PgColumn<{
748
- name: string;
749
- tableName: "pages";
750
- dataType: "string";
751
- columnType: "PgDateString";
752
- data: string;
753
- driverParam: string;
754
- notNull: true;
755
- hasDefault: false;
756
- isPrimaryKey: false;
757
- isAutoincrement: false;
758
- hasRuntimeDefault: false;
759
- enumValues: undefined;
760
- baseColumn: never;
761
- identity: undefined;
762
- generated: undefined;
763
- }, {}, {}>;
764
- };
765
- dialect: "pg";
766
- }>;
767
- declare const keywords: _$drizzle_orm_pg_core0.PgTableWithColumns<{
768
- name: "keywords";
769
- schema: undefined;
770
- columns: {
771
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
772
- name: string;
773
- tableName: "keywords";
774
- dataType: "number";
775
- columnType: "PgInteger";
776
- data: number;
777
- driverParam: string | number;
778
- notNull: true;
779
- hasDefault: false;
780
- isPrimaryKey: false;
781
- isAutoincrement: false;
782
- hasRuntimeDefault: false;
783
- enumValues: undefined;
784
- baseColumn: never;
785
- identity: undefined;
786
- generated: undefined;
787
- }, {}, {}>;
788
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
789
- name: string;
790
- tableName: "keywords";
791
- dataType: "number";
792
- columnType: "PgInteger";
793
- data: number;
794
- driverParam: string | number;
795
- notNull: true;
796
- hasDefault: false;
797
- isPrimaryKey: false;
798
- isAutoincrement: false;
799
- hasRuntimeDefault: false;
800
- enumValues: undefined;
801
- baseColumn: never;
802
- identity: undefined;
803
- generated: undefined;
804
- }, {}, {}>;
805
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
806
- name: string;
807
- tableName: "keywords";
808
- dataType: "number";
809
- columnType: "PgDoublePrecision";
810
- data: number;
811
- driverParam: string | number;
812
- notNull: true;
813
- hasDefault: false;
814
- isPrimaryKey: false;
815
- isAutoincrement: false;
816
- hasRuntimeDefault: false;
817
- enumValues: undefined;
818
- baseColumn: never;
819
- identity: undefined;
820
- generated: undefined;
821
- }, {}, {}>;
822
- query: _$drizzle_orm_pg_core0.PgColumn<{
823
- name: "query";
824
- tableName: "keywords";
825
- dataType: "string";
826
- columnType: "PgVarchar";
827
- data: string;
828
- driverParam: string;
829
- notNull: true;
830
- hasDefault: false;
831
- isPrimaryKey: false;
832
- isAutoincrement: false;
833
- hasRuntimeDefault: false;
834
- enumValues: [string, ...string[]];
835
- baseColumn: never;
836
- identity: undefined;
837
- generated: undefined;
838
- }, {}, {
839
- length: number | undefined;
840
- }>;
841
- query_canonical: _$drizzle_orm_pg_core0.PgColumn<{
842
- name: "query_canonical";
843
- tableName: "keywords";
844
- dataType: "string";
845
- columnType: "PgVarchar";
846
- data: string;
847
- driverParam: string;
848
- notNull: false;
849
- hasDefault: false;
850
- isPrimaryKey: false;
851
- isAutoincrement: false;
852
- hasRuntimeDefault: false;
853
- enumValues: [string, ...string[]];
854
- baseColumn: never;
855
- identity: undefined;
856
- generated: undefined;
857
- }, {}, {
858
- length: number | undefined;
859
- }>;
860
- date: _$drizzle_orm_pg_core0.PgColumn<{
861
- name: string;
862
- tableName: "keywords";
863
- dataType: "string";
864
- columnType: "PgDateString";
865
- data: string;
866
- driverParam: string;
867
- notNull: true;
868
- hasDefault: false;
869
- isPrimaryKey: false;
870
- isAutoincrement: false;
871
- hasRuntimeDefault: false;
872
- enumValues: undefined;
873
- baseColumn: never;
874
- identity: undefined;
875
- generated: undefined;
876
- }, {}, {}>;
877
- };
878
- dialect: "pg";
879
- }>;
880
- declare const countries: _$drizzle_orm_pg_core0.PgTableWithColumns<{
881
- name: "countries";
882
- schema: undefined;
883
- columns: {
884
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
885
- name: string;
886
- tableName: "countries";
887
- dataType: "number";
888
- columnType: "PgInteger";
889
- data: number;
890
- driverParam: string | number;
891
- notNull: true;
892
- hasDefault: false;
893
- isPrimaryKey: false;
894
- isAutoincrement: false;
895
- hasRuntimeDefault: false;
896
- enumValues: undefined;
897
- baseColumn: never;
898
- identity: undefined;
899
- generated: undefined;
900
- }, {}, {}>;
901
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
902
- name: string;
903
- tableName: "countries";
904
- dataType: "number";
905
- columnType: "PgInteger";
906
- data: number;
907
- driverParam: string | number;
908
- notNull: true;
909
- hasDefault: false;
910
- isPrimaryKey: false;
911
- isAutoincrement: false;
912
- hasRuntimeDefault: false;
913
- enumValues: undefined;
914
- baseColumn: never;
915
- identity: undefined;
916
- generated: undefined;
917
- }, {}, {}>;
918
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
919
- name: string;
920
- tableName: "countries";
921
- dataType: "number";
922
- columnType: "PgDoublePrecision";
923
- data: number;
924
- driverParam: string | number;
925
- notNull: true;
926
- hasDefault: false;
927
- isPrimaryKey: false;
928
- isAutoincrement: false;
929
- hasRuntimeDefault: false;
930
- enumValues: undefined;
931
- baseColumn: never;
932
- identity: undefined;
933
- generated: undefined;
934
- }, {}, {}>;
935
- country: _$drizzle_orm_pg_core0.PgColumn<{
936
- name: "country";
937
- tableName: "countries";
938
- dataType: "string";
939
- columnType: "PgVarchar";
940
- data: string;
941
- driverParam: string;
942
- notNull: true;
943
- hasDefault: false;
944
- isPrimaryKey: false;
945
- isAutoincrement: false;
946
- hasRuntimeDefault: false;
947
- enumValues: [string, ...string[]];
948
- baseColumn: never;
949
- identity: undefined;
950
- generated: undefined;
951
- }, {}, {
952
- length: number | undefined;
953
- }>;
954
- date: _$drizzle_orm_pg_core0.PgColumn<{
955
- name: string;
956
- tableName: "countries";
957
- dataType: "string";
958
- columnType: "PgDateString";
959
- data: string;
960
- driverParam: string;
961
- notNull: true;
962
- hasDefault: false;
963
- isPrimaryKey: false;
964
- isAutoincrement: false;
965
- hasRuntimeDefault: false;
966
- enumValues: undefined;
967
- baseColumn: never;
968
- identity: undefined;
969
- generated: undefined;
970
- }, {}, {}>;
971
- };
972
- dialect: "pg";
973
- }>;
974
- declare const devices: _$drizzle_orm_pg_core0.PgTableWithColumns<{
975
- name: "devices";
976
- schema: undefined;
977
- columns: {
978
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
979
- name: string;
980
- tableName: "devices";
981
- dataType: "number";
982
- columnType: "PgInteger";
983
- data: number;
984
- driverParam: string | number;
985
- notNull: true;
986
- hasDefault: false;
987
- isPrimaryKey: false;
988
- isAutoincrement: false;
989
- hasRuntimeDefault: false;
990
- enumValues: undefined;
991
- baseColumn: never;
992
- identity: undefined;
993
- generated: undefined;
994
- }, {}, {}>;
995
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
996
- name: string;
997
- tableName: "devices";
998
- dataType: "number";
999
- columnType: "PgInteger";
1000
- data: number;
1001
- driverParam: string | number;
1002
- notNull: true;
1003
- hasDefault: false;
1004
- isPrimaryKey: false;
1005
- isAutoincrement: false;
1006
- hasRuntimeDefault: false;
1007
- enumValues: undefined;
1008
- baseColumn: never;
1009
- identity: undefined;
1010
- generated: undefined;
1011
- }, {}, {}>;
1012
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
1013
- name: string;
1014
- tableName: "devices";
1015
- dataType: "number";
1016
- columnType: "PgDoublePrecision";
1017
- data: number;
1018
- driverParam: string | number;
1019
- notNull: true;
1020
- hasDefault: false;
1021
- isPrimaryKey: false;
1022
- isAutoincrement: false;
1023
- hasRuntimeDefault: false;
1024
- enumValues: undefined;
1025
- baseColumn: never;
1026
- identity: undefined;
1027
- generated: undefined;
1028
- }, {}, {}>;
1029
- device: _$drizzle_orm_pg_core0.PgColumn<{
1030
- name: "device";
1031
- tableName: "devices";
1032
- dataType: "string";
1033
- columnType: "PgVarchar";
1034
- data: string;
1035
- driverParam: string;
1036
- notNull: true;
1037
- hasDefault: false;
1038
- isPrimaryKey: false;
1039
- isAutoincrement: false;
1040
- hasRuntimeDefault: false;
1041
- enumValues: [string, ...string[]];
1042
- baseColumn: never;
1043
- identity: undefined;
1044
- generated: undefined;
1045
- }, {}, {
1046
- length: number | undefined;
1047
- }>;
1048
- date: _$drizzle_orm_pg_core0.PgColumn<{
1049
- name: string;
1050
- tableName: "devices";
1051
- dataType: "string";
1052
- columnType: "PgDateString";
1053
- data: string;
1054
- driverParam: string;
1055
- notNull: true;
1056
- hasDefault: false;
1057
- isPrimaryKey: false;
1058
- isAutoincrement: false;
1059
- hasRuntimeDefault: false;
1060
- enumValues: undefined;
1061
- baseColumn: never;
1062
- identity: undefined;
1063
- generated: undefined;
1064
- }, {}, {}>;
1065
- };
1066
- dialect: "pg";
1067
- }>;
1068
- declare const page_keywords: _$drizzle_orm_pg_core0.PgTableWithColumns<{
1069
- name: "page_keywords";
1070
- schema: undefined;
1071
- columns: {
1072
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
1073
- name: string;
1074
- tableName: "page_keywords";
1075
- dataType: "number";
1076
- columnType: "PgInteger";
1077
- data: number;
1078
- driverParam: string | number;
1079
- notNull: true;
1080
- hasDefault: false;
1081
- isPrimaryKey: false;
1082
- isAutoincrement: false;
1083
- hasRuntimeDefault: false;
1084
- enumValues: undefined;
1085
- baseColumn: never;
1086
- identity: undefined;
1087
- generated: undefined;
1088
- }, {}, {}>;
1089
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
1090
- name: string;
1091
- tableName: "page_keywords";
1092
- dataType: "number";
1093
- columnType: "PgInteger";
1094
- data: number;
1095
- driverParam: string | number;
1096
- notNull: true;
1097
- hasDefault: false;
1098
- isPrimaryKey: false;
1099
- isAutoincrement: false;
1100
- hasRuntimeDefault: false;
1101
- enumValues: undefined;
1102
- baseColumn: never;
1103
- identity: undefined;
1104
- generated: undefined;
1105
- }, {}, {}>;
1106
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
1107
- name: string;
1108
- tableName: "page_keywords";
1109
- dataType: "number";
1110
- columnType: "PgDoublePrecision";
1111
- data: number;
1112
- driverParam: string | number;
1113
- notNull: true;
1114
- hasDefault: false;
1115
- isPrimaryKey: false;
1116
- isAutoincrement: false;
1117
- hasRuntimeDefault: false;
1118
- enumValues: undefined;
1119
- baseColumn: never;
1120
- identity: undefined;
1121
- generated: undefined;
1122
- }, {}, {}>;
1123
- url: _$drizzle_orm_pg_core0.PgColumn<{
1124
- name: "url";
1125
- tableName: "page_keywords";
1126
- dataType: "string";
1127
- columnType: "PgVarchar";
1128
- data: string;
1129
- driverParam: string;
1130
- notNull: true;
1131
- hasDefault: false;
1132
- isPrimaryKey: false;
1133
- isAutoincrement: false;
1134
- hasRuntimeDefault: false;
1135
- enumValues: [string, ...string[]];
1136
- baseColumn: never;
1137
- identity: undefined;
1138
- generated: undefined;
1139
- }, {}, {
1140
- length: number | undefined;
1141
- }>;
1142
- query: _$drizzle_orm_pg_core0.PgColumn<{
1143
- name: "query";
1144
- tableName: "page_keywords";
1145
- dataType: "string";
1146
- columnType: "PgVarchar";
1147
- data: string;
1148
- driverParam: string;
1149
- notNull: true;
1150
- hasDefault: false;
1151
- isPrimaryKey: false;
1152
- isAutoincrement: false;
1153
- hasRuntimeDefault: false;
1154
- enumValues: [string, ...string[]];
1155
- baseColumn: never;
1156
- identity: undefined;
1157
- generated: undefined;
1158
- }, {}, {
1159
- length: number | undefined;
1160
- }>;
1161
- query_canonical: _$drizzle_orm_pg_core0.PgColumn<{
1162
- name: "query_canonical";
1163
- tableName: "page_keywords";
1164
- dataType: "string";
1165
- columnType: "PgVarchar";
1166
- data: string;
1167
- driverParam: string;
1168
- notNull: false;
1169
- hasDefault: false;
1170
- isPrimaryKey: false;
1171
- isAutoincrement: false;
1172
- hasRuntimeDefault: false;
1173
- enumValues: [string, ...string[]];
1174
- baseColumn: never;
1175
- identity: undefined;
1176
- generated: undefined;
1177
- }, {}, {
1178
- length: number | undefined;
1179
- }>;
1180
- date: _$drizzle_orm_pg_core0.PgColumn<{
1181
- name: string;
1182
- tableName: "page_keywords";
1183
- dataType: "string";
1184
- columnType: "PgDateString";
1185
- data: string;
1186
- driverParam: string;
1187
- notNull: true;
1188
- hasDefault: false;
1189
- isPrimaryKey: false;
1190
- isAutoincrement: false;
1191
- hasRuntimeDefault: false;
1192
- enumValues: undefined;
1193
- baseColumn: never;
1194
- identity: undefined;
1195
- generated: undefined;
1196
- }, {}, {}>;
1197
- };
1198
- dialect: "pg";
1199
- }>;
1200
- declare const drizzleSchema: {
1201
- pages: _$drizzle_orm_pg_core0.PgTableWithColumns<{
1202
- name: "pages";
1203
- schema: undefined;
1204
- columns: {
1205
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
1206
- name: string;
1207
- tableName: "pages";
1208
- dataType: "number";
1209
- columnType: "PgInteger";
1210
- data: number;
1211
- driverParam: string | number;
1212
- notNull: true;
1213
- hasDefault: false;
1214
- isPrimaryKey: false;
1215
- isAutoincrement: false;
1216
- hasRuntimeDefault: false;
1217
- enumValues: undefined;
1218
- baseColumn: never;
1219
- identity: undefined;
1220
- generated: undefined;
1221
- }, {}, {}>;
1222
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
1223
- name: string;
1224
- tableName: "pages";
1225
- dataType: "number";
1226
- columnType: "PgInteger";
1227
- data: number;
1228
- driverParam: string | number;
1229
- notNull: true;
1230
- hasDefault: false;
1231
- isPrimaryKey: false;
1232
- isAutoincrement: false;
1233
- hasRuntimeDefault: false;
1234
- enumValues: undefined;
1235
- baseColumn: never;
1236
- identity: undefined;
1237
- generated: undefined;
1238
- }, {}, {}>;
1239
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
1240
- name: string;
1241
- tableName: "pages";
1242
- dataType: "number";
1243
- columnType: "PgDoublePrecision";
1244
- data: number;
1245
- driverParam: string | number;
1246
- notNull: true;
1247
- hasDefault: false;
1248
- isPrimaryKey: false;
1249
- isAutoincrement: false;
1250
- hasRuntimeDefault: false;
1251
- enumValues: undefined;
1252
- baseColumn: never;
1253
- identity: undefined;
1254
- generated: undefined;
1255
- }, {}, {}>;
1256
- url: _$drizzle_orm_pg_core0.PgColumn<{
1257
- name: "url";
1258
- tableName: "pages";
1259
- dataType: "string";
1260
- columnType: "PgVarchar";
1261
- data: string;
1262
- driverParam: string;
1263
- notNull: true;
1264
- hasDefault: false;
1265
- isPrimaryKey: false;
1266
- isAutoincrement: false;
1267
- hasRuntimeDefault: false;
1268
- enumValues: [string, ...string[]];
1269
- baseColumn: never;
1270
- identity: undefined;
1271
- generated: undefined;
1272
- }, {}, {
1273
- length: number | undefined;
1274
- }>;
1275
- date: _$drizzle_orm_pg_core0.PgColumn<{
1276
- name: string;
1277
- tableName: "pages";
1278
- dataType: "string";
1279
- columnType: "PgDateString";
1280
- data: string;
1281
- driverParam: string;
1282
- notNull: true;
1283
- hasDefault: false;
1284
- isPrimaryKey: false;
1285
- isAutoincrement: false;
1286
- hasRuntimeDefault: false;
1287
- enumValues: undefined;
1288
- baseColumn: never;
1289
- identity: undefined;
1290
- generated: undefined;
1291
- }, {}, {}>;
1292
- };
1293
- dialect: "pg";
1294
- }>;
1295
- keywords: _$drizzle_orm_pg_core0.PgTableWithColumns<{
1296
- name: "keywords";
1297
- schema: undefined;
1298
- columns: {
1299
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
1300
- name: string;
1301
- tableName: "keywords";
1302
- dataType: "number";
1303
- columnType: "PgInteger";
1304
- data: number;
1305
- driverParam: string | number;
1306
- notNull: true;
1307
- hasDefault: false;
1308
- isPrimaryKey: false;
1309
- isAutoincrement: false;
1310
- hasRuntimeDefault: false;
1311
- enumValues: undefined;
1312
- baseColumn: never;
1313
- identity: undefined;
1314
- generated: undefined;
1315
- }, {}, {}>;
1316
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
1317
- name: string;
1318
- tableName: "keywords";
1319
- dataType: "number";
1320
- columnType: "PgInteger";
1321
- data: number;
1322
- driverParam: string | number;
1323
- notNull: true;
1324
- hasDefault: false;
1325
- isPrimaryKey: false;
1326
- isAutoincrement: false;
1327
- hasRuntimeDefault: false;
1328
- enumValues: undefined;
1329
- baseColumn: never;
1330
- identity: undefined;
1331
- generated: undefined;
1332
- }, {}, {}>;
1333
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
1334
- name: string;
1335
- tableName: "keywords";
1336
- dataType: "number";
1337
- columnType: "PgDoublePrecision";
1338
- data: number;
1339
- driverParam: string | number;
1340
- notNull: true;
1341
- hasDefault: false;
1342
- isPrimaryKey: false;
1343
- isAutoincrement: false;
1344
- hasRuntimeDefault: false;
1345
- enumValues: undefined;
1346
- baseColumn: never;
1347
- identity: undefined;
1348
- generated: undefined;
1349
- }, {}, {}>;
1350
- query: _$drizzle_orm_pg_core0.PgColumn<{
1351
- name: "query";
1352
- tableName: "keywords";
1353
- dataType: "string";
1354
- columnType: "PgVarchar";
1355
- data: string;
1356
- driverParam: string;
1357
- notNull: true;
1358
- hasDefault: false;
1359
- isPrimaryKey: false;
1360
- isAutoincrement: false;
1361
- hasRuntimeDefault: false;
1362
- enumValues: [string, ...string[]];
1363
- baseColumn: never;
1364
- identity: undefined;
1365
- generated: undefined;
1366
- }, {}, {
1367
- length: number | undefined;
1368
- }>;
1369
- query_canonical: _$drizzle_orm_pg_core0.PgColumn<{
1370
- name: "query_canonical";
1371
- tableName: "keywords";
1372
- dataType: "string";
1373
- columnType: "PgVarchar";
1374
- data: string;
1375
- driverParam: string;
1376
- notNull: false;
1377
- hasDefault: false;
1378
- isPrimaryKey: false;
1379
- isAutoincrement: false;
1380
- hasRuntimeDefault: false;
1381
- enumValues: [string, ...string[]];
1382
- baseColumn: never;
1383
- identity: undefined;
1384
- generated: undefined;
1385
- }, {}, {
1386
- length: number | undefined;
1387
- }>;
1388
- date: _$drizzle_orm_pg_core0.PgColumn<{
1389
- name: string;
1390
- tableName: "keywords";
1391
- dataType: "string";
1392
- columnType: "PgDateString";
1393
- data: string;
1394
- driverParam: string;
1395
- notNull: true;
1396
- hasDefault: false;
1397
- isPrimaryKey: false;
1398
- isAutoincrement: false;
1399
- hasRuntimeDefault: false;
1400
- enumValues: undefined;
1401
- baseColumn: never;
1402
- identity: undefined;
1403
- generated: undefined;
1404
- }, {}, {}>;
1405
- };
1406
- dialect: "pg";
1407
- }>;
1408
- countries: _$drizzle_orm_pg_core0.PgTableWithColumns<{
1409
- name: "countries";
1410
- schema: undefined;
1411
- columns: {
1412
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
1413
- name: string;
1414
- tableName: "countries";
1415
- dataType: "number";
1416
- columnType: "PgInteger";
1417
- data: number;
1418
- driverParam: string | number;
1419
- notNull: true;
1420
- hasDefault: false;
1421
- isPrimaryKey: false;
1422
- isAutoincrement: false;
1423
- hasRuntimeDefault: false;
1424
- enumValues: undefined;
1425
- baseColumn: never;
1426
- identity: undefined;
1427
- generated: undefined;
1428
- }, {}, {}>;
1429
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
1430
- name: string;
1431
- tableName: "countries";
1432
- dataType: "number";
1433
- columnType: "PgInteger";
1434
- data: number;
1435
- driverParam: string | number;
1436
- notNull: true;
1437
- hasDefault: false;
1438
- isPrimaryKey: false;
1439
- isAutoincrement: false;
1440
- hasRuntimeDefault: false;
1441
- enumValues: undefined;
1442
- baseColumn: never;
1443
- identity: undefined;
1444
- generated: undefined;
1445
- }, {}, {}>;
1446
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
1447
- name: string;
1448
- tableName: "countries";
1449
- dataType: "number";
1450
- columnType: "PgDoublePrecision";
1451
- data: number;
1452
- driverParam: string | number;
1453
- notNull: true;
1454
- hasDefault: false;
1455
- isPrimaryKey: false;
1456
- isAutoincrement: false;
1457
- hasRuntimeDefault: false;
1458
- enumValues: undefined;
1459
- baseColumn: never;
1460
- identity: undefined;
1461
- generated: undefined;
1462
- }, {}, {}>;
1463
- country: _$drizzle_orm_pg_core0.PgColumn<{
1464
- name: "country";
1465
- tableName: "countries";
1466
- dataType: "string";
1467
- columnType: "PgVarchar";
1468
- data: string;
1469
- driverParam: string;
1470
- notNull: true;
1471
- hasDefault: false;
1472
- isPrimaryKey: false;
1473
- isAutoincrement: false;
1474
- hasRuntimeDefault: false;
1475
- enumValues: [string, ...string[]];
1476
- baseColumn: never;
1477
- identity: undefined;
1478
- generated: undefined;
1479
- }, {}, {
1480
- length: number | undefined;
1481
- }>;
1482
- date: _$drizzle_orm_pg_core0.PgColumn<{
1483
- name: string;
1484
- tableName: "countries";
1485
- dataType: "string";
1486
- columnType: "PgDateString";
1487
- data: string;
1488
- driverParam: string;
1489
- notNull: true;
1490
- hasDefault: false;
1491
- isPrimaryKey: false;
1492
- isAutoincrement: false;
1493
- hasRuntimeDefault: false;
1494
- enumValues: undefined;
1495
- baseColumn: never;
1496
- identity: undefined;
1497
- generated: undefined;
1498
- }, {}, {}>;
1499
- };
1500
- dialect: "pg";
1501
- }>;
1502
- devices: _$drizzle_orm_pg_core0.PgTableWithColumns<{
1503
- name: "devices";
1504
- schema: undefined;
1505
- columns: {
1506
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
1507
- name: string;
1508
- tableName: "devices";
1509
- dataType: "number";
1510
- columnType: "PgInteger";
1511
- data: number;
1512
- driverParam: string | number;
1513
- notNull: true;
1514
- hasDefault: false;
1515
- isPrimaryKey: false;
1516
- isAutoincrement: false;
1517
- hasRuntimeDefault: false;
1518
- enumValues: undefined;
1519
- baseColumn: never;
1520
- identity: undefined;
1521
- generated: undefined;
1522
- }, {}, {}>;
1523
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
1524
- name: string;
1525
- tableName: "devices";
1526
- dataType: "number";
1527
- columnType: "PgInteger";
1528
- data: number;
1529
- driverParam: string | number;
1530
- notNull: true;
1531
- hasDefault: false;
1532
- isPrimaryKey: false;
1533
- isAutoincrement: false;
1534
- hasRuntimeDefault: false;
1535
- enumValues: undefined;
1536
- baseColumn: never;
1537
- identity: undefined;
1538
- generated: undefined;
1539
- }, {}, {}>;
1540
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
1541
- name: string;
1542
- tableName: "devices";
1543
- dataType: "number";
1544
- columnType: "PgDoublePrecision";
1545
- data: number;
1546
- driverParam: string | number;
1547
- notNull: true;
1548
- hasDefault: false;
1549
- isPrimaryKey: false;
1550
- isAutoincrement: false;
1551
- hasRuntimeDefault: false;
1552
- enumValues: undefined;
1553
- baseColumn: never;
1554
- identity: undefined;
1555
- generated: undefined;
1556
- }, {}, {}>;
1557
- device: _$drizzle_orm_pg_core0.PgColumn<{
1558
- name: "device";
1559
- tableName: "devices";
1560
- dataType: "string";
1561
- columnType: "PgVarchar";
1562
- data: string;
1563
- driverParam: string;
1564
- notNull: true;
1565
- hasDefault: false;
1566
- isPrimaryKey: false;
1567
- isAutoincrement: false;
1568
- hasRuntimeDefault: false;
1569
- enumValues: [string, ...string[]];
1570
- baseColumn: never;
1571
- identity: undefined;
1572
- generated: undefined;
1573
- }, {}, {
1574
- length: number | undefined;
1575
- }>;
1576
- date: _$drizzle_orm_pg_core0.PgColumn<{
1577
- name: string;
1578
- tableName: "devices";
1579
- dataType: "string";
1580
- columnType: "PgDateString";
1581
- data: string;
1582
- driverParam: string;
1583
- notNull: true;
1584
- hasDefault: false;
1585
- isPrimaryKey: false;
1586
- isAutoincrement: false;
1587
- hasRuntimeDefault: false;
1588
- enumValues: undefined;
1589
- baseColumn: never;
1590
- identity: undefined;
1591
- generated: undefined;
1592
- }, {}, {}>;
1593
- };
1594
- dialect: "pg";
1595
- }>;
1596
- page_keywords: _$drizzle_orm_pg_core0.PgTableWithColumns<{
1597
- name: "page_keywords";
1598
- schema: undefined;
1599
- columns: {
1600
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
1601
- name: string;
1602
- tableName: "page_keywords";
1603
- dataType: "number";
1604
- columnType: "PgInteger";
1605
- data: number;
1606
- driverParam: string | number;
1607
- notNull: true;
1608
- hasDefault: false;
1609
- isPrimaryKey: false;
1610
- isAutoincrement: false;
1611
- hasRuntimeDefault: false;
1612
- enumValues: undefined;
1613
- baseColumn: never;
1614
- identity: undefined;
1615
- generated: undefined;
1616
- }, {}, {}>;
1617
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
1618
- name: string;
1619
- tableName: "page_keywords";
1620
- dataType: "number";
1621
- columnType: "PgInteger";
1622
- data: number;
1623
- driverParam: string | number;
1624
- notNull: true;
1625
- hasDefault: false;
1626
- isPrimaryKey: false;
1627
- isAutoincrement: false;
1628
- hasRuntimeDefault: false;
1629
- enumValues: undefined;
1630
- baseColumn: never;
1631
- identity: undefined;
1632
- generated: undefined;
1633
- }, {}, {}>;
1634
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
1635
- name: string;
1636
- tableName: "page_keywords";
1637
- dataType: "number";
1638
- columnType: "PgDoublePrecision";
1639
- data: number;
1640
- driverParam: string | number;
1641
- notNull: true;
1642
- hasDefault: false;
1643
- isPrimaryKey: false;
1644
- isAutoincrement: false;
1645
- hasRuntimeDefault: false;
1646
- enumValues: undefined;
1647
- baseColumn: never;
1648
- identity: undefined;
1649
- generated: undefined;
1650
- }, {}, {}>;
1651
- url: _$drizzle_orm_pg_core0.PgColumn<{
1652
- name: "url";
1653
- tableName: "page_keywords";
1654
- dataType: "string";
1655
- columnType: "PgVarchar";
1656
- data: string;
1657
- driverParam: string;
1658
- notNull: true;
1659
- hasDefault: false;
1660
- isPrimaryKey: false;
1661
- isAutoincrement: false;
1662
- hasRuntimeDefault: false;
1663
- enumValues: [string, ...string[]];
1664
- baseColumn: never;
1665
- identity: undefined;
1666
- generated: undefined;
1667
- }, {}, {
1668
- length: number | undefined;
1669
- }>;
1670
- query: _$drizzle_orm_pg_core0.PgColumn<{
1671
- name: "query";
1672
- tableName: "page_keywords";
1673
- dataType: "string";
1674
- columnType: "PgVarchar";
1675
- data: string;
1676
- driverParam: string;
1677
- notNull: true;
1678
- hasDefault: false;
1679
- isPrimaryKey: false;
1680
- isAutoincrement: false;
1681
- hasRuntimeDefault: false;
1682
- enumValues: [string, ...string[]];
1683
- baseColumn: never;
1684
- identity: undefined;
1685
- generated: undefined;
1686
- }, {}, {
1687
- length: number | undefined;
1688
- }>;
1689
- query_canonical: _$drizzle_orm_pg_core0.PgColumn<{
1690
- name: "query_canonical";
1691
- tableName: "page_keywords";
1692
- dataType: "string";
1693
- columnType: "PgVarchar";
1694
- data: string;
1695
- driverParam: string;
1696
- notNull: false;
1697
- hasDefault: false;
1698
- isPrimaryKey: false;
1699
- isAutoincrement: false;
1700
- hasRuntimeDefault: false;
1701
- enumValues: [string, ...string[]];
1702
- baseColumn: never;
1703
- identity: undefined;
1704
- generated: undefined;
1705
- }, {}, {
1706
- length: number | undefined;
1707
- }>;
1708
- date: _$drizzle_orm_pg_core0.PgColumn<{
1709
- name: string;
1710
- tableName: "page_keywords";
1711
- dataType: "string";
1712
- columnType: "PgDateString";
1713
- data: string;
1714
- driverParam: string;
1715
- notNull: true;
1716
- hasDefault: false;
1717
- isPrimaryKey: false;
1718
- isAutoincrement: false;
1719
- hasRuntimeDefault: false;
1720
- enumValues: undefined;
1721
- baseColumn: never;
1722
- identity: undefined;
1723
- generated: undefined;
1724
- }, {}, {}>;
1725
- };
1726
- dialect: "pg";
1727
- }>;
1728
- search_appearance: _$drizzle_orm_pg_core0.PgTableWithColumns<{
1729
- name: "search_appearance";
1730
- schema: undefined;
1731
- columns: {
1732
- clicks: _$drizzle_orm_pg_core0.PgColumn<{
1733
- name: string;
1734
- tableName: "search_appearance";
1735
- dataType: "number";
1736
- columnType: "PgInteger";
1737
- data: number;
1738
- driverParam: string | number;
1739
- notNull: true;
1740
- hasDefault: false;
1741
- isPrimaryKey: false;
1742
- isAutoincrement: false;
1743
- hasRuntimeDefault: false;
1744
- enumValues: undefined;
1745
- baseColumn: never;
1746
- identity: undefined;
1747
- generated: undefined;
1748
- }, {}, {}>;
1749
- impressions: _$drizzle_orm_pg_core0.PgColumn<{
1750
- name: string;
1751
- tableName: "search_appearance";
1752
- dataType: "number";
1753
- columnType: "PgInteger";
1754
- data: number;
1755
- driverParam: string | number;
1756
- notNull: true;
1757
- hasDefault: false;
1758
- isPrimaryKey: false;
1759
- isAutoincrement: false;
1760
- hasRuntimeDefault: false;
1761
- enumValues: undefined;
1762
- baseColumn: never;
1763
- identity: undefined;
1764
- generated: undefined;
1765
- }, {}, {}>;
1766
- sum_position: _$drizzle_orm_pg_core0.PgColumn<{
1767
- name: string;
1768
- tableName: "search_appearance";
1769
- dataType: "number";
1770
- columnType: "PgDoublePrecision";
1771
- data: number;
1772
- driverParam: string | number;
1773
- notNull: true;
1774
- hasDefault: false;
1775
- isPrimaryKey: false;
1776
- isAutoincrement: false;
1777
- hasRuntimeDefault: false;
1778
- enumValues: undefined;
1779
- baseColumn: never;
1780
- identity: undefined;
1781
- generated: undefined;
1782
- }, {}, {}>;
1783
- searchAppearance: _$drizzle_orm_pg_core0.PgColumn<{
1784
- name: "searchAppearance";
1785
- tableName: "search_appearance";
1786
- dataType: "string";
1787
- columnType: "PgVarchar";
1788
- data: string;
1789
- driverParam: string;
1790
- notNull: true;
1791
- hasDefault: false;
1792
- isPrimaryKey: false;
1793
- isAutoincrement: false;
1794
- hasRuntimeDefault: false;
1795
- enumValues: [string, ...string[]];
1796
- baseColumn: never;
1797
- identity: undefined;
1798
- generated: undefined;
1799
- }, {}, {
1800
- length: number | undefined;
1801
- }>;
1802
- date: _$drizzle_orm_pg_core0.PgColumn<{
1803
- name: string;
1804
- tableName: "search_appearance";
1805
- dataType: "string";
1806
- columnType: "PgDateString";
1807
- data: string;
1808
- driverParam: string;
1809
- notNull: true;
1810
- hasDefault: false;
1811
- isPrimaryKey: false;
1812
- isAutoincrement: false;
1813
- hasRuntimeDefault: false;
1814
- enumValues: undefined;
1815
- baseColumn: never;
1816
- identity: undefined;
1817
- generated: undefined;
1818
- }, {}, {}>;
1819
- };
1820
- dialect: "pg";
1821
- }>;
1822
- };
1823
- type DrizzleSchema = typeof drizzleSchema;
1824
- declare const TABLE_METADATA: Record<TableName$1, {
1825
- sortKey: string[];
1826
- version: number;
1827
- }>;
1828
- declare const SCHEMAS: Record<TableName$1, TableSchema$1>;
1829
- declare function currentSchemaVersion(table: TableName$1): number;
1830
- declare function allTables(): readonly TableName$1[];
1831
- declare function inferTable(dimensions: readonly string[]): TableName$1;
1832
- declare function dimensionToColumn(dim: string, _table: TableName$1): string;
1833
- declare function formatLiteral(value: unknown): string;
1834
- /**
1835
- * Replace `?` and `$N` placeholders with inline SQL literals. Single-quoted
1836
- * string regions and SQL comments (`-- line`, `/* block *\/`) are left
1837
- * untouched — a `?` or `$1` inside `'foo?bar'` or a comment is not a
1838
- * placeholder. SQL-standard `''` escape handling; no `\`-escape or
1839
- * dialect-specific identifier quoting.
1840
- *
1841
- * `?` placeholders bind sequentially against `params`. `$N` (Postgres-style)
1842
- * binds explicitly to `params[N-1]`. The two styles must not be mixed in the
1843
- * same query.
1844
- *
1845
- * Throws when placeholder count and params length disagree, or when a `$N`
1846
- * index is out of range.
1847
- */
1848
- declare function bindLiterals(sql: string, params: readonly unknown[]): string;
1849
13
  export { type CodecCtx, type ColumnDef, type ColumnType, type CompactionThresholds, type CompactionTier, type ComparisonResult, type CreateInspectionStoreSqliteOptions, DEFAULT_SEARCH_TYPE, type DataSource, type DrizzleSchema, type DuckDBFactory, type DuckDBHandle, type EngineOptions, type ExtraResult, FILES_PLACEHOLDER, type FileSetRef, type GcCtx, type GscApiRow, type IngestOptions, type InspectionSqlDriver, type ListLiveFilter, type LockScope, MAX_DAY_BYTES, type ManifestEntry, type ManifestPurgeResult, type ManifestStore, type ParquetCodec, type PurgeFilter, type PurgeResult, type PurgeUrlsResult, type QueryCtx, type QueryExecuteOptions, type QueryExecuteResult, type QueryExecutor, type QueryResult, type ResolvedQuery, type Row, type RowAccumulator, type RowAccumulatorOptions, type RunSQLOptions, SCHEMAS, type SearchType, type StorageEngine, type SyncState, type SyncStateDetail, type SyncStateFilter, type SyncStateKind, type SyncStateScope, TABLE_METADATA, type TableName, type TableSchema, type TenantCtx, type Watermark, type WatermarkFilter, type WatermarkScope, type WriteCtx, type WriteResult, allTables, bindLiterals, canonicalEmptyParquetSchema, coerceRow, coerceRows, countries, createDuckDBCodec, createDuckDBExecutor, createInspectionStoreSqlite, createRowAccumulator, createStorageEngine, currentSchemaVersion, dayPartition, devices, dimensionToColumn, drizzleSchema, enumeratePartitions, formatLiteral, inferLegacyTier, inferSearchType, inferTable, inspectionSqliteKey, keywords, mondayOfWeek, monthPartition, objectKey, page_keywords, pages, quarterOfMonth, quarterPartition, resolveToSQL, substituteNamedFiles, toPath, toSumPosition, transformGscRow, weekPartition };