nsmcp::AccessRecordStoreSQLite method initialize (protected)

 <instance of nsmcp::AccessRecordStoreSQLite> initialize

Defined in /usr/local/ns/tcl/nsmcp/log-traffic-record-store.tcl

Testcases:

No testcase defined.

Source code:

if {[${:db} scalar {SELECT EXISTS(SELECT 1 FROM main.sqlite_schema WHERE name='state' AND type='table')}] 
    && [:stateGet partitionInterval 0]>0} {
    if {[:stateGet partitionInterval 0]!=${:partitionInterval}} {
        error "record-store-partition-reset-required"
    }
    return
}
# Capacity is an application budget; connection policies belong to the pool.
:pageLimit
${:db} execute {
    CREATE TABLE IF NOT EXISTS main.meta(version INTEGER NOT NULL);
    INSERT INTO main.meta SELECT 1 WHERE NOT EXISTS(SELECT 1 FROM main.meta);
    CREATE TABLE IF NOT EXISTS main.files(
                                                   fid INTEGER PRIMARY KEY AUTOINCREMENT,
                                                   k TEXT UNIQUE NOT NULL,
                                                   identity TEXT NOT NULL,
                                                   prefix TEXT NOT NULL,
                                                   plen INTEGER NOT NULL,
                                                   high INTEGER NOT NULL,
                                                   stamp INTEGER NOT NULL,
                                                   touched INTEGER NOT NULL
                                                   );
    CREATE TABLE IF NOT EXISTS main.scan_counts(
                                                         fid INTEGER NOT NULL,
                                                         lo INTEGER NOT NULL,
                                                         hi INTEGER NOT NULL,
                                                         malformed INTEGER NOT NULL,
                                                         oversized INTEGER NOT NULL,
                                                         skipped INTEGER NOT NULL,
                                                         completed INTEGER NOT NULL,
                                                         PRIMARY KEY(fid,lo)
                                                         );
    CREATE INDEX IF NOT EXISTS main.scan_counts_expiry ON scan_counts(completed);
    CREATE TABLE IF NOT EXISTS main.ranges(
                                                    fid INTEGER NOT NULL,
                                                    lo INTEGER NOT NULL,
                                                    hi INTEGER NOT NULL,
                                                    anchor TEXT NOT NULL,
                                                    PRIMARY KEY(fid,lo)
                                                    );
    CREATE TABLE IF NOT EXISTS main.rows(
                                                  fid INTEGER NOT NULL,
                                                  off INTEGER NOT NULL,
                                                  stop INTEGER NOT NULL,
                                                  kind INTEGER NOT NULL,
                                                  t REAL,
                                                  status INTEGER,
                                                  path TEXT,
                                                  method TEXT,
                                                  pool TEXT,
                                                  source TEXT,
                                                  driver TEXT,
                                                  auth TEXT,
                                                  bytes INTEGER,
                                                  phase INTEGER,
                                                  fallback INTEGER,
                                                  a REAL,
                                                  q REAL,
                                                  f REAL,
                                                  r REAL,
                                                  peer TEXT,
                                                  agent TEXT,
                                                  label TEXT,
                                                  clipped INTEGER,
                                                  redacted INTEGER,
                                                  identifier TEXT,
                                                  score TEXT,
                                                  PRIMARY KEY(fid,off)
                                                  );
    CREATE INDEX IF NOT EXISTS main.by_time ON rows(t);
    CREATE INDEX IF NOT EXISTS main.by_time_status ON rows(t,status,fid,off,kind)
}
set version [${:db} scalar {SELECT version FROM main.meta}]
if {$version ni {1 2 3}} {
    error "record-store-schema-version"
}
set columns {}
foreach row [${:db} execute {SELECT name FROM pragma_table_info('rows','main')}] {
    lappend columns [dict get $row name]
}
if {"completed" ni $columns} {
    ${:db} execute  {ALTER TABLE main.rows ADD COLUMN completed REAL NOT NULL DEFAULT 0}
}
if {"rolled" ni $columns} {
    ${:db} execute  {ALTER TABLE main.rows ADD COLUMN rolled INTEGER NOT NULL DEFAULT 0}
}
set columns {}
foreach row [${:db} execute {SELECT name FROM pragma_table_info('files','main')}] {
    lappend columns [dict get $row name]
}
if {"active" ni $columns} {
    ${:db} execute  {ALTER TABLE main.files ADD COLUMN active INTEGER NOT NULL DEFAULT 1}
}
foreach column {dropping} {
    if {$column ni $columns} {
        ${:db} execute  "ALTER TABLE main.files ADD COLUMN $column INTEGER NOT NULL DEFAULT 0"
    }
}
${:db} execute {
    CREATE TABLE IF NOT EXISTS main.state(key TEXT PRIMARY KEY,value TEXT NOT NULL);
    CREATE TABLE IF NOT EXISTS main.peer_addresses(
                                                            k BLOB PRIMARY KEY,
                                                            address TEXT NOT NULL,
                                                            seen REAL NOT NULL
                                                            );
    CREATE TABLE IF NOT EXISTS main.minutes(
                                                     fid INTEGER NOT NULL,
                                                     slot INTEGER NOT NULL,
                                                     status INTEGER NOT NULL,
                                                     pool TEXT NOT NULL,
                                                     method TEXT NOT NULL,
                                                     source TEXT NOT NULL,
                                                     n INTEGER NOT NULL,
                                                     bytes INTEGER NOT NULL,
                                                     PRIMARY KEY(fid,slot,status,pool,method,source)
                                                     );
    CREATE INDEX IF NOT EXISTS main.minute_time ON minutes(slot,status);
    CREATE INDEX IF NOT EXISTS main.peer_expiry ON peer_addresses(seen);
    CREATE INDEX IF NOT EXISTS main.diagnostic_expiry ON rows(completed) WHERE kind<>0;
    CREATE INDEX IF NOT EXISTS main.correlation ON rows(identifier,t);
    CREATE TABLE IF NOT EXISTS main.evictions(
                                                       id INTEGER PRIMARY KEY,
                                                       dropped_at INTEGER,
                                                       first_time REAL,
                                                       last_time REAL,
                                                       rows INTEGER,
                                                       reason TEXT
                                                       );
    UPDATE main.meta SET version=3
}

XQL Not present:

Generic, PostgreSQL, Oracle