@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.
- package/dist/_chunks/compiler.mjs +288 -0
- package/dist/_chunks/duckdb.d.mts +26 -0
- package/dist/_chunks/engine.mjs +578 -0
- package/dist/_chunks/pg-adapter.mjs +676 -0
- package/dist/_chunks/planner.d.mts +15 -0
- package/dist/_chunks/schema.d.mts +1258 -0
- package/dist/_chunks/schema.mjs +139 -0
- package/dist/_chunks/storage.d.mts +476 -0
- package/dist/_chunks/storage.mjs +39 -0
- package/dist/_chunks/types.d.mts +53 -0
- package/dist/adapters/duckdb-node.d.mts +1 -13
- package/dist/adapters/duckdb-node.mjs +1 -7
- package/dist/adapters/filesystem.d.mts +1 -193
- package/dist/adapters/filesystem.mjs +2 -9
- package/dist/adapters/http.d.mts +1 -193
- package/dist/adapters/http.mjs +1 -5
- package/dist/adapters/hyparquet.d.mts +6 -83
- package/dist/adapters/hyparquet.mjs +1 -105
- package/dist/adapters/inspection-sqlite-browser.d.mts +1 -7
- package/dist/adapters/inspection-sqlite-node.d.mts +1 -7
- package/dist/adapters/inspection-sqlite-node.mjs +1 -1
- package/dist/adapters/node-harness.d.mts +3 -306
- package/dist/adapters/node-harness.mjs +4 -1866
- package/dist/adapters/r2-manifest.d.mts +4 -149
- package/dist/adapters/r2-manifest.mjs +1 -8
- package/dist/adapters/r2.d.mts +1 -47
- package/dist/contracts.d.mts +1 -435
- package/dist/entities.d.mts +1 -47
- package/dist/index.d.mts +8 -1844
- package/dist/index.mjs +8 -1962
- package/dist/ingest.d.mts +1 -1
- package/dist/planner.d.mts +3 -16
- package/dist/planner.mjs +1 -320
- package/dist/resolver/index.d.mts +3 -51
- package/dist/resolver/index.mjs +2 -780
- package/dist/rollups.d.mts +6 -51
- package/dist/rollups.mjs +2 -209
- package/dist/schema.d.mts +2 -1258
- package/dist/schema.mjs +1 -138
- package/package.json +2 -2
package/dist/index.d.mts
CHANGED
|
@@ -1,1849 +1,13 @@
|
|
|
1
|
-
import
|
|
2
|
-
import {
|
|
3
|
-
import {
|
|
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 };
|