eric: comparison eric7/DebugClients/Python/coverage/sqldata.py

-:fb9351497cea
+:0e511e0e94a3
 # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
 # For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
-"""Sqlite coverage data."""
+"""SQLite coverage data."""
-# TODO: factor out dataop debugging to a wrapper class?
-# TODO: make sure all dataop debugging is in place somehow
 import collections
 import datetime
 import functools
 import glob
 import random
 import re
 import socket
 import sqlite3
 import sys
+import textwrap
 import threading
 import zlib
 from coverage.debug import NoDebugging, SimpleReprMixin, clipped_repr
 from coverage.exceptions import CoverageException, DataError
 from coverage.version import __version__
 os = isolate_module(os)
 # If you change the schema, increment the SCHEMA_VERSION, and update the
-# docs in docs/dbschema.rst also.
+# docs in docs/dbschema.rst by running "make cogdoc".
 SCHEMA_VERSION = 7
 # Schema versions:
 # 1: Released in 5.0a2
 if suffix:
 self._filename += "." + suffix
 def _reset(self):
 """Reset our attributes."""
-if self._dbs:
+if not self._no_disk:
 for db in self._dbs.values():
 db.close()
 self._dbs = {}
 self._file_map = {}
 self._have_used = False
 self._current_context_id = None
 def _open_db(self):
 for row in db.execute("select value from meta where key = 'has_arcs'"):
 self._has_arcs = bool(int(row[0]))
 self._has_lines = not self._has_arcs
-for path, file_id in db.execute("select path, id from file"):
+for file_id, path in db.execute("select id, path from file"):
 self._file_map[path] = file_id
 def _init_db(self, db):
 """Write the initial contents of the database."""
 if self._debug.should("dataio"):
 If `add` is not True, return None.
 """
 if filename not in self._file_map:
 if add:
 with self._connect() as con:
-cur = con.execute("insert or replace into file (path) values (?)", (filename,))
+self._file_map[filename] = con.execute_for_rowid(
-self._file_map[filename] = cur.lastrowid
+"insert or replace into file (path) values (?)",
+(filename,)
+)
 return self._file_map.get(filename)
 def _context_id(self, context):
 """Get the id for a context."""
 assert context is not None
 context_id = self._context_id(context)
 if context_id is not None:
 self._current_context_id = context_id
 else:
 with self._connect() as con:
-cur = con.execute("insert into context (context) values (?)", (context,))
+self._current_context_id = con.execute_for_rowid(
-self._current_context_id = cur.lastrowid
+"insert into context (context) values (?)",
+(context,)
+)
 def base_filename(self):
 """The base filename for storing data.
 .. versionadded:: 5.0
 return
 with self._connect() as con:
 self._set_context_id()
 for filename, arcs in arc_data.items():
 file_id = self._file_id(filename, add=True)
-from coverage import env
-if env.PYVERSION == (3, 11, 0, "alpha", 4, 0):
-arcs = [(a, b) for a, b in arcs if a is not None and b is not None]
 data = [(file_id, self._current_context_id, fromno, tono) for fromno, tono in arcs]
 con.executemany(
 "insert or ignore into arc " +
 "(file_id, context_id, fromno, tono) values (?, ?, ?, ?)",
 data,
 # contexts.
 self._start_using()
 # Collector for all arcs, lines and tracers
 other_data.read()
-with other_data._connect() as conn:
+with other_data._connect() as con:
 # Get files data.
-cur = conn.execute("select path from file")
+cur = con.execute("select path from file")
 files = {path: aliases.map(path) for (path,) in cur}
 cur.close()
 # Get contexts data.
-cur = conn.execute("select context from context")
+cur = con.execute("select context from context")
 contexts = [context for (context,) in cur]
 cur.close()
 # Get arc data.
-cur = conn.execute(
+cur = con.execute(
 "select file.path, context.context, arc.fromno, arc.tono " +
 "from arc " +
 "inner join file on file.id = arc.file_id " +
 "inner join context on context.id = arc.context_id"
 )
 arcs = [(files[path], context, fromno, tono) for (path, context, fromno, tono) in cur]
 cur.close()
 # Get line data.
-cur = conn.execute(
+cur = con.execute(
 "select file.path, context.context, line_bits.numbits " +
 "from line_bits " +
 "inner join file on file.id = line_bits.file_id " +
 "inner join context on context.id = line_bits.context_id"
 )
 lines = {(files[path], context): numbits for (path, context, numbits) in cur}
 cur.close()
 # Get tracer data.
-cur = conn.execute(
+cur = con.execute(
 "select file.path, tracer " +
 "from tracer " +
 "inner join file on file.id = tracer.file_id"
 )
 tracers = {files[path]: tracer for (path, tracer) in cur}
 cur.close()
-with self._connect() as conn:
+with self._connect() as con:
-conn.con.isolation_level = "IMMEDIATE"
+con.con.isolation_level = "IMMEDIATE"
 # Get all tracers in the DB. Files not in the tracers are assumed
 # to have an empty string tracer. Since Sqlite does not support
 # full outer joins, we have to make two queries to fill the
 # dictionary.
-this_tracers = {path: "" for path, in conn.execute("select path from file")}
+this_tracers = {path: "" for path, in con.execute("select path from file")}
 this_tracers.update({
 aliases.map(path): tracer
-for path, tracer in conn.execute(
+for path, tracer in con.execute(
 "select file.path, tracer from tracer " +
 "inner join file on file.id = tracer.file_id"
 )
 })
 # Create all file and context rows in the DB.
-conn.executemany(
+con.executemany(
 "insert or ignore into file (path) values (?)",
 ((file,) for file in files.values())
 )
 file_ids = {
 path: id
-for id, path in conn.execute("select id, path from file")
+for id, path in con.execute("select id, path from file")
 }
-conn.executemany(
+self._file_map.update(file_ids)
+con.executemany(
 "insert or ignore into context (context) values (?)",
 ((context,) for context in contexts)
 )
 context_ids = {
 context: id
-for id, context in conn.execute("select id, context from context")
+for id, context in con.execute("select id, context from context")
 }
 # Prepare tracers and fail, if a conflict is found.
 # tracer_paths is used to ensure consistency over the tracer data
 # and tracer_map tracks the tracers to be inserted.
 (file_ids[file], context_ids[context], fromno, tono)
 for file, context, fromno, tono in arcs
 )
 # Get line data.
-cur = conn.execute(
+cur = con.execute(
 "select file.path, context.context, line_bits.numbits " +
 "from line_bits " +
 "inner join file on file.id = line_bits.file_id " +
 "inner join context on context.id = line_bits.context_id"
 )
 for path, context, numbits in cur:
 key = (aliases.map(path), context)
 if key in lines:
 numbits = numbits_union(lines[key], numbits)
 lines[key] = numbits
 if arcs:
 self._choose_lines_or_arcs(arcs=True)
 # Write the combined data.
-conn.executemany(
+con.executemany(
 "insert or ignore into arc " +
 "(file_id, context_id, fromno, tono) values (?, ?, ?, ?)",
 arc_rows
 )
 if lines:
 self._choose_lines_or_arcs(lines=True)
-conn.execute("delete from line_bits")
+con.execute("delete from line_bits")
-conn.executemany(
+con.executemany(
 "insert into line_bits " +
 "(file_id, context_id, numbits) values (?, ?, ?)",
 [
 (file_ids[file], context_ids[context], numbits)
 for (file, context), numbits in lines.items()
 ]
 )
-conn.executemany(
+con.executemany(
 "insert or ignore into tracer (file_id, tracer) values (?, ?)",
 ((file_ids[filename], tracer) for filename, tracer in tracer_map.items())
 )
-# Update all internal cache data.
+if not self._no_disk:
-self._reset()
+# Update all internal cache data.
-self.read()
+self._reset()
+self.read()
 def erase(self, parallel=False):
 """Erase the data in this object.
 If `parallel` is true, then also deletes data files created from the
 self._debug.write(f"Erasing parallel data file {filename!r}")
 file_be_gone(filename)
 def read(self):
 """Start using an existing data file."""
-with self._connect():       # TODO: doesn't look right
+if os.path.exists(self._filename):
-self._have_used = True
+with self._connect():
+self._have_used = True
 def write(self):
 """Ensure the data is written to the data file."""
 pass
 else:
 query = (
 "select l.numbits, c.context from line_bits l, context c " +
 "where l.context_id = c.id " +
 "and file_id = ?"
 )
 data = [file_id]
 if self._query_context_ids is not None:
 ids_array = ", ".join("?" * len(self._query_context_ids))
 query += " and l.context_id in (" + ids_array + ")"
 data += self._query_context_ids
 """
 with SqliteDb(":memory:", debug=NoDebugging()) as db:
 temp_store = [row[0] for row in db.execute("pragma temp_store")]
 copts = [row[0] for row in db.execute("pragma compile_options")]
-# Yes, this is overkill. I don't like the long list of options
+copts = textwrap.wrap(", ".join(copts), width=75)
-# at the end of "debug sys", but I don't want to omit information.
-copts = ["; ".join(copts[i:i + 3]) for i in range(0, len(copts), 3)]
 return [
 ("sqlite3_version", sqlite3.version),
 ("sqlite3_sqlite_version", sqlite3.sqlite_version),
 ("sqlite3_temp_store", temp_store),
 with SqliteDb(filename, debug_control) as db:
 db.execute("insert into schema (version) values (?)", (SCHEMA_VERSION,))
 """
 def __init__(self, filename, debug):
-self.debug = debug if debug.should("sql") else None
+self.debug = debug
 self.filename = filename
 self.nest = 0
 self.con = None
 def _connect(self):
 # It can happen that Python switches threads while the tracer writes
 # data. The second thread will also try to write to the data,
 # effectively causing a nested context. However, given the idempotent
 # nature of the tracer operations, sharing a connection among threads
 # is not a problem.
-if self.debug:
+if self.debug.should("sql"):
 self.debug.write(f"Connecting to {self.filename!r}")
 try:
 self.con = sqlite3.connect(self.filename, check_same_thread=False)
 except sqlite3.Error as exc:
 raise DataError(f"Couldn't use data file {self.filename!r}: {exc}") from exc
 if self.nest == 0:
 try:
 self.con.__exit__(exc_type, exc_value, traceback)
 self.close()
 except Exception as exc:
-if self.debug:
+if self.debug.should("sql"):
 self.debug.write(f"EXCEPTION from __exit__: {exc}")
 raise DataError(f"Couldn't end data file {self.filename!r}: {exc}") from exc
 def execute(self, sql, parameters=()):
 """Same as :meth:`python:sqlite3.Connection.execute`."""
-if self.debug:
+if self.debug.should("sql"):
 tail = f" with {parameters!r}" if parameters else ""
 self.debug.write(f"Executing {sql!r}{tail}")
 try:
 try:
 return self.con.execute(sql, parameters)
 "Looks like a coverage 4.x data file. " +
 "Are you mixing versions of coverage?"
 )
 except Exception:   # pragma: cant happen
 pass
-if self.debug:
+if self.debug.should("sql"):
 self.debug.write(f"EXCEPTION from execute: {msg}")
 raise DataError(f"Couldn't use data file {self.filename!r}: {msg}") from exc
+def execute_for_rowid(self, sql, parameters=()):
+"""Like execute, but returns the lastrowid."""
+con = self.execute(sql, parameters)
+rowid = con.lastrowid
+if self.debug.should("sqldata"):
+self.debug.write(f"Row id result: {rowid!r}")
+return rowid
 def execute_one(self, sql, parameters=()):
 """Execute a statement and return the one row that results.
 This is like execute(sql, parameters).fetchone(), except it is
 else:
 raise AssertionError(f"SQL {sql!r} shouldn't return {len(rows)} rows")
 def executemany(self, sql, data):
 """Same as :meth:`python:sqlite3.Connection.executemany`."""
-if self.debug:
+if self.debug.should("sql"):
 data = list(data)
-self.debug.write(f"Executing many {sql!r} with {len(data)} rows")
+final = ":" if self.debug.should("sqldata") else ""
+self.debug.write(f"Executing many {sql!r} with {len(data)} rows{final}")
+if self.debug.should("sqldata"):
+for i, row in enumerate(data):
+self.debug.write(f"{i:4d}: {row!r}")
 try:
 return self.con.executemany(sql, data)
 except Exception:   # pragma: cant happen
 # In some cases, an error might happen that isn't really an
 # error.  Try again immediately.
 # https://github.com/nedbat/coveragepy/issues/1010
 return self.con.executemany(sql, data)
 def executescript(self, script):
 """Same as :meth:`python:sqlite3.Connection.executescript`."""
-if self.debug:
+if self.debug.should("sql"):
 self.debug.write("Executing script with {} chars: {}".format(
 len(script), clipped_repr(script, 100),
 ))
 self.con.executescript(script)

Mercurial Repositories > eric / file comparison

comparison: eric7/DebugClients/Python/coverage/sqldata.py

eric7/DebugClients/Python/coverage/sqldata.py