signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def set_verbose_logging(verbose: bool) -> None: | if verbose:<EOL><INDENT>set_loglevel(logging.DEBUG)<EOL><DEDENT>else:<EOL><INDENT>set_loglevel(logging.INFO)<EOL><DEDENT> | Chooses basic or verbose logging. | f14623:m0 |
def debug_sql(sql: str, *args: Any) -> None: | log.debug("<STR_LIT>" % sql)<EOL>if args:<EOL><INDENT>log.debug("<STR_LIT>" % args)<EOL><DEDENT> | Writes SQL and arguments to the log. | f14623:m2 |
def delimit(x: str, delims: Tuple[str, str]) -> str: | return delims[<NUM_LIT:0>] + x + delims[<NUM_LIT:1>]<EOL> | Delimits x, using delims[0] (left) and delims[1] (right). | f14623:m3 |
def get_pk_of_last_insert(cursor) -> int: | return cursor.lastrowid<EOL> | Returns the primary key of the last insert performed with the cursor. | f14623:m4 |
def get_sql_select_all_non_pk_fields_by_pk(<EOL>table: str,<EOL>fieldlist: Sequence[str],<EOL>delims: Tuple[str, str] = ("<STR_LIT>", "<STR_LIT>")) -> str: | return (<EOL>"<STR_LIT>" +<EOL>"<STR_LIT:U+002C>".join([delimit(x, delims) for x in fieldlist[<NUM_LIT:1>:]]) +<EOL>"<STR_LIT>" + table +<EOL>"<STR_LIT>" + delimit(fieldlist[<NUM_LIT:0>], delims) + "<STR_LIT>"<EOL>)<EOL> | Returns SQL:
SELECT [all but the first field] WHERE [the first field] = ? | f14623:m5 |
def get_sql_select_all_fields_by_key(<EOL>table: str,<EOL>fieldlist: Sequence[str],<EOL>keyname: str,<EOL>delims: Tuple[str, str] = ("<STR_LIT>", "<STR_LIT>")) -> str: | return (<EOL>"<STR_LIT>" +<EOL>"<STR_LIT:U+002C>".join([delimit(x, delims) for x in fieldlist]) +<EOL>"<STR_LIT>" + delimit(table, delims) +<EOL>"<STR_LIT>" + delimit(keyname, delims) + "<STR_LIT>"<EOL>)<EOL> | Returns SQL:
SELECT [all fields in the fieldlist] WHERE [keyname] = ? | f14623:m6 |
def get_sql_insert(table: str,<EOL>fieldlist: Sequence[str],<EOL>delims: Tuple[str, str] = ("<STR_LIT>", "<STR_LIT>")) -> str: | return (<EOL>"<STR_LIT>" + delimit(table, delims) +<EOL>"<STR_LIT>" +<EOL>"<STR_LIT:U+002C>".join([delimit(x, delims) for x in fieldlist]) +<EOL>"<STR_LIT>" +<EOL>"<STR_LIT:U+002C>".join(["<STR_LIT:?>"] * len(fieldlist)) +<EOL>"<STR_LIT:)>"<EOL>)<EOL> | Returns ?-marked SQL for an INSERT statement. | f14623:m7 |
def get_sql_insert_or_update(table: str,<EOL>fieldlist: Sequence[str],<EOL>delims: Tuple[str, str] = ("<STR_LIT>", "<STR_LIT>")) -> str: | <EOL>return """<STR_LIT>""".format(<EOL>table=delimit(table, delims),<EOL>fields="<STR_LIT:U+002C>".join([delimit(x, delims) for x in fieldlist]),<EOL>placeholders="<STR_LIT:U+002C>".join(["<STR_LIT:?>"] * len(fieldlist)),<EOL>updatelist="<STR_LIT:U+002C>".join(<EOL>["<STR_LIT>".format(field=delimit(x, delims))<EOL>for x in fieldlist]<EOL>),<EOL>)<EOL> | Returns ?-marked SQL for an INSERT-or-if-duplicate-key-UPDATE statement. | f14623:m8 |
def get_sql_insert_without_first_field(<EOL>table: str,<EOL>fieldlist: Sequence[str],<EOL>delims: Tuple[str, str] = ("<STR_LIT>", "<STR_LIT>")) -> str: | return get_sql_insert(table, fieldlist[<NUM_LIT:1>:], delims)<EOL> | Returns ?-marked SQL for an INSERT statement, ignoring the first field
(typically, the PK). | f14623:m9 |
def get_sql_update_by_first_field(table: str,<EOL>fieldlist: Sequence[str],<EOL>delims: Tuple[str, str] = ("<STR_LIT>", "<STR_LIT>")) -> str: | return (<EOL>"<STR_LIT>" + delimit(table, delims) +<EOL>"<STR_LIT>" +<EOL>"<STR_LIT:U+002C>".join([delimit(x, delims) + "<STR_LIT>" for x in fieldlist[<NUM_LIT:1>:]]) +<EOL>"<STR_LIT>" + delimit(fieldlist[<NUM_LIT:0>], delims) + "<STR_LIT>"<EOL>)<EOL> | Returns SQL for an UPDATE statement, to update all fields except the
first field (PK) using the PK as the key. | f14623:m10 |
def sql_quote_string(s: str) -> str: | return "<STR_LIT:'>" + s.replace("<STR_LIT:'>", "<STR_LIT>") + "<STR_LIT:'>"<EOL> | Quotes string, escaping apostrophes by doubling them. | f14623:m11 |
def sql_dequote_string(s: str) -> str: | if len(s) < <NUM_LIT:2>:<EOL><INDENT>return s<EOL><DEDENT>s = s[<NUM_LIT:1>:-<NUM_LIT:1>] <EOL>return s.replace("<STR_LIT>", "<STR_LIT:'>")<EOL> | Reverses sql_quote_string. | f14623:m12 |
def datetime2literal_rnc(d: datetime.datetime, c: Optional[Dict]) -> str: | <EOL>dt = d.isoformat("<STR_LIT:U+0020>")<EOL>return _mysql.string_literal(dt, c)<EOL> | Format a DateTime object as something MySQL will actually accept. | f14623:m13 |
def full_datatype_to_mysql(d: str) -> str: | d = d.upper()<EOL>(s, length) = split_long_sqltype(d)<EOL>if d in ["<STR_LIT>", "<STR_LIT>"]:<EOL><INDENT>return "<STR_LIT>"<EOL><DEDENT>elif d in ["<STR_LIT>"] or s in ["<STR_LIT>"]:<EOL><INDENT>return "<STR_LIT>"<EOL><DEDENT>else:<EOL><INDENT>return d<EOL><DEDENT> | Converts a full datatype, e.g. INT, VARCHAR(10), VARCHAR(MAX), to a
MySQL equivalent. | f14623:m14 |
def debug_object(obj: T) -> str: | pairs = []<EOL>for k, v in vars(obj).items():<EOL><INDENT>pairs.append(u"<STR_LIT>".format(k, v))<EOL><DEDENT>return u"<STR_LIT:U+002CU+0020>".join(pairs)<EOL> | Prints key/value pairs for an object's dictionary. | f14623:m15 |
def dump_database_object(obj: T, fieldlist: Iterable[str]) -> None: | log.info(_LINE_EQUALS)<EOL>log.info("<STR_LIT>", obj)<EOL>for f in fieldlist:<EOL><INDENT>log.info(u"<STR_LIT>", f=f, v=getattr(obj, f))<EOL><DEDENT>log.info(_LINE_EQUALS)<EOL> | Prints key/value pairs for an object's dictionary. | f14623:m16 |
def assign_from_list(obj: T,<EOL>fieldlist: Sequence[str],<EOL>valuelist: Sequence[any]) -> None: | if len(fieldlist) != len(valuelist):<EOL><INDENT>raise AssertionError("<STR_LIT>"<EOL>"<STR_LIT>")<EOL><DEDENT>for i in range(len(valuelist)):<EOL><INDENT>setattr(obj, fieldlist[i], valuelist[i])<EOL><DEDENT> | Within "obj", assigns the values from the value list to the fields in
the fieldlist. | f14623:m17 |
def create_object_from_list(cls: Type,<EOL>fieldlist: Sequence[str],<EOL>valuelist: Sequence[Any],<EOL>*args, **kwargs) -> T: | construct_with_pk = kwargs.pop('<STR_LIT>', False)<EOL>if construct_with_pk:<EOL><INDENT>obj = cls(valuelist[<NUM_LIT:0>], *args, **kwargs)<EOL>assign_from_list(obj, fieldlist[<NUM_LIT:1>:], valuelist[<NUM_LIT:1>:])<EOL><DEDENT>else:<EOL><INDENT>obj = cls(*args, **kwargs)<EOL>assign_from_list(obj, fieldlist, valuelist)<EOL><DEDENT>return obj<EOL> | Create an object by instantiating ``cls(*args, **kwargs)`` and assigning the
values in ``valuelist`` to the fields in ``fieldlist``.
If ``construct_with_pk`` is ``True``, initialize with
``cls(valuelist[0], *args, **kwargs)``
and assign the values in ``valuelist[1:]`` to ``fieldlist[1:]``.
Note: in Python 3, we could define as
.. code-block:: none
...(... valuelist, *args, construct_with_pk=False, **kwargs):
but not in Python 2, and this is meant to be back-compatible. | f14623:m18 |
def blank_object(obj: T, fieldlist: Sequence[str]) -> None: | for f in fieldlist:<EOL><INDENT>setattr(obj, f, None)<EOL><DEDENT> | Within "obj", sets all fields in the fieldlist to None. | f14623:m19 |
def debug_query_result(rows: Sequence[Any]) -> None: | log.info("<STR_LIT>", len(rows))<EOL>for i in range(len(rows)):<EOL><INDENT>log.info("<STR_LIT>", i, rows[i])<EOL><DEDENT> | Writes a query result to the log. | f14623:m20 |
def create_database_mysql(database: str,<EOL>user: str,<EOL>password: str,<EOL>server: str = "<STR_LIT:localhost>",<EOL>port: int = <NUM_LIT>,<EOL>charset: str = "<STR_LIT:utf8>",<EOL>collate: str = "<STR_LIT>",<EOL>use_unicode: bool = True) -> bool: | con = mysql.connect(<EOL>host=server,<EOL>port=port,<EOL>user=user,<EOL>passwd=password,<EOL>charset=charset,<EOL>use_unicode=use_unicode<EOL>)<EOL>sql = ("<STR_LIT>"<EOL>"<STR_LIT>").format(<EOL>database,<EOL>charset,<EOL>collate<EOL>)<EOL>cursor = con.cursor()<EOL>debug_sql(sql)<EOL>cursor.execute(sql)<EOL>log.info("<STR_LIT>", database)<EOL>return True<EOL> | Connects via PyMySQL/MySQLdb and creates a database. | f14623:m41 |
def add_master_user_mysql(database: str,<EOL>root_user: str,<EOL>root_password: str,<EOL>new_user: str,<EOL>new_password: str,<EOL>server: str = "<STR_LIT:localhost>",<EOL>port: int = <NUM_LIT>,<EOL>charset: str = "<STR_LIT:utf8>",<EOL>use_unicode: bool = True,<EOL>localhost_only: bool = True) -> None: | con = mysql.connect(<EOL>host=server,<EOL>port=port,<EOL>user=root_user,<EOL>passwd=root_password,<EOL>charset=charset,<EOL>use_unicode=use_unicode<EOL>)<EOL>wherefrom = "<STR_LIT:localhost>" if localhost_only else "<STR_LIT:%>"<EOL>sql = ("<STR_LIT>"<EOL>"<STR_LIT>").format(<EOL>database,<EOL>new_user,<EOL>wherefrom,<EOL>new_password<EOL>)<EOL>cursor = con.cursor()<EOL>debug_sql(sql)<EOL>cursor.execute(sql)<EOL>log.info("<STR_LIT>", new_user, database)<EOL> | Connects via PyMySQL/MySQLdb and creates a database superuser. | f14623:m42 |
@classmethod<EOL><INDENT>def get_all_table_names(cls, db: DATABASE_SUPPORTER_FWD_REF) -> List[str]:<DEDENT> | raise RuntimeError(_MSG_NO_FLAVOUR)<EOL> | Returns all table names in the database. | f14623:c0:m5 |
@classmethod<EOL><INDENT>def get_all_table_details(cls, db: DATABASE_SUPPORTER_FWD_REF)-> List[List[Any]]:<DEDENT> | raise RuntimeError(_MSG_NO_FLAVOUR)<EOL> | Returns all information the database has on a table. | f14623:c0:m6 |
@classmethod<EOL><INDENT>def describe_table(cls,<EOL>db: DATABASE_SUPPORTER_FWD_REF,<EOL>table: str) -> List[List[Any]]:<DEDENT> | raise RuntimeError(_MSG_NO_FLAVOUR)<EOL> | Returns details on a specific table. | f14623:c0:m7 |
@classmethod<EOL><INDENT>def fetch_column_names(cls,<EOL>db: DATABASE_SUPPORTER_FWD_REF,<EOL>table: str) -> List[str]:<DEDENT> | raise RuntimeError(_MSG_NO_FLAVOUR)<EOL> | Returns all column names for a table. | f14623:c0:m8 |
@classmethod<EOL><INDENT>def get_datatype(cls,<EOL>db: DATABASE_SUPPORTER_FWD_REF,<EOL>table: str,<EOL>column: str) -> str:<DEDENT> | raise RuntimeError(_MSG_NO_FLAVOUR)<EOL> | Returns database SQL datatype for a column: e.g. VARCHAR. | f14623:c0:m9 |
@classmethod<EOL><INDENT>def get_column_type(cls,<EOL>db: DATABASE_SUPPORTER_FWD_REF,<EOL>table: str,<EOL>column: str) -> str:<DEDENT> | raise RuntimeError(_MSG_NO_FLAVOUR)<EOL> | Returns database SQL datatype for a column, e.g. VARCHAR(50). | f14623:c0:m10 |
@classmethod<EOL><INDENT>def get_comment(cls,<EOL>db: DATABASE_SUPPORTER_FWD_REF,<EOL>table: str,<EOL>column: str) -> str:<DEDENT> | return '<STR_LIT>'<EOL> | Returns database SQL comment for a column. | f14623:c0:m11 |
@classmethod<EOL><INDENT>def get_system_variable(cls,<EOL>db: DATABASE_SUPPORTER_FWD_REF,<EOL>varname: str) -> Any:<DEDENT> | return None<EOL> | Returns a database system variable. | f14623:c0:m12 |
@classmethod<EOL><INDENT>def is_read_only(cls,<EOL>db: DATABASE_SUPPORTER_FWD_REF,<EOL>logger: logging.Logger = None) -> bool:<DEDENT> | def convert_enums(row_):<EOL><INDENT>return [True if x == '<STR_LIT:Y>' else (False if x == '<STR_LIT:N>' else None)<EOL>for x in row_]<EOL><DEDENT>try:<EOL><INDENT>sql = """<STR_LIT>"""<EOL>rows = db.fetchall(sql)<EOL>for row in rows:<EOL><INDENT>dbname = row[<NUM_LIT:0>]<EOL>prohibited = convert_enums(row[<NUM_LIT:1>:])<EOL>if any(prohibited):<EOL><INDENT>if logger:<EOL><INDENT>logger.debug(<EOL>"<STR_LIT>"<EOL>"<STR_LIT>".format(<EOL>dbname, prohibited<EOL>)<EOL>)<EOL><DEDENT>return False<EOL><DEDENT><DEDENT><DEDENT>except mysql.OperationalError:<EOL><INDENT>pass<EOL><DEDENT>try:<EOL><INDENT>sql = """<STR_LIT>"""<EOL>rows = db.fetchall(sql)<EOL>if not rows or len(rows) > <NUM_LIT:1>:<EOL><INDENT>return False<EOL><DEDENT>prohibited = convert_enums(rows[<NUM_LIT:0>])<EOL>if any(prohibited):<EOL><INDENT>if logger:<EOL><INDENT>logger.debug(<EOL>"<STR_LIT>"<EOL>"<STR_LIT>".format(prohibited))<EOL><DEDENT>return False<EOL><DEDENT><DEDENT>except mysql.OperationalError:<EOL><INDENT>pass<EOL><DEDENT>return True<EOL> | Do we have read-only access? | f14623:c2:m19 |
def connect(self,<EOL>engine: str = None,<EOL>interface: str = None,<EOL>host: str = None,<EOL>port: int = None,<EOL>database: str = None,<EOL>driver: str = None,<EOL>dsn: str = None,<EOL>odbc_connection_string: str = None,<EOL>user: str = None,<EOL>password: str = None,<EOL>autocommit: bool = True,<EOL>charset: str = "<STR_LIT:utf8>",<EOL>use_unicode: bool = True) -> bool: | <EOL>try:<EOL><INDENT>return self._connect(<EOL>engine=engine, interface=interface,<EOL>host=host, port=port, database=database,<EOL>driver=driver, dsn=dsn,<EOL>odbc_connection_string=odbc_connection_string,<EOL>user=user, password=password,<EOL>autocommit=autocommit, charset=charset,<EOL>use_unicode=use_unicode)<EOL><DEDENT>except Exception as e:<EOL><INDENT>self.reraise_connection_exception(e)<EOL><DEDENT> | engine: access, mysql, sqlserver
interface: mysql, odbc, jdbc | f14623:c6:m2 |
def ping(self) -> None: | if self.db is None or self.db_pythonlib not in [PYTHONLIB_MYSQLDB,<EOL>PYTHONLIB_PYMYSQL]:<EOL><INDENT>return<EOL><DEDENT>try:<EOL><INDENT>self.db.ping(True) <EOL><DEDENT>except mysql.OperationalError: <EOL><INDENT>self.db = None<EOL>self.connect_to_database_mysql(<EOL>self._database, self._user, self._password, self._server,<EOL>self._port, self._charset, self._use_unicode)<EOL><DEDENT> | Pings a database connection, reconnecting if necessary. | f14623:c6:m5 |
def connect_to_database_odbc_mysql(self,<EOL>database: str,<EOL>user: str,<EOL>password: str,<EOL>server: str = "<STR_LIT:localhost>",<EOL>port: int = <NUM_LIT>,<EOL>driver: str = "<STR_LIT>",<EOL>autocommit: bool = True) -> None: | self.connect(engine=ENGINE_MYSQL, interface=INTERFACE_ODBC,<EOL>database=database, user=user, password=password,<EOL>host=server, port=port, driver=driver,<EOL>autocommit=autocommit)<EOL> | Connects to a MySQL database via ODBC. | f14623:c6:m7 |
def connect_to_database_odbc_sqlserver(self,<EOL>odbc_connection_string: str = None,<EOL>dsn: str = None,<EOL>database: str = None,<EOL>user: str = None,<EOL>password: str = None,<EOL>server: str = "<STR_LIT:localhost>",<EOL>driver: str = "<STR_LIT>",<EOL>autocommit: bool = True) -> None: | self.connect(engine=ENGINE_SQLSERVER, interface=INTERFACE_ODBC,<EOL>odbc_connection_string=odbc_connection_string,<EOL>dsn=dsn,<EOL>database=database, user=user, password=password,<EOL>host=server, driver=driver,<EOL>autocommit=autocommit)<EOL> | Connects to an SQL Server database via ODBC. | f14623:c6:m8 |
def connect_to_database_odbc_access(self,<EOL>dsn: str,<EOL>autocommit: bool = True) -> None: | self.connect(engine=ENGINE_ACCESS, interface=INTERFACE_ODBC,<EOL>dsn=dsn, autocommit=autocommit)<EOL> | Connects to an Access database via ODBC, with the DSN
prespecified. | f14623:c6:m9 |
def delimit(self, x: str) -> str: | return delimit(x, self.get_delims())<EOL> | Delimits e.g. a fieldname. | f14623:c6:m13 |
def localize_sql(self, sql: str) -> str: | <EOL>if self.db_pythonlib in [PYTHONLIB_PYMYSQL, PYTHONLIB_MYSQLDB]:<EOL><INDENT>sql = _PERCENT_REGEX.sub("<STR_LIT>", sql)<EOL>sql = _QUERY_VALUE_REGEX.sub("<STR_LIT:%s>", sql)<EOL><DEDENT>return sql<EOL> | Translates ?-placeholder SQL to appropriate dialect.
For example, MySQLdb uses %s rather than ?. | f14623:c6:m14 |
def is_open(self) -> bool: | return self.db is not None<EOL> | Is the database open? | f14623:c6:m15 |
def ensure_db_open(self) -> None: | if self.db is None:<EOL><INDENT>raise NoDatabaseError("<STR_LIT>")<EOL><DEDENT> | Raise NoDatabaseError if the database isn't open. | f14623:c6:m16 |
def cursor(self): | self.ensure_db_open()<EOL>return self.db.cursor()<EOL> | Returns database cursor, or raises NoDatabaseError. | f14623:c6:m17 |
def commit(self) -> None: | self.ensure_db_open()<EOL>self.db.commit()<EOL>log.debug("<STR_LIT>")<EOL> | Commits the transaction. | f14623:c6:m18 |
def rollback(self) -> None: | self.ensure_db_open()<EOL>self.db.rollback()<EOL>log.debug("<STR_LIT>")<EOL> | Rolls back the transaction. | f14623:c6:m19 |
def insert_record(self,<EOL>table: str,<EOL>fields: Sequence[str],<EOL>values: Sequence[Any],<EOL>update_on_duplicate_key: bool = False) -> int: | self.ensure_db_open()<EOL>if len(fields) != len(values):<EOL><INDENT>raise AssertionError("<STR_LIT>")<EOL><DEDENT>if update_on_duplicate_key:<EOL><INDENT>sql = get_sql_insert_or_update(table, fields, self.get_delims())<EOL><DEDENT>else:<EOL><INDENT>sql = get_sql_insert(table, fields, self.get_delims())<EOL><DEDENT>sql = self.localize_sql(sql)<EOL>log.debug("<STR_LIT>" + sql)<EOL>try:<EOL><INDENT>cursor = self.db.cursor()<EOL>debug_sql(sql, values)<EOL>cursor.execute(sql, values)<EOL>new_pk = get_pk_of_last_insert(cursor)<EOL>log.debug("<STR_LIT>")<EOL>return new_pk<EOL><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>")<EOL>raise<EOL><DEDENT> | Inserts a record into database, table "table", using the list of
fieldnames and the list of values. Returns the new PK (or None). | f14623:c6:m20 |
def insert_record_by_fieldspecs_with_values(<EOL>self,<EOL>table: str,<EOL>fieldspeclist: FIELDSPECLIST_TYPE) -> int: | fields = []<EOL>values = []<EOL>for fs in fieldspeclist:<EOL><INDENT>fields.append(fs["<STR_LIT:name>"])<EOL>values.append(fs["<STR_LIT:value>"])<EOL><DEDENT>return self.insert_record(table, fields, values)<EOL> | Inserts a record into the database using a list of fieldspecs having
their value stored under the 'value' key. | f14623:c6:m21 |
def insert_record_by_dict(self,<EOL>table: str,<EOL>valuedict: Dict[str, Any]) -> Optional[int]: | if not valuedict:<EOL><INDENT>return None<EOL><DEDENT>n = len(valuedict)<EOL>fields = []<EOL>args = []<EOL>for f, v in valuedict.items():<EOL><INDENT>fields.append(self.delimit(f))<EOL>args.append(v)<EOL><DEDENT>query = """<STR_LIT>""".format(<EOL>table=table,<EOL>fields="<STR_LIT:U+002C>".join(fields),<EOL>placeholders="<STR_LIT:U+002C>".join(["<STR_LIT:?>"]*n)<EOL>)<EOL>query = self.localize_sql(query)<EOL>log.debug("<STR_LIT>" + query)<EOL>try:<EOL><INDENT>cursor = self.db.cursor()<EOL>debug_sql(query, args)<EOL>cursor.execute(query, args)<EOL>new_pk = get_pk_of_last_insert(cursor)<EOL>log.debug("<STR_LIT>")<EOL>return new_pk<EOL><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>")<EOL>raise<EOL><DEDENT> | Inserts a record into database, table "table", using a dictionary
containing field/value mappings. Returns the new PK (or None). | f14623:c6:m22 |
def insert_multiple_records(self,<EOL>table: str,<EOL>fields: Sequence[str],<EOL>records: Sequence[Sequence[Any]]) -> int: | self.ensure_db_open()<EOL>sql = self.localize_sql(get_sql_insert(table, fields,<EOL>self.get_delims()))<EOL>log.debug("<STR_LIT>" + sql)<EOL>try:<EOL><INDENT>cursor = self.db.cursor()<EOL>debug_sql(sql, records)<EOL>cursor.executemany(sql, records)<EOL>log.debug("<STR_LIT>")<EOL>return cursor.rowcount<EOL><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>")<EOL>raise<EOL><DEDENT> | Inserts a record into database, table "table", using the list of
fieldnames and the list of records (each a list of values).
Returns number of rows affected. | f14623:c6:m23 |
def db_exec_with_cursor(self, cursor, sql: str, *args) -> int: | sql = self.localize_sql(sql)<EOL>try:<EOL><INDENT>debug_sql(sql, args)<EOL>cursor.execute(sql, args)<EOL>return cursor.rowcount<EOL><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>" + sql)<EOL>raise<EOL><DEDENT> | Executes SQL on a supplied cursor, with "?" placeholders,
substituting in the arguments. Returns number of rows affected. | f14623:c6:m24 |
def db_exec(self, sql: str, *args) -> int: | self.ensure_db_open()<EOL>cursor = self.db.cursor()<EOL>return self.db_exec_with_cursor(cursor, sql, *args)<EOL> | Executes SQL (with "?" placeholders for arguments). | f14623:c6:m25 |
def db_exec_and_commit(self, sql: str, *args) -> int: | rowcount = self.db_exec(sql, *args)<EOL>self.commit()<EOL>return rowcount<EOL> | Execute SQL and commit. | f14623:c6:m26 |
def db_exec_literal(self, sql: str) -> int: | self.ensure_db_open()<EOL>cursor = self.db.cursor()<EOL>debug_sql(sql)<EOL>try:<EOL><INDENT>cursor.execute(sql)<EOL>return cursor.rowcount<EOL><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>" + sql)<EOL>raise<EOL><DEDENT> | Executes SQL without modification. Returns rowcount. | f14623:c6:m27 |
def fetchvalue(self, sql: str, *args) -> Optional[Any]: | row = self.fetchone(sql, *args)<EOL>if row is None:<EOL><INDENT>return None<EOL><DEDENT>return row[<NUM_LIT:0>]<EOL> | Executes SQL; returns the first value of the first row, or None. | f14623:c6:m29 |
def fetchone(self, sql: str, *args) -> Optional[Sequence[Any]]: | self.ensure_db_open()<EOL>cursor = self.db.cursor()<EOL>self.db_exec_with_cursor(cursor, sql, *args)<EOL>try:<EOL><INDENT>return cursor.fetchone()<EOL><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>" + sql)<EOL>raise<EOL><DEDENT> | Executes SQL; returns the first row, or None. | f14623:c6:m30 |
def fetchall(self, sql: str, *args) -> Sequence[Sequence[Any]]: | self.ensure_db_open()<EOL>cursor = self.db.cursor()<EOL>self.db_exec_with_cursor(cursor, sql, *args)<EOL>try:<EOL><INDENT>rows = cursor.fetchall()<EOL>return rows<EOL><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>" + sql)<EOL>raise<EOL><DEDENT> | Executes SQL; returns all rows, or []. | f14623:c6:m31 |
def gen_fetchall(self, sql: str, *args) -> Iterator[Sequence[Any]]: | self.ensure_db_open()<EOL>cursor = self.db.cursor()<EOL>self.db_exec_with_cursor(cursor, sql, *args)<EOL>try:<EOL><INDENT>row = cursor.fetchone()<EOL>while row is not None:<EOL><INDENT>yield row<EOL>row = cursor.fetchone()<EOL><DEDENT><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>" + sql)<EOL>raise<EOL><DEDENT> | fetchall() as a generator. | f14623:c6:m32 |
def gen_fetchfirst(self, sql: str, *args) -> Iterator[Any]: | self.ensure_db_open()<EOL>cursor = self.db.cursor()<EOL>self.db_exec_with_cursor(cursor, sql, *args)<EOL>try:<EOL><INDENT>row = cursor.fetchone()<EOL>while row is not None:<EOL><INDENT>yield row[<NUM_LIT:0>]<EOL>row = cursor.fetchone()<EOL><DEDENT><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>" + sql)<EOL>raise<EOL><DEDENT> | fetch first values, as a generator. | f14623:c6:m33 |
def fetchall_with_fieldnames(self, sql: str, *args)-> Tuple[Sequence[Sequence[Any]], Sequence[str]]: | self.ensure_db_open()<EOL>cursor = self.db.cursor()<EOL>self.db_exec_with_cursor(cursor, sql, *args)<EOL>try:<EOL><INDENT>rows = cursor.fetchall()<EOL>fieldnames = [i[<NUM_LIT:0>] for i in cursor.description]<EOL>return rows, fieldnames<EOL><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>" + sql)<EOL>raise<EOL><DEDENT> | Executes SQL; returns (rows, fieldnames). | f14623:c6:m34 |
def fetchall_as_dictlist(self, sql: str, *args) -> List[Dict[str, Any]]: | self.ensure_db_open()<EOL>cursor = self.db.cursor()<EOL>self.db_exec_with_cursor(cursor, sql, *args)<EOL>try:<EOL><INDENT>rows = cursor.fetchall()<EOL>fieldnames = [i[<NUM_LIT:0>] for i in cursor.description]<EOL>dictlist = []<EOL>for r in rows:<EOL><INDENT>dictlist.append(dict(zip(fieldnames, r)))<EOL><DEDENT>return dictlist<EOL><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>" + sql)<EOL>raise<EOL><DEDENT> | Executes SQL; returns list of dictionaries, where each dict contains
fieldname/value pairs. | f14623:c6:m35 |
def fetchallfirstvalues(self, sql: str, *args) -> List[Any]: | rows = self.fetchall(sql, *args)<EOL>return [row[<NUM_LIT:0>] for row in rows]<EOL> | Executes SQL; returns list of first values of each row. | f14623:c6:m36 |
def fetch_fieldnames(self, sql: str, *args) -> List[str]: | self.ensure_db_open()<EOL>cursor = self.db.cursor()<EOL>self.db_exec_with_cursor(cursor, sql, *args)<EOL>try:<EOL><INDENT>return [i[<NUM_LIT:0>] for i in cursor.description]<EOL><DEDENT>except: <EOL><INDENT>log.exception("<STR_LIT>" + sql)<EOL>raise<EOL><DEDENT> | Executes SQL; returns just the output fieldnames. | f14623:c6:m37 |
def count_where(self, table: str, wheredict: Dict[str, Any] = None) -> int: | sql = "<STR_LIT>" + self.delimit(table)<EOL>if wheredict is not None:<EOL><INDENT>sql += "<STR_LIT>" + "<STR_LIT>".join([<EOL>self.delimit(k) + "<STR_LIT>"<EOL>for k in wheredict.keys()<EOL>])<EOL>whereargs = wheredict.values()<EOL>count = self.fetchone(sql, *whereargs)[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>count = self.fetchone(sql)[<NUM_LIT:0>]<EOL><DEDENT>return count<EOL> | Counts rows in a table, given a set of WHERE criteria (ANDed),
returning a count. | f14623:c6:m38 |
def does_row_exist(self, table: str, field: str, value: Any) -> bool: | sql = ("<STR_LIT>" + self.delimit(table) +<EOL>"<STR_LIT>" + self.delimit(field) + "<STR_LIT>")<EOL>row = self.fetchone(sql, value)<EOL>return True if row[<NUM_LIT:0>] >= <NUM_LIT:1> else False<EOL> | Checks for the existence of a record by a single field (typically a
PK). | f14623:c6:m39 |
def delete_by_field(self, table: str, field: str, value: Any) -> int: | sql = ("<STR_LIT>" + self.delimit(table) +<EOL>"<STR_LIT>" + self.delimit(field) + "<STR_LIT>")<EOL>return self.db_exec(sql, value)<EOL> | Deletes all records where "field" is "value". | f14623:c6:m40 |
def fetch_object_from_db_by_pk(self,<EOL>obj: Any,<EOL>table: str,<EOL>fieldlist: Sequence[str],<EOL>pkvalue: Any) -> bool: | if pkvalue is None:<EOL><INDENT>blank_object(obj, fieldlist)<EOL>return False<EOL><DEDENT>row = self.fetchone(<EOL>get_sql_select_all_non_pk_fields_by_pk(table, fieldlist,<EOL>self.get_delims()),<EOL>pkvalue<EOL>)<EOL>if row is None:<EOL><INDENT>blank_object(obj, fieldlist)<EOL>return False<EOL><DEDENT>setattr(obj, fieldlist[<NUM_LIT:0>], pkvalue) <EOL>assign_from_list(obj, fieldlist[<NUM_LIT:1>:], row) <EOL>return True<EOL> | Fetches object from database table by PK value. Writes back to
object. Returns True/False for success/failure. | f14623:c6:m41 |
def fetch_object_from_db_by_other_field(self,<EOL>obj: Any,<EOL>table: str,<EOL>fieldlist: Sequence[str],<EOL>keyname: str,<EOL>keyvalue: Any) -> bool: | row = self.fetchone(<EOL>get_sql_select_all_fields_by_key(table, fieldlist, keyname,<EOL>self.get_delims()),<EOL>keyvalue<EOL>)<EOL>if row is None:<EOL><INDENT>blank_object(obj, fieldlist)<EOL>return False<EOL><DEDENT>assign_from_list(obj, fieldlist, row)<EOL>return True<EOL> | Fetches object from database table by a field specified by
keyname/keyvalue. Writes back to object. Returns True/False for
success/failure. | f14623:c6:m42 |
def fetch_all_objects_from_db(self,<EOL>cls: Type[T],<EOL>table: str,<EOL>fieldlist: Sequence[str],<EOL>construct_with_pk: bool,<EOL>*args) -> List[T]: | return self.fetch_all_objects_from_db_where(<EOL>cls, table, fieldlist, construct_with_pk, None, *args)<EOL> | Fetches all objects from a table, returning an array of objects of
class cls. | f14623:c6:m43 |
def fetch_all_objects_from_db_by_pklist(self,<EOL>cls: Type,<EOL>table: str,<EOL>fieldlist: Sequence[str],<EOL>pklist: Sequence[Any],<EOL>construct_with_pk: bool,<EOL>*args) -> List[T]: | objarray = []<EOL>for pk in pklist:<EOL><INDENT>if construct_with_pk:<EOL><INDENT>obj = cls(pk, *args) <EOL><DEDENT>else:<EOL><INDENT>obj = cls(*args)<EOL>self.fetch_object_from_db_by_pk(obj, table, fieldlist, pk)<EOL><DEDENT>objarray.append(obj)<EOL><DEDENT>return objarray<EOL> | Fetches all objects from a table, given a list of PKs. | f14623:c6:m44 |
def fetch_all_objects_from_db_where(self,<EOL>cls: Type[T],<EOL>table: str,<EOL>fieldlist: Sequence[str],<EOL>construct_with_pk: bool,<EOL>wheredict: Optional[Dict[str, Any]],<EOL>*args) -> List[T]: | sql = (<EOL>"<STR_LIT>" + "<STR_LIT:U+002C>".join([self.delimit(x) for x in fieldlist]) +<EOL>"<STR_LIT>" + self.delimit(table)<EOL>)<EOL>whereargs = []<EOL>if wheredict is not None:<EOL><INDENT>sql += "<STR_LIT>" + "<STR_LIT>".join([<EOL>self.delimit(k) + "<STR_LIT>"<EOL>for k in wheredict.keys()<EOL>])<EOL>whereargs = wheredict.values()<EOL><DEDENT>rows = self.fetchall(sql, *whereargs)<EOL>objects = []<EOL>for row in rows:<EOL><INDENT>objects.append(<EOL>create_object_from_list(cls, fieldlist, row, *args,<EOL>construct_with_pk=construct_with_pk))<EOL><DEDENT>return objects<EOL> | Fetches all objects from a table, given a set of WHERE criteria
(ANDed), returning an array of objects of class cls.
As usual here, the first field in the fieldlist must be the PK. | f14623:c6:m45 |
def insert_object_into_db_pk_known(self,<EOL>obj: Any,<EOL>table: str,<EOL>fieldlist: Sequence[str]) -> None: | pkvalue = getattr(obj, fieldlist[<NUM_LIT:0>])<EOL>if pkvalue is None:<EOL><INDENT>raise AssertionError("<STR_LIT>"<EOL>"<STR_LIT>")<EOL><DEDENT>valuelist = []<EOL>for f in fieldlist:<EOL><INDENT>valuelist.append(getattr(obj, f))<EOL><DEDENT>self.db_exec(<EOL>get_sql_insert(table, fieldlist, self.get_delims()),<EOL>*valuelist<EOL>)<EOL> | Inserts object into database table, with PK (first field) already
known. | f14623:c6:m46 |
def insert_object_into_db_pk_unknown(self,<EOL>obj: Any,<EOL>table: str,<EOL>fieldlist: Sequence[str]) -> None: | self.ensure_db_open()<EOL>valuelist = []<EOL>for f in fieldlist[<NUM_LIT:1>:]:<EOL><INDENT>valuelist.append(getattr(obj, f))<EOL><DEDENT>cursor = self.db.cursor()<EOL>self.db_exec_with_cursor(<EOL>cursor,<EOL>get_sql_insert_without_first_field(table, fieldlist,<EOL>self.get_delims()),<EOL>*valuelist<EOL>)<EOL>pkvalue = get_pk_of_last_insert(cursor)<EOL>setattr(obj, fieldlist[<NUM_LIT:0>], pkvalue)<EOL> | Inserts object into database table, with PK (first field) initially
unknown (and subsequently set in the object from the database). | f14623:c6:m47 |
def update_object_in_db(self,<EOL>obj: Any,<EOL>table: str,<EOL>fieldlist: Sequence[str]) -> None: | self.ensure_db_open()<EOL>pkvalue = getattr(obj, fieldlist[<NUM_LIT:0>])<EOL>valuelist = []<EOL>for f in fieldlist[<NUM_LIT:1>:]:<EOL><INDENT>valuelist.append(getattr(obj, f))<EOL><DEDENT>valuelist.append(pkvalue)<EOL>cursor = self.db.cursor()<EOL>self.db_exec_with_cursor(<EOL>cursor,<EOL>get_sql_update_by_first_field(table, fieldlist, self.get_delims()),<EOL>*valuelist<EOL>)<EOL> | Updates an object in the database (saves it to the database, where
it exists there already). | f14623:c6:m48 |
def save_object_to_db(self,<EOL>obj: Any,<EOL>table: str,<EOL>fieldlist: Sequence[str],<EOL>is_new_record: bool) -> None: | if is_new_record:<EOL><INDENT>pkvalue = getattr(obj, fieldlist[<NUM_LIT:0>])<EOL>if pkvalue is None:<EOL><INDENT>self.insert_object_into_db_pk_unknown(obj, table, fieldlist)<EOL><DEDENT>else:<EOL><INDENT>self.insert_object_into_db_pk_known(obj, table, fieldlist)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>self.update_object_in_db(obj, table, fieldlist)<EOL><DEDENT> | Saves a object to the database, inserting or updating as
necessary. | f14623:c6:m49 |
def index_exists(self, table: str, indexname: str) -> bool: | <EOL>sql = ("<STR_LIT>"<EOL>"<STR_LIT>")<EOL>row = self.fetchone(sql, table, indexname)<EOL>return True if row[<NUM_LIT:0>] >= <NUM_LIT:1> else False<EOL> | Does an index exist? (Specific to MySQL.) | f14623:c6:m50 |
def create_index(self,<EOL>table: str,<EOL>field: str,<EOL>nchars: int = None,<EOL>indexname: str = None,<EOL>unique: bool = False) -> Optional[int]: | limit = "<STR_LIT>"<EOL>if nchars is not None:<EOL><INDENT>limit = "<STR_LIT>".format(nchars)<EOL><DEDENT>if indexname is None:<EOL><INDENT>indexname = "<STR_LIT>".format(field)<EOL><DEDENT>if self.index_exists(table, indexname):<EOL><INDENT>return None<EOL><DEDENT>uniquestr = "<STR_LIT>" if unique else "<STR_LIT>"<EOL>sql = (<EOL>"<STR_LIT>"<EOL>"<STR_LIT>".format(<EOL>unique=uniquestr,<EOL>indexname=indexname,<EOL>table=table,<EOL>field=field,<EOL>limit=limit,<EOL>)<EOL>)<EOL>return self.db_exec(sql)<EOL> | Creates an index (default name _idx_FIELDNAME), unless it exists
already. | f14623:c6:m51 |
def create_index_from_fieldspec(self,<EOL>table: str,<EOL>fieldspec: FIELDSPEC_TYPE,<EOL>indexname: str = None) -> None: | if "<STR_LIT>" in fieldspec and fieldspec["<STR_LIT>"]:<EOL><INDENT>if "<STR_LIT>" in fieldspec:<EOL><INDENT>nchar = fieldspec["<STR_LIT>"]<EOL><DEDENT>else:<EOL><INDENT>nchar = None<EOL><DEDENT>self.create_index(table, fieldspec["<STR_LIT:name>"], nchar,<EOL>indexname=indexname)<EOL><DEDENT> | Calls create_index based on a fieldspec, if the fieldspec has
indexed = True. | f14623:c6:m52 |
def create_fulltext_index(self,<EOL>table: str,<EOL>field: str,<EOL>indexname: str = None) -> Optional[int]: | if indexname is None:<EOL><INDENT>indexname = "<STR_LIT>".format(field)<EOL><DEDENT>if self.index_exists(table, indexname):<EOL><INDENT>return None<EOL><DEDENT>sql = "<STR_LIT>".format(indexname, table,<EOL>field)<EOL>return self.db_exec(sql)<EOL> | Creates a FULLTEXT index (default name _idxft_FIELDNAME), unless it
exists already. See:
http://dev.mysql.com/doc/refman/5.6/en/innodb-fulltext-index.html
http://dev.mysql.com/doc/refman/5.0/en/fulltext-search.html | f14623:c6:m53 |
@staticmethod<EOL><INDENT>def fieldnames_from_fieldspeclist(fieldspeclist: FIELDSPECLIST_TYPE)-> List[str]:<DEDENT> | return [x["<STR_LIT:name>"] for x in fieldspeclist]<EOL> | Returns fieldnames from a field specification list. | f14623:c6:m54 |
@staticmethod<EOL><INDENT>def fieldname_from_fieldspec(fieldspec: FIELDSPEC_TYPE) -> str:<DEDENT> | return fieldspec["<STR_LIT:name>"]<EOL> | Returns a fieldname from a field specification. | f14623:c6:m55 |
@staticmethod<EOL><INDENT>def fielddefsql_from_fieldspec(fieldspec: FIELDSPEC_TYPE) -> str:<DEDENT> | sql = fieldspec["<STR_LIT:name>"] + "<STR_LIT:U+0020>" + fieldspec["<STR_LIT>"]<EOL>if "<STR_LIT>" in fieldspec and fieldspec["<STR_LIT>"]:<EOL><INDENT>sql += "<STR_LIT>"<EOL><DEDENT>if "<STR_LIT>" in fieldspec and fieldspec["<STR_LIT>"]:<EOL><INDENT>sql += "<STR_LIT>"<EOL><DEDENT>if "<STR_LIT>" in fieldspec and fieldspec["<STR_LIT>"]:<EOL><INDENT>sql += "<STR_LIT>"<EOL><DEDENT>else:<EOL><INDENT>if "<STR_LIT>" in fieldspec and fieldspec["<STR_LIT>"]:<EOL><INDENT>sql += "<STR_LIT>"<EOL><DEDENT><DEDENT>if "<STR_LIT>" in fieldspec:<EOL><INDENT>sql += "<STR_LIT>" + sql_quote_string(fieldspec["<STR_LIT>"])<EOL><DEDENT>return sql<EOL> | Returns SQL fragment to define a field. | f14623:c6:m56 |
def fielddefsql_from_fieldspeclist(<EOL>self, fieldspeclist: FIELDSPECLIST_TYPE) -> str: | return "<STR_LIT:U+002C>".join([<EOL>self.fielddefsql_from_fieldspec(x)<EOL>for x in fieldspeclist<EOL>])<EOL> | Returns list of field-defining SQL fragments. | f14623:c6:m57 |
@staticmethod<EOL><INDENT>def fieldspec_subset_by_name(<EOL>fieldspeclist: FIELDSPECLIST_TYPE,<EOL>fieldnames: Container[str]) -> FIELDSPECLIST_TYPE:<DEDENT> | result = []<EOL>for x in fieldspeclist:<EOL><INDENT>if x["<STR_LIT:name>"] in fieldnames:<EOL><INDENT>result.append(x)<EOL><DEDENT><DEDENT>return result<EOL> | Returns a subset of the fieldspecs matching the fieldnames list. | f14623:c6:m58 |
def table_exists(self, tablename: str) -> bool: | <EOL>sql = """<STR_LIT>""".format(self.get_current_schema_expr())<EOL>row = self.fetchone(sql, tablename)<EOL>return True if row[<NUM_LIT:0>] >= <NUM_LIT:1> else False<EOL> | Does the table exist? | f14623:c6:m59 |
def column_exists(self, tablename: str, column: str) -> bool: | sql = """<STR_LIT>""".format(self.get_current_schema_expr())<EOL>row = self.fetchone(sql, tablename, column)<EOL>return True if row[<NUM_LIT:0>] >= <NUM_LIT:1> else False<EOL> | Does the column exist? | f14623:c6:m60 |
def drop_table(self, tablename: str) -> int: | sql = "<STR_LIT>".format(tablename)<EOL>log.info("<STR_LIT>" + tablename + "<STR_LIT>")<EOL>return self.db_exec_literal(sql)<EOL> | Drops a table. Use caution! | f14623:c6:m61 |
def drop_view(self, viewname: str) -> int: | sql = "<STR_LIT>".format(viewname)<EOL>log.info("<STR_LIT>" + viewname + "<STR_LIT>")<EOL>return self.db_exec_literal(sql)<EOL> | Drops a view. | f14623:c6:m62 |
def make_table(self,<EOL>tablename: str,<EOL>fieldspeclist: FIELDSPECLIST_TYPE,<EOL>dynamic: bool = False,<EOL>compressed: bool = False) -> Optional[int]: | if self.table_exists(tablename):<EOL><INDENT>log.info("<STR_LIT>" + tablename +<EOL>"<STR_LIT>")<EOL>return None<EOL><DEDENT>if not self.is_mysql():<EOL><INDENT>dynamic = False<EOL>compressed = False<EOL><DEDENT>sql = """<STR_LIT>""".format(<EOL>tablename=tablename,<EOL>fieldspecs=self.fielddefsql_from_fieldspeclist(fieldspeclist),<EOL>dynamic="<STR_LIT>" if dynamic else "<STR_LIT>",<EOL>compressed="<STR_LIT>" if compressed else "<STR_LIT>",<EOL>)<EOL>log.info("<STR_LIT>" + tablename)<EOL>return self.db_exec_literal(sql)<EOL> | Makes a table, if it doesn't already exist. | f14623:c6:m63 |
def rename_table(self, from_table: str, to_table: str) -> Optional[int]: | if not self.table_exists(from_table):<EOL><INDENT>log.info("<STR_LIT>" + from_table +<EOL>"<STR_LIT>")<EOL>return None<EOL><DEDENT>if self.table_exists(to_table):<EOL><INDENT>raise RuntimeError("<STR_LIT>"<EOL>"<STR_LIT>".format(from_table, to_table))<EOL><DEDENT>log.info("<STR_LIT>", from_table, to_table)<EOL>sql = "<STR_LIT>".format(from_table, to_table)<EOL>return self.db_exec_literal(sql)<EOL> | Renames a table. MySQL-specific. | f14623:c6:m64 |
def add_column(self, tablename: str, fieldspec: FIELDSPEC_TYPE) -> int: | sql = "<STR_LIT>".format(<EOL>tablename, self.fielddefsql_from_fieldspec(fieldspec))<EOL>log.info(sql)<EOL>return self.db_exec_literal(sql)<EOL> | Adds a column to an existing table. | f14623:c6:m65 |
def drop_column(self, tablename: str, fieldname: str) -> int: | sql = "<STR_LIT>".format(tablename, fieldname)<EOL>log.info(sql)<EOL>return self.db_exec_literal(sql)<EOL> | Drops (deletes) a column from an existing table. | f14623:c6:m66 |
def modify_column_if_table_exists(self,<EOL>tablename: str,<EOL>fieldname: str,<EOL>newdef: str) -> Optional[int]: | if not self.table_exists(tablename):<EOL><INDENT>return None<EOL><DEDENT>sql = "<STR_LIT>".format(<EOL>t=tablename,<EOL>field=fieldname,<EOL>newdef=newdef<EOL>)<EOL>log.info(sql)<EOL>return self.db_exec_literal(sql)<EOL> | Alters a column's definition without renaming it. | f14623:c6:m67 |
def change_column_if_table_exists(self,<EOL>tablename: str,<EOL>oldfieldname: str,<EOL>newfieldname: str,<EOL>newdef: str) -> Optional[int]: | if not self.table_exists(tablename):<EOL><INDENT>return None<EOL><DEDENT>if not self.column_exists(tablename, oldfieldname):<EOL><INDENT>return None<EOL><DEDENT>sql = "<STR_LIT>".format(<EOL>t=tablename,<EOL>old=oldfieldname,<EOL>new=newfieldname,<EOL>newdef=newdef,<EOL>)<EOL>log.info(sql)<EOL>return self.db_exec_literal(sql)<EOL> | Renames a column and alters its definition. | f14623:c6:m68 |
def create_or_update_table(self,<EOL>tablename: str,<EOL>fieldspeclist: FIELDSPECLIST_TYPE,<EOL>drop_superfluous_columns: bool = False,<EOL>dynamic: bool = False,<EOL>compressed: bool = False) -> None: | <EOL>self.make_table(tablename, fieldspeclist, dynamic=dynamic,<EOL>compressed=compressed)<EOL>fields_in_db = set(self.fetch_column_names(tablename))<EOL>desired_fieldnames = set(<EOL>self.fieldnames_from_fieldspeclist(fieldspeclist))<EOL>missing_fieldnames = desired_fieldnames - fields_in_db<EOL>missing_fieldspecs = self.fieldspec_subset_by_name(fieldspeclist,<EOL>missing_fieldnames)<EOL>for f in missing_fieldspecs:<EOL><INDENT>self.add_column(tablename, f)<EOL><DEDENT>superfluous_fieldnames = fields_in_db - desired_fieldnames<EOL>for f in superfluous_fieldnames:<EOL><INDENT>if drop_superfluous_columns:<EOL><INDENT>log.warning("<STR_LIT>" + f)<EOL>self.drop_column(tablename, f)<EOL><DEDENT>else:<EOL><INDENT>log.warning("<STR_LIT>" + f)<EOL><DEDENT><DEDENT>for fs in fieldspeclist:<EOL><INDENT>self.create_index_from_fieldspec(tablename, fs)<EOL><DEDENT> | - Make table, if it doesn't exist.
- Add fields that aren't there.
- Warn about superfluous fields, but don't delete them, unless
``drop_superfluous_columns == True``.
- Make indexes, if requested. | f14623:c6:m69 |
def get_all_table_details(self) -> List[List[Any]]: | return self.flavour.get_all_table_details(self)<EOL> | Returns all information the database has on a table. | f14623:c6:m70 |
def get_all_table_names(self) -> List[str]: | return self.flavour.get_all_table_names(self)<EOL> | Returns all table names in the database. | f14623:c6:m71 |
def describe_table(self, table: str) -> List[List[Any]]: | return self.flavour.describe_table(self, table)<EOL> | Returns details on a specific table. | f14623:c6:m72 |
def fetch_column_names(self, table: str) -> List[str]: | return self.flavour.fetch_column_names(self, table)<EOL> | Returns all column names for a table. | f14623:c6:m73 |
def get_datatype(self, table: str, column: str) -> str: | return self.flavour.get_datatype(self, table, column).upper()<EOL> | Returns database SQL datatype for a column: e.g. VARCHAR. | f14623:c6:m74 |
def get_column_type(self, table: str, column: str) -> str: | return self.flavour.get_column_type(self, table, column).upper()<EOL> | Returns database SQL datatype for a column, e.g. VARCHAR(50). | f14623:c6:m75 |
def get_comment(self, table: str, column: str) -> str: | return self.flavour.get_comment(self, table, column)<EOL> | Returns database SQL comment for a column. | f14623:c6:m76 |
def debug_query(self, sql: str, *args) -> None: | rows = self.fetchall(sql, *args)<EOL>debug_query_result(rows)<EOL> | Executes SQL and writes the result to the log. | f14623:c6:m77 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.