123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283 |
- import re
-
- from django.db.backends.base.introspection import (
- BaseDatabaseIntrospection, FieldInfo, TableInfo,
- )
- from django.db.models.indexes import Index
-
- field_size_re = re.compile(r'^\s*(?:var)?char\s*\(\s*(\d+)\s*\)\s*$')
-
-
- def get_field_size(name):
- """ Extract the size number from a "varchar(11)" type name """
- m = field_size_re.search(name)
- return int(m.group(1)) if m else None
-
-
- # This light wrapper "fakes" a dictionary interface, because some SQLite data
- # types include variables in them -- e.g. "varchar(30)" -- and can't be matched
- # as a simple dictionary lookup.
- class FlexibleFieldLookupDict:
- # Maps SQL types to Django Field types. Some of the SQL types have multiple
- # entries here because SQLite allows for anything and doesn't normalize the
- # field type; it uses whatever was given.
- base_data_types_reverse = {
- 'bool': 'BooleanField',
- 'boolean': 'BooleanField',
- 'smallint': 'SmallIntegerField',
- 'smallint unsigned': 'PositiveSmallIntegerField',
- 'smallinteger': 'SmallIntegerField',
- 'int': 'IntegerField',
- 'integer': 'IntegerField',
- 'bigint': 'BigIntegerField',
- 'integer unsigned': 'PositiveIntegerField',
- 'decimal': 'DecimalField',
- 'real': 'FloatField',
- 'text': 'TextField',
- 'char': 'CharField',
- 'blob': 'BinaryField',
- 'date': 'DateField',
- 'datetime': 'DateTimeField',
- 'time': 'TimeField',
- }
-
- def __getitem__(self, key):
- key = key.lower()
- try:
- return self.base_data_types_reverse[key]
- except KeyError:
- size = get_field_size(key)
- if size is not None:
- return ('CharField', {'max_length': size})
- raise KeyError
-
-
- class DatabaseIntrospection(BaseDatabaseIntrospection):
- data_types_reverse = FlexibleFieldLookupDict()
-
- def get_table_list(self, cursor):
- """Return a list of table and view names in the current database."""
- # Skip the sqlite_sequence system table used for autoincrement key
- # generation.
- cursor.execute("""
- SELECT name, type FROM sqlite_master
- WHERE type in ('table', 'view') AND NOT name='sqlite_sequence'
- ORDER BY name""")
- return [TableInfo(row[0], row[1][0]) for row in cursor.fetchall()]
-
- def get_table_description(self, cursor, table_name):
- """
- Return a description of the table with the DB-API cursor.description
- interface.
- """
- return [
- FieldInfo(
- info['name'],
- info['type'],
- None,
- info['size'],
- None,
- None,
- info['null_ok'],
- info['default'],
- ) for info in self._table_info(cursor, table_name)
- ]
-
- def get_sequences(self, cursor, table_name, table_fields=()):
- pk_col = self.get_primary_key_column(cursor, table_name)
- return [{'table': table_name, 'column': pk_col}]
-
- def get_relations(self, cursor, table_name):
- """
- Return a dictionary of {field_name: (field_name_other_table, other_table)}
- representing all relationships to the given table.
- """
- # Dictionary of relations to return
- relations = {}
-
- # Schema for this table
- cursor.execute(
- "SELECT sql, type FROM sqlite_master "
- "WHERE tbl_name = %s AND type IN ('table', 'view')",
- [table_name]
- )
- create_sql, table_type = cursor.fetchone()
- if table_type == 'view':
- # It might be a view, then no results will be returned
- return relations
- results = create_sql[create_sql.index('(') + 1:create_sql.rindex(')')]
-
- # Walk through and look for references to other tables. SQLite doesn't
- # really have enforced references, but since it echoes out the SQL used
- # to create the table we can look for REFERENCES statements used there.
- for field_desc in results.split(','):
- field_desc = field_desc.strip()
- if field_desc.startswith("UNIQUE"):
- continue
-
- m = re.search(r'references (\S*) ?\(["|]?(.*)["|]?\)', field_desc, re.I)
- if not m:
- continue
- table, column = [s.strip('"') for s in m.groups()]
-
- if field_desc.startswith("FOREIGN KEY"):
- # Find name of the target FK field
- m = re.match(r'FOREIGN KEY\s*\(([^\)]*)\).*', field_desc, re.I)
- field_name = m.groups()[0].strip('"')
- else:
- field_name = field_desc.split()[0].strip('"')
-
- cursor.execute("SELECT sql FROM sqlite_master WHERE tbl_name = %s", [table])
- result = cursor.fetchall()[0]
- other_table_results = result[0].strip()
- li, ri = other_table_results.index('('), other_table_results.rindex(')')
- other_table_results = other_table_results[li + 1:ri]
-
- for other_desc in other_table_results.split(','):
- other_desc = other_desc.strip()
- if other_desc.startswith('UNIQUE'):
- continue
-
- other_name = other_desc.split(' ', 1)[0].strip('"')
- if other_name == column:
- relations[field_name] = (other_name, table)
- break
-
- return relations
-
- def get_key_columns(self, cursor, table_name):
- """
- Return a list of (column_name, referenced_table_name, referenced_column_name)
- for all key columns in given table.
- """
- key_columns = []
-
- # Schema for this table
- cursor.execute("SELECT sql FROM sqlite_master WHERE tbl_name = %s AND type = %s", [table_name, "table"])
- results = cursor.fetchone()[0].strip()
- results = results[results.index('(') + 1:results.rindex(')')]
-
- # Walk through and look for references to other tables. SQLite doesn't
- # really have enforced references, but since it echoes out the SQL used
- # to create the table we can look for REFERENCES statements used there.
- for field_index, field_desc in enumerate(results.split(',')):
- field_desc = field_desc.strip()
- if field_desc.startswith("UNIQUE"):
- continue
-
- m = re.search(r'"(.*)".*references (.*) \(["|](.*)["|]\)', field_desc, re.I)
- if not m:
- continue
-
- # This will append (column_name, referenced_table_name, referenced_column_name) to key_columns
- key_columns.append(tuple(s.strip('"') for s in m.groups()))
-
- return key_columns
-
- def get_primary_key_column(self, cursor, table_name):
- """Return the column name of the primary key for the given table."""
- # Don't use PRAGMA because that causes issues with some transactions
- cursor.execute(
- "SELECT sql, type FROM sqlite_master "
- "WHERE tbl_name = %s AND type IN ('table', 'view')",
- [table_name]
- )
- row = cursor.fetchone()
- if row is None:
- raise ValueError("Table %s does not exist" % table_name)
- create_sql, table_type = row
- if table_type == 'view':
- # Views don't have a primary key.
- return None
- fields_sql = create_sql[create_sql.index('(') + 1:create_sql.rindex(')')]
- for field_desc in fields_sql.split(','):
- field_desc = field_desc.strip()
- m = re.match(r'(?:(?:["`\[])(.*)(?:["`\]])|(\w+)).*PRIMARY KEY.*', field_desc)
- if m:
- return m.group(1) if m.group(1) else m.group(2)
- return None
-
- def _table_info(self, cursor, name):
- cursor.execute('PRAGMA table_info(%s)' % self.connection.ops.quote_name(name))
- # cid, name, type, notnull, default_value, pk
- return [{
- 'name': field[1],
- 'type': field[2],
- 'size': get_field_size(field[2]),
- 'null_ok': not field[3],
- 'default': field[4],
- 'pk': field[5], # undocumented
- } for field in cursor.fetchall()]
-
- def _get_foreign_key_constraints(self, cursor, table_name):
- constraints = {}
- cursor.execute('PRAGMA foreign_key_list(%s)' % self.connection.ops.quote_name(table_name))
- for row in cursor.fetchall():
- # Remaining on_update/on_delete/match values are of no interest.
- id_, _, table, from_, to = row[:5]
- constraints['fk_%d' % id_] = {
- 'columns': [from_],
- 'primary_key': False,
- 'unique': False,
- 'foreign_key': (table, to),
- 'check': False,
- 'index': False,
- }
- return constraints
-
- def get_constraints(self, cursor, table_name):
- """
- Retrieve any constraints or keys (unique, pk, fk, check, index) across
- one or more columns.
- """
- constraints = {}
- # Get the index info
- cursor.execute("PRAGMA index_list(%s)" % self.connection.ops.quote_name(table_name))
- for row in cursor.fetchall():
- # Sqlite3 3.8.9+ has 5 columns, however older versions only give 3
- # columns. Discard last 2 columns if there.
- number, index, unique = row[:3]
- # Get the index info for that index
- cursor.execute('PRAGMA index_info(%s)' % self.connection.ops.quote_name(index))
- for index_rank, column_rank, column in cursor.fetchall():
- if index not in constraints:
- constraints[index] = {
- "columns": [],
- "primary_key": False,
- "unique": bool(unique),
- "foreign_key": False,
- "check": False,
- "index": True,
- }
- constraints[index]['columns'].append(column)
- # Add type and column orders for indexes
- if constraints[index]['index'] and not constraints[index]['unique']:
- # SQLite doesn't support any index type other than b-tree
- constraints[index]['type'] = Index.suffix
- cursor.execute(
- "SELECT sql FROM sqlite_master "
- "WHERE type='index' AND name=%s" % self.connection.ops.quote_name(index)
- )
- orders = []
- # There would be only 1 row to loop over
- for sql, in cursor.fetchall():
- order_info = sql.split('(')[-1].split(')')[0].split(',')
- orders = ['DESC' if info.endswith('DESC') else 'ASC' for info in order_info]
- constraints[index]['orders'] = orders
- # Get the PK
- pk_column = self.get_primary_key_column(cursor, table_name)
- if pk_column:
- # SQLite doesn't actually give a name to the PK constraint,
- # so we invent one. This is fine, as the SQLite backend never
- # deletes PK constraints by name, as you can't delete constraints
- # in SQLite; we remake the table with a new PK instead.
- constraints["__primary__"] = {
- "columns": [pk_column],
- "primary_key": True,
- "unique": False, # It's not actually a unique constraint.
- "foreign_key": False,
- "check": False,
- "index": False,
- }
- constraints.update(self._get_foreign_key_constraints(cursor, table_name))
- return constraints
|