File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/base.zip
Back
PK �"�Z���o �o base.pynu �[��� import _thread import copy import datetime import logging import threading import time import warnings from collections import deque from contextlib import contextmanager from django.db.backends.utils import debug_transaction try: import zoneinfo except ImportError: from backports import zoneinfo from django.conf import settings from django.core.exceptions import ImproperlyConfigured from django.db import DEFAULT_DB_ALIAS, DatabaseError, NotSupportedError from django.db.backends import utils from django.db.backends.base.validation import BaseDatabaseValidation from django.db.backends.signals import connection_created from django.db.transaction import TransactionManagementError from django.db.utils import DatabaseErrorWrapper from django.utils.asyncio import async_unsafe from django.utils.functional import cached_property NO_DB_ALIAS = "__no_db__" RAN_DB_VERSION_CHECK = set() logger = logging.getLogger("django.db.backends.base") # RemovedInDjango50Warning def timezone_constructor(tzname): if settings.USE_DEPRECATED_PYTZ: import pytz return pytz.timezone(tzname) return zoneinfo.ZoneInfo(tzname) class BaseDatabaseWrapper: """Represent a database connection.""" # Mapping of Field objects to their column types. data_types = {} # Mapping of Field objects to their SQL suffix such as AUTOINCREMENT. data_types_suffix = {} # Mapping of Field objects to their SQL for CHECK constraints. data_type_check_constraints = {} ops = None vendor = "unknown" display_name = "unknown" SchemaEditorClass = None # Classes instantiated in __init__(). client_class = None creation_class = None features_class = None introspection_class = None ops_class = None validation_class = BaseDatabaseValidation queries_limit = 9000 def __init__(self, settings_dict, alias=DEFAULT_DB_ALIAS): # Connection related attributes. # The underlying database connection. self.connection = None # `settings_dict` should be a dictionary containing keys such as # NAME, USER, etc. It's called `settings_dict` instead of `settings` # to disambiguate it from Django settings modules. self.settings_dict = settings_dict self.alias = alias # Query logging in debug mode or when explicitly enabled. self.queries_log = deque(maxlen=self.queries_limit) self.force_debug_cursor = False # Transaction related attributes. # Tracks if the connection is in autocommit mode. Per PEP 249, by # default, it isn't. self.autocommit = False # Tracks if the connection is in a transaction managed by 'atomic'. self.in_atomic_block = False # Increment to generate unique savepoint ids. self.savepoint_state = 0 # List of savepoints created by 'atomic'. self.savepoint_ids = [] # Stack of active 'atomic' blocks. self.atomic_blocks = [] # Tracks if the outermost 'atomic' block should commit on exit, # ie. if autocommit was active on entry. self.commit_on_exit = True # Tracks if the transaction should be rolled back to the next # available savepoint because of an exception in an inner block. self.needs_rollback = False self.rollback_exc = None # Connection termination related attributes. self.close_at = None self.closed_in_transaction = False self.errors_occurred = False self.health_check_enabled = False self.health_check_done = False # Thread-safety related attributes. self._thread_sharing_lock = threading.Lock() self._thread_sharing_count = 0 self._thread_ident = _thread.get_ident() # A list of no-argument functions to run when the transaction commits. # Each entry is an (sids, func, robust) tuple, where sids is a set of # the active savepoint IDs when this function was registered and robust # specifies whether it's allowed for the function to fail. self.run_on_commit = [] # Should we run the on-commit hooks the next time set_autocommit(True) # is called? self.run_commit_hooks_on_set_autocommit_on = False # A stack of wrappers to be invoked around execute()/executemany() # calls. Each entry is a function taking five arguments: execute, sql, # params, many, and context. It's the function's responsibility to # call execute(sql, params, many, context). self.execute_wrappers = [] self.client = self.client_class(self) self.creation = self.creation_class(self) self.features = self.features_class(self) self.introspection = self.introspection_class(self) self.ops = self.ops_class(self) self.validation = self.validation_class(self) def __repr__(self): return ( f"<{self.__class__.__qualname__} " f"vendor={self.vendor!r} alias={self.alias!r}>" ) def ensure_timezone(self): """ Ensure the connection's timezone is set to `self.timezone_name` and return whether it changed or not. """ return False @cached_property def timezone(self): """ Return a tzinfo of the database connection time zone. This is only used when time zone support is enabled. When a datetime is read from the database, it is always returned in this time zone. When the database backend supports time zones, it doesn't matter which time zone Django uses, as long as aware datetimes are used everywhere. Other users connecting to the database can choose their own time zone. When the database backend doesn't support time zones, the time zone Django uses may be constrained by the requirements of other users of the database. """ if not settings.USE_TZ: return None elif self.settings_dict["TIME_ZONE"] is None: return datetime.timezone.utc else: return timezone_constructor(self.settings_dict["TIME_ZONE"]) @cached_property def timezone_name(self): """ Name of the time zone of the database connection. """ if not settings.USE_TZ: return settings.TIME_ZONE elif self.settings_dict["TIME_ZONE"] is None: return "UTC" else: return self.settings_dict["TIME_ZONE"] @property def queries_logged(self): return self.force_debug_cursor or settings.DEBUG @property def queries(self): if len(self.queries_log) == self.queries_log.maxlen: warnings.warn( "Limit for query logging exceeded, only the last {} queries " "will be returned.".format(self.queries_log.maxlen) ) return list(self.queries_log) def get_database_version(self): """Return a tuple of the database's version.""" raise NotImplementedError( "subclasses of BaseDatabaseWrapper may require a get_database_version() " "method." ) def check_database_version_supported(self): """ Raise an error if the database version isn't supported by this version of Django. """ if ( self.features.minimum_database_version is not None and self.get_database_version() < self.features.minimum_database_version ): db_version = ".".join(map(str, self.get_database_version())) min_db_version = ".".join(map(str, self.features.minimum_database_version)) raise NotSupportedError( f"{self.display_name} {min_db_version} or later is required " f"(found {db_version})." ) # ##### Backend-specific methods for creating connections and cursors ##### def get_connection_params(self): """Return a dict of parameters suitable for get_new_connection.""" raise NotImplementedError( "subclasses of BaseDatabaseWrapper may require a get_connection_params() " "method" ) def get_new_connection(self, conn_params): """Open a connection to the database.""" raise NotImplementedError( "subclasses of BaseDatabaseWrapper may require a get_new_connection() " "method" ) def init_connection_state(self): """Initialize the database connection settings.""" global RAN_DB_VERSION_CHECK if self.alias not in RAN_DB_VERSION_CHECK: self.check_database_version_supported() RAN_DB_VERSION_CHECK.add(self.alias) def create_cursor(self, name=None): """Create a cursor. Assume that a connection is established.""" raise NotImplementedError( "subclasses of BaseDatabaseWrapper may require a create_cursor() method" ) # ##### Backend-specific methods for creating connections ##### @async_unsafe def connect(self): """Connect to the database. Assume that the connection is closed.""" # Check for invalid configurations. self.check_settings() # In case the previous connection was closed while in an atomic block self.in_atomic_block = False self.savepoint_ids = [] self.atomic_blocks = [] self.needs_rollback = False # Reset parameters defining when to close/health-check the connection. self.health_check_enabled = self.settings_dict["CONN_HEALTH_CHECKS"] max_age = self.settings_dict["CONN_MAX_AGE"] self.close_at = None if max_age is None else time.monotonic() + max_age self.closed_in_transaction = False self.errors_occurred = False # New connections are healthy. self.health_check_done = True # Establish the connection conn_params = self.get_connection_params() self.connection = self.get_new_connection(conn_params) self.set_autocommit(self.settings_dict["AUTOCOMMIT"]) self.init_connection_state() connection_created.send(sender=self.__class__, connection=self) self.run_on_commit = [] def check_settings(self): if self.settings_dict["TIME_ZONE"] is not None and not settings.USE_TZ: raise ImproperlyConfigured( "Connection '%s' cannot set TIME_ZONE because USE_TZ is False." % self.alias ) @async_unsafe def ensure_connection(self): """Guarantee that a connection to the database is established.""" if self.connection is None: with self.wrap_database_errors: self.connect() # ##### Backend-specific wrappers for PEP-249 connection methods ##### def _prepare_cursor(self, cursor): """ Validate the connection is usable and perform database cursor wrapping. """ self.validate_thread_sharing() if self.queries_logged: wrapped_cursor = self.make_debug_cursor(cursor) else: wrapped_cursor = self.make_cursor(cursor) return wrapped_cursor def _cursor(self, name=None): self.close_if_health_check_failed() self.ensure_connection() with self.wrap_database_errors: return self._prepare_cursor(self.create_cursor(name)) def _commit(self): if self.connection is not None: with debug_transaction(self, "COMMIT"), self.wrap_database_errors: return self.connection.commit() def _rollback(self): if self.connection is not None: with debug_transaction(self, "ROLLBACK"), self.wrap_database_errors: return self.connection.rollback() def _close(self): if self.connection is not None: with self.wrap_database_errors: return self.connection.close() # ##### Generic wrappers for PEP-249 connection methods ##### @async_unsafe def cursor(self): """Create a cursor, opening a connection if necessary.""" return self._cursor() @async_unsafe def commit(self): """Commit a transaction and reset the dirty flag.""" self.validate_thread_sharing() self.validate_no_atomic_block() self._commit() # A successful commit means that the database connection works. self.errors_occurred = False self.run_commit_hooks_on_set_autocommit_on = True @async_unsafe def rollback(self): """Roll back a transaction and reset the dirty flag.""" self.validate_thread_sharing() self.validate_no_atomic_block() self._rollback() # A successful rollback means that the database connection works. self.errors_occurred = False self.needs_rollback = False self.run_on_commit = [] @async_unsafe def close(self): """Close the connection to the database.""" self.validate_thread_sharing() self.run_on_commit = [] # Don't call validate_no_atomic_block() to avoid making it difficult # to get rid of a connection in an invalid state. The next connect() # will reset the transaction state anyway. if self.closed_in_transaction or self.connection is None: return try: self._close() finally: if self.in_atomic_block: self.closed_in_transaction = True self.needs_rollback = True else: self.connection = None # ##### Backend-specific savepoint management methods ##### def _savepoint(self, sid): with self.cursor() as cursor: cursor.execute(self.ops.savepoint_create_sql(sid)) def _savepoint_rollback(self, sid): with self.cursor() as cursor: cursor.execute(self.ops.savepoint_rollback_sql(sid)) def _savepoint_commit(self, sid): with self.cursor() as cursor: cursor.execute(self.ops.savepoint_commit_sql(sid)) def _savepoint_allowed(self): # Savepoints cannot be created outside a transaction return self.features.uses_savepoints and not self.get_autocommit() # ##### Generic savepoint management methods ##### @async_unsafe def savepoint(self): """ Create a savepoint inside the current transaction. Return an identifier for the savepoint that will be used for the subsequent rollback or commit. Do nothing if savepoints are not supported. """ if not self._savepoint_allowed(): return thread_ident = _thread.get_ident() tid = str(thread_ident).replace("-", "") self.savepoint_state += 1 sid = "s%s_x%d" % (tid, self.savepoint_state) self.validate_thread_sharing() self._savepoint(sid) return sid @async_unsafe def savepoint_rollback(self, sid): """ Roll back to a savepoint. Do nothing if savepoints are not supported. """ if not self._savepoint_allowed(): return self.validate_thread_sharing() self._savepoint_rollback(sid) # Remove any callbacks registered while this savepoint was active. self.run_on_commit = [ (sids, func, robust) for (sids, func, robust) in self.run_on_commit if sid not in sids ] @async_unsafe def savepoint_commit(self, sid): """ Release a savepoint. Do nothing if savepoints are not supported. """ if not self._savepoint_allowed(): return self.validate_thread_sharing() self._savepoint_commit(sid) @async_unsafe def clean_savepoints(self): """ Reset the counter used to generate unique savepoint ids in this thread. """ self.savepoint_state = 0 # ##### Backend-specific transaction management methods ##### def _set_autocommit(self, autocommit): """ Backend-specific implementation to enable or disable autocommit. """ raise NotImplementedError( "subclasses of BaseDatabaseWrapper may require a _set_autocommit() method" ) # ##### Generic transaction management methods ##### def get_autocommit(self): """Get the autocommit state.""" self.ensure_connection() return self.autocommit def set_autocommit( self, autocommit, force_begin_transaction_with_broken_autocommit=False ): """ Enable or disable autocommit. The usual way to start a transaction is to turn autocommit off. SQLite does not properly start a transaction when disabling autocommit. To avoid this buggy behavior and to actually enter a new transaction, an explicit BEGIN is required. Using force_begin_transaction_with_broken_autocommit=True will issue an explicit BEGIN with SQLite. This option will be ignored for other backends. """ self.validate_no_atomic_block() self.close_if_health_check_failed() self.ensure_connection() start_transaction_under_autocommit = ( force_begin_transaction_with_broken_autocommit and not autocommit and hasattr(self, "_start_transaction_under_autocommit") ) if start_transaction_under_autocommit: self._start_transaction_under_autocommit() elif autocommit: self._set_autocommit(autocommit) else: with debug_transaction(self, "BEGIN"): self._set_autocommit(autocommit) self.autocommit = autocommit if autocommit and self.run_commit_hooks_on_set_autocommit_on: self.run_and_clear_commit_hooks() self.run_commit_hooks_on_set_autocommit_on = False def get_rollback(self): """Get the "needs rollback" flag -- for *advanced use* only.""" if not self.in_atomic_block: raise TransactionManagementError( "The rollback flag doesn't work outside of an 'atomic' block." ) return self.needs_rollback def set_rollback(self, rollback): """ Set or unset the "needs rollback" flag -- for *advanced use* only. """ if not self.in_atomic_block: raise TransactionManagementError( "The rollback flag doesn't work outside of an 'atomic' block." ) self.needs_rollback = rollback def validate_no_atomic_block(self): """Raise an error if an atomic block is active.""" if self.in_atomic_block: raise TransactionManagementError( "This is forbidden when an 'atomic' block is active." ) def validate_no_broken_transaction(self): if self.needs_rollback: raise TransactionManagementError( "An error occurred in the current transaction. You can't " "execute queries until the end of the 'atomic' block." ) from self.rollback_exc # ##### Foreign key constraints checks handling ##### @contextmanager def constraint_checks_disabled(self): """ Disable foreign key constraint checking. """ disabled = self.disable_constraint_checking() try: yield finally: if disabled: self.enable_constraint_checking() def disable_constraint_checking(self): """ Backends can implement as needed to temporarily disable foreign key constraint checking. Should return True if the constraints were disabled and will need to be reenabled. """ return False def enable_constraint_checking(self): """ Backends can implement as needed to re-enable foreign key constraint checking. """ pass def check_constraints(self, table_names=None): """ Backends can override this method if they can apply constraint checking (e.g. via "SET CONSTRAINTS ALL IMMEDIATE"). Should raise an IntegrityError if any invalid foreign key references are encountered. """ pass # ##### Connection termination handling ##### def is_usable(self): """ Test if the database connection is usable. This method may assume that self.connection is not None. Actual implementations should take care not to raise exceptions as that may prevent Django from recycling unusable connections. """ raise NotImplementedError( "subclasses of BaseDatabaseWrapper may require an is_usable() method" ) def close_if_health_check_failed(self): """Close existing connection if it fails a health check.""" if ( self.connection is None or not self.health_check_enabled or self.health_check_done ): return if not self.is_usable(): self.close() self.health_check_done = True def close_if_unusable_or_obsolete(self): """ Close the current connection if unrecoverable errors have occurred or if it outlived its maximum age. """ if self.connection is not None: self.health_check_done = False # If the application didn't restore the original autocommit setting, # don't take chances, drop the connection. if self.get_autocommit() != self.settings_dict["AUTOCOMMIT"]: self.close() return # If an exception other than DataError or IntegrityError occurred # since the last commit / rollback, check if the connection works. if self.errors_occurred: if self.is_usable(): self.errors_occurred = False self.health_check_done = True else: self.close() return if self.close_at is not None and time.monotonic() >= self.close_at: self.close() return # ##### Thread safety handling ##### @property def allow_thread_sharing(self): with self._thread_sharing_lock: return self._thread_sharing_count > 0 def inc_thread_sharing(self): with self._thread_sharing_lock: self._thread_sharing_count += 1 def dec_thread_sharing(self): with self._thread_sharing_lock: if self._thread_sharing_count <= 0: raise RuntimeError( "Cannot decrement the thread sharing count below zero." ) self._thread_sharing_count -= 1 def validate_thread_sharing(self): """ Validate that the connection isn't accessed by another thread than the one which originally created it, unless the connection was explicitly authorized to be shared between threads (via the `inc_thread_sharing()` method). Raise an exception if the validation fails. """ if not (self.allow_thread_sharing or self._thread_ident == _thread.get_ident()): raise DatabaseError( "DatabaseWrapper objects created in a " "thread can only be used in that same thread. The object " "with alias '%s' was created in thread id %s and this is " "thread id %s." % (self.alias, self._thread_ident, _thread.get_ident()) ) # ##### Miscellaneous ##### def prepare_database(self): """ Hook to do any database check or preparation, generally called before migrating a project or an app. """ pass @cached_property def wrap_database_errors(self): """ Context manager and decorator that re-throws backend-specific database exceptions using Django's common wrappers. """ return DatabaseErrorWrapper(self) def chunked_cursor(self): """ Return a cursor that tries to avoid caching in the database (if supported by the database), otherwise return a regular cursor. """ return self.cursor() def make_debug_cursor(self, cursor): """Create a cursor that logs all queries in self.queries_log.""" return utils.CursorDebugWrapper(cursor, self) def make_cursor(self, cursor): """Create a cursor without debug logging.""" return utils.CursorWrapper(cursor, self) @contextmanager def temporary_connection(self): """ Context manager that ensures that a connection is established, and if it opened one, closes it to avoid leaving a dangling connection. This is useful for operations outside of the request-response cycle. Provide a cursor: with self.temporary_connection() as cursor: ... """ must_close = self.connection is None try: with self.cursor() as cursor: yield cursor finally: if must_close: self.close() @contextmanager def _nodb_cursor(self): """ Return a cursor from an alternative connection to be used when there is no need to access the main database, specifically for test db creation/deletion. This also prevents the production database from being exposed to potential child threads while (or after) the test database is destroyed. Refs #10868, #17786, #16969. """ conn = self.__class__({**self.settings_dict, "NAME": None}, alias=NO_DB_ALIAS) try: with conn.cursor() as cursor: yield cursor finally: conn.close() def schema_editor(self, *args, **kwargs): """ Return a new instance of this backend's SchemaEditor. """ if self.SchemaEditorClass is None: raise NotImplementedError( "The SchemaEditorClass attribute of this database wrapper is still None" ) return self.SchemaEditorClass(self, *args, **kwargs) def on_commit(self, func, robust=False): if not callable(func): raise TypeError("on_commit()'s callback must be a callable.") if self.in_atomic_block: # Transaction in progress; save for execution on commit. self.run_on_commit.append((set(self.savepoint_ids), func, robust)) elif not self.get_autocommit(): raise TransactionManagementError( "on_commit() cannot be used in manual transaction management" ) else: # No transaction in progress and in autocommit mode; execute # immediately. if robust: try: func() except Exception as e: logger.error( f"Error calling {func.__qualname__} in on_commit() (%s).", e, exc_info=True, ) else: func() def run_and_clear_commit_hooks(self): self.validate_no_atomic_block() current_run_on_commit = self.run_on_commit self.run_on_commit = [] while current_run_on_commit: _, func, robust = current_run_on_commit.pop(0) if robust: try: func() except Exception as e: logger.error( f"Error calling {func.__qualname__} in on_commit() during " f"transaction (%s).", e, exc_info=True, ) else: func() @contextmanager def execute_wrapper(self, wrapper): """ Return a context manager under which the wrapper is applied to suitable database query executions. """ self.execute_wrappers.append(wrapper) try: yield finally: self.execute_wrappers.pop() def copy(self, alias=None): """ Return a copy of this connection. For tests that require two connections to the same database. """ settings_dict = copy.deepcopy(self.settings_dict) if alias is None: alias = self.alias return type(self)(settings_dict, alias) PK �"�Z>+�i: i: features.pynu �[��� from django.db import ProgrammingError from django.utils.functional import cached_property class BaseDatabaseFeatures: # An optional tuple indicating the minimum supported database version. minimum_database_version = None gis_enabled = False # Oracle can't group by LOB (large object) data types. allows_group_by_lob = True allows_group_by_selected_pks = False allows_group_by_select_index = True empty_fetchmany_value = [] update_can_self_select = True # Does the backend distinguish between '' and None? interprets_empty_strings_as_nulls = False # Does the backend allow inserting duplicate NULL rows in a nullable # unique field? All core backends implement this correctly, but other # databases such as SQL Server do not. supports_nullable_unique_constraints = True # Does the backend allow inserting duplicate rows when a unique_together # constraint exists and some fields are nullable but not all of them? supports_partially_nullable_unique_constraints = True # Does the backend support initially deferrable unique constraints? supports_deferrable_unique_constraints = False can_use_chunked_reads = True can_return_columns_from_insert = False can_return_rows_from_bulk_insert = False has_bulk_insert = True uses_savepoints = True can_release_savepoints = False # If True, don't use integer foreign keys referring to, e.g., positive # integer primary keys. related_fields_match_type = False allow_sliced_subqueries_with_in = True has_select_for_update = False has_select_for_update_nowait = False has_select_for_update_skip_locked = False has_select_for_update_of = False has_select_for_no_key_update = False # Does the database's SELECT FOR UPDATE OF syntax require a column rather # than a table? select_for_update_of_column = False # Does the default test database allow multiple connections? # Usually an indication that the test database is in-memory test_db_allows_multiple_connections = True # Can an object be saved without an explicit primary key? supports_unspecified_pk = False # Can a fixture contain forward references? i.e., are # FK constraints checked at the end of transaction, or # at the end of each save operation? supports_forward_references = True # Does the backend truncate names properly when they are too long? truncates_names = False # Is there a REAL datatype in addition to floats/doubles? has_real_datatype = False supports_subqueries_in_group_by = True # Does the backend ignore unnecessary ORDER BY clauses in subqueries? ignores_unnecessary_order_by_in_subqueries = True # Is there a true datatype for uuid? has_native_uuid_field = False # Is there a true datatype for timedeltas? has_native_duration_field = False # Does the database driver supports same type temporal data subtraction # by returning the type used to store duration field? supports_temporal_subtraction = False # Does the __regex lookup support backreferencing and grouping? supports_regex_backreferencing = True # Can date/datetime lookups be performed using a string? supports_date_lookup_using_string = True # Can datetimes with timezones be used? supports_timezones = True # Does the database have a copy of the zoneinfo database? has_zoneinfo_database = True # When performing a GROUP BY, is an ORDER BY NULL required # to remove any ordering? requires_explicit_null_ordering_when_grouping = False # Does the backend order NULL values as largest or smallest? nulls_order_largest = False # Does the backend support NULLS FIRST and NULLS LAST in ORDER BY? supports_order_by_nulls_modifier = True # Does the backend orders NULLS FIRST by default? order_by_nulls_first = False # The database's limit on the number of query parameters. max_query_params = None # Can an object have an autoincrement primary key of 0? allows_auto_pk_0 = True # Do we need to NULL a ForeignKey out, or can the constraint check be # deferred can_defer_constraint_checks = False # Does the backend support tablespaces? Default to False because it isn't # in the SQL standard. supports_tablespaces = False # Does the backend reset sequences between tests? supports_sequence_reset = True # Can the backend introspect the default value of a column? can_introspect_default = True # Confirm support for introspected foreign keys # Every database can do this reliably, except MySQL, # which can't do it for MyISAM tables can_introspect_foreign_keys = True # Map fields which some backends may not be able to differentiate to the # field it's introspected as. introspected_field_types = { "AutoField": "AutoField", "BigAutoField": "BigAutoField", "BigIntegerField": "BigIntegerField", "BinaryField": "BinaryField", "BooleanField": "BooleanField", "CharField": "CharField", "DurationField": "DurationField", "GenericIPAddressField": "GenericIPAddressField", "IntegerField": "IntegerField", "PositiveBigIntegerField": "PositiveBigIntegerField", "PositiveIntegerField": "PositiveIntegerField", "PositiveSmallIntegerField": "PositiveSmallIntegerField", "SmallAutoField": "SmallAutoField", "SmallIntegerField": "SmallIntegerField", "TimeField": "TimeField", } # Can the backend introspect the column order (ASC/DESC) for indexes? supports_index_column_ordering = True # Does the backend support introspection of materialized views? can_introspect_materialized_views = False # Support for the DISTINCT ON clause can_distinct_on_fields = False # Does the backend prevent running SQL queries in broken transactions? atomic_transactions = True # Can we roll back DDL in a transaction? can_rollback_ddl = False schema_editor_uses_clientside_param_binding = False # Does it support operations requiring references rename in a transaction? supports_atomic_references_rename = True # Can we issue more than one ALTER COLUMN clause in an ALTER TABLE? supports_combined_alters = False # Does it support foreign keys? supports_foreign_keys = True # Can it create foreign key constraints inline when adding columns? can_create_inline_fk = True # Can an index be renamed? can_rename_index = False # Does it automatically index foreign keys? indexes_foreign_keys = True # Does it support CHECK constraints? supports_column_check_constraints = True supports_table_check_constraints = True # Does the backend support introspection of CHECK constraints? can_introspect_check_constraints = True # Does the backend support 'pyformat' style ("... %(name)s ...", {'name': value}) # parameter passing? Note this can be provided by the backend even if not # supported by the Python driver supports_paramstyle_pyformat = True # Does the backend require literal defaults, rather than parameterized ones? requires_literal_defaults = False # Does the backend require a connection reset after each material schema change? connection_persists_old_columns = False # What kind of error does the backend throw when accessing closed cursor? closed_cursor_error_class = ProgrammingError # Does 'a' LIKE 'A' match? has_case_insensitive_like = False # Suffix for backends that don't support "SELECT xxx;" queries. bare_select_suffix = "" # If NULL is implied on columns without needing to be explicitly specified implied_column_null = False # Does the backend support "select for update" queries with limit (and offset)? supports_select_for_update_with_limit = True # Does the backend ignore null expressions in GREATEST and LEAST queries unless # every expression is null? greatest_least_ignores_nulls = False # Can the backend clone databases for parallel test execution? # Defaults to False to allow third-party backends to opt-in. can_clone_databases = False # Does the backend consider table names with different casing to # be equal? ignores_table_name_case = False # Place FOR UPDATE right after FROM clause. Used on MSSQL. for_update_after_from = False # Combinatorial flags supports_select_union = True supports_select_intersection = True supports_select_difference = True supports_slicing_ordering_in_compound = False supports_parentheses_in_compound = True requires_compound_order_by_subquery = False # Does the database support SQL 2003 FILTER (WHERE ...) in aggregate # expressions? supports_aggregate_filter_clause = False # Does the backend support indexing a TextField? supports_index_on_text_field = True # Does the backend support window expressions (expression OVER (...))? supports_over_clause = False supports_frame_range_fixed_distance = False only_supports_unbounded_with_preceding_and_following = False # Does the backend support CAST with precision? supports_cast_with_precision = True # How many second decimals does the database return when casting a value to # a type with time? time_cast_precision = 6 # SQL to create a procedure for use by the Django test suite. The # functionality of the procedure isn't important. create_test_procedure_without_params_sql = None create_test_procedure_with_int_param_sql = None # SQL to create a table with a composite primary key for use by the Django # test suite. create_test_table_with_composite_primary_key = None # Does the backend support keyword parameters for cursor.callproc()? supports_callproc_kwargs = False # What formats does the backend EXPLAIN syntax support? supported_explain_formats = set() # Does the backend support the default parameter in lead() and lag()? supports_default_in_lead_lag = True # Does the backend support ignoring constraint or uniqueness errors during # INSERT? supports_ignore_conflicts = True # Does the backend support updating rows on constraint or uniqueness errors # during INSERT? supports_update_conflicts = False supports_update_conflicts_with_target = False # Does this backend require casting the results of CASE expressions used # in UPDATE statements to ensure the expression has the correct type? requires_casted_case_in_updates = False # Does the backend support partial indexes (CREATE INDEX ... WHERE ...)? supports_partial_indexes = True supports_functions_in_partial_indexes = True # Does the backend support covering indexes (CREATE INDEX ... INCLUDE ...)? supports_covering_indexes = False # Does the backend support indexes on expressions? supports_expression_indexes = True # Does the backend treat COLLATE as an indexed expression? collate_as_index_expression = False # Does the database allow more than one constraint or index on the same # field(s)? allows_multiple_constraints_on_same_fields = True # Does the backend support boolean expressions in SELECT and GROUP BY # clauses? supports_boolean_expr_in_select_clause = True # Does the backend support comparing boolean expressions in WHERE clauses? # Eg: WHERE (price > 0) IS NOT NULL supports_comparing_boolean_expr = True # Does the backend support JSONField? supports_json_field = True # Can the backend introspect a JSONField? can_introspect_json_field = True # Does the backend support primitives in JSONField? supports_primitives_in_json_field = True # Is there a true datatype for JSON? has_native_json_field = False # Does the backend use PostgreSQL-style JSON operators like '->'? has_json_operators = False # Does the backend support __contains and __contained_by lookups for # a JSONField? supports_json_field_contains = True # Does value__d__contains={'f': 'g'} (without a list around the dict) match # {'d': [{'f': 'g'}]}? json_key_contains_list_matching_requires_list = False # Does the backend support JSONObject() database function? has_json_object_function = True # Does the backend support column collations? supports_collation_on_charfield = True supports_collation_on_textfield = True # Does the backend support non-deterministic collations? supports_non_deterministic_collations = True # Does the backend support column and table comments? supports_comments = False # Does the backend support column comments in ADD COLUMN statements? supports_comments_inline = False # Does the backend support the logical XOR operator? supports_logical_xor = False # Set to (exception, message) if null characters in text are disallowed. prohibits_null_characters_in_text_exception = None # Does the backend support unlimited character columns? supports_unlimited_charfield = False # Collation names for use by the Django test suite. test_collations = { "ci": None, # Case-insensitive. "cs": None, # Case-sensitive. "non_default": None, # Non-default. "swedish_ci": None, # Swedish case-insensitive. } # SQL template override for tests.aggregation.tests.NowUTC test_now_utc_template = None # A set of dotted paths to tests in Django's test suite that are expected # to fail on this database. django_test_expected_failures = set() # A map of reasons to sets of dotted paths to tests in Django's test suite # that should be skipped for this database. django_test_skips = {} def __init__(self, connection): self.connection = connection @cached_property def supports_explaining_query_execution(self): """Does this backend support explaining query execution?""" return self.connection.ops.explain_prefix is not None @cached_property def supports_transactions(self): """Confirm support for transactions.""" with self.connection.cursor() as cursor: cursor.execute("CREATE TABLE ROLLBACK_TEST (X INT)") self.connection.set_autocommit(False) cursor.execute("INSERT INTO ROLLBACK_TEST (X) VALUES (8)") self.connection.rollback() self.connection.set_autocommit(True) cursor.execute("SELECT COUNT(X) FROM ROLLBACK_TEST") (count,) = cursor.fetchone() cursor.execute("DROP TABLE ROLLBACK_TEST") return count == 0 def allows_group_by_selected_pks_on_model(self, model): if not self.allows_group_by_selected_pks: return False return model._meta.managed PK �"�ZLh �4= 4= creation.pynu �[��� import os import sys from io import StringIO from django.apps import apps from django.conf import settings from django.core import serializers from django.db import router from django.db.transaction import atomic from django.utils.module_loading import import_string # The prefix to put on the default database name when creating # the test database. TEST_DATABASE_PREFIX = "test_" class BaseDatabaseCreation: """ Encapsulate backend-specific differences pertaining to creation and destruction of the test database. """ def __init__(self, connection): self.connection = connection def _nodb_cursor(self): return self.connection._nodb_cursor() def log(self, msg): sys.stderr.write(msg + os.linesep) def create_test_db( self, verbosity=1, autoclobber=False, serialize=True, keepdb=False ): """ Create a test database, prompting the user for confirmation if the database already exists. Return the name of the test database created. """ # Don't import django.core.management if it isn't needed. from django.core.management import call_command test_database_name = self._get_test_db_name() if verbosity >= 1: action = "Creating" if keepdb: action = "Using existing" self.log( "%s test database for alias %s..." % ( action, self._get_database_display_str(verbosity, test_database_name), ) ) # We could skip this call if keepdb is True, but we instead # give it the keepdb param. This is to handle the case # where the test DB doesn't exist, in which case we need to # create it, then just not destroy it. If we instead skip # this, we will get an exception. self._create_test_db(verbosity, autoclobber, keepdb) self.connection.close() settings.DATABASES[self.connection.alias]["NAME"] = test_database_name self.connection.settings_dict["NAME"] = test_database_name try: if self.connection.settings_dict["TEST"]["MIGRATE"] is False: # Disable migrations for all apps. old_migration_modules = settings.MIGRATION_MODULES settings.MIGRATION_MODULES = { app.label: None for app in apps.get_app_configs() } # We report migrate messages at one level lower than that # requested. This ensures we don't get flooded with messages during # testing (unless you really ask to be flooded). call_command( "migrate", verbosity=max(verbosity - 1, 0), interactive=False, database=self.connection.alias, run_syncdb=True, ) finally: if self.connection.settings_dict["TEST"]["MIGRATE"] is False: settings.MIGRATION_MODULES = old_migration_modules # We then serialize the current state of the database into a string # and store it on the connection. This slightly horrific process is so people # who are testing on databases without transactions or who are using # a TransactionTestCase still get a clean database on every test run. if serialize: self.connection._test_serialized_contents = self.serialize_db_to_string() call_command("createcachetable", database=self.connection.alias) # Ensure a connection for the side effect of initializing the test database. self.connection.ensure_connection() if os.environ.get("RUNNING_DJANGOS_TEST_SUITE") == "true": self.mark_expected_failures_and_skips() return test_database_name def set_as_test_mirror(self, primary_settings_dict): """ Set this database up to be used in testing as a mirror of a primary database whose settings are given. """ self.connection.settings_dict["NAME"] = primary_settings_dict["NAME"] def serialize_db_to_string(self): """ Serialize all data in the database into a JSON string. Designed only for test runner usage; will not handle large amounts of data. """ # Iteratively return every object for all models to serialize. def get_objects(): from django.db.migrations.loader import MigrationLoader loader = MigrationLoader(self.connection) for app_config in apps.get_app_configs(): if ( app_config.models_module is not None and app_config.label in loader.migrated_apps and app_config.name not in settings.TEST_NON_SERIALIZED_APPS ): for model in app_config.get_models(): if model._meta.can_migrate( self.connection ) and router.allow_migrate_model(self.connection.alias, model): queryset = model._base_manager.using( self.connection.alias, ).order_by(model._meta.pk.name) yield from queryset.iterator() # Serialize to a string out = StringIO() serializers.serialize("json", get_objects(), indent=None, stream=out) return out.getvalue() def deserialize_db_from_string(self, data): """ Reload the database with data from a string generated by the serialize_db_to_string() method. """ data = StringIO(data) table_names = set() # Load data in a transaction to handle forward references and cycles. with atomic(using=self.connection.alias): # Disable constraint checks, because some databases (MySQL) doesn't # support deferred checks. with self.connection.constraint_checks_disabled(): for obj in serializers.deserialize( "json", data, using=self.connection.alias ): obj.save() table_names.add(obj.object.__class__._meta.db_table) # Manually check for any invalid keys that might have been added, # because constraint checks were disabled. self.connection.check_constraints(table_names=table_names) def _get_database_display_str(self, verbosity, database_name): """ Return display string for a database for use in various actions. """ return "'%s'%s" % ( self.connection.alias, (" ('%s')" % database_name) if verbosity >= 2 else "", ) def _get_test_db_name(self): """ Internal implementation - return the name of the test DB that will be created. Only useful when called from create_test_db() and _create_test_db() and when no external munging is done with the 'NAME' settings. """ if self.connection.settings_dict["TEST"]["NAME"]: return self.connection.settings_dict["TEST"]["NAME"] return TEST_DATABASE_PREFIX + self.connection.settings_dict["NAME"] def _execute_create_test_db(self, cursor, parameters, keepdb=False): cursor.execute("CREATE DATABASE %(dbname)s %(suffix)s" % parameters) def _create_test_db(self, verbosity, autoclobber, keepdb=False): """ Internal implementation - create the test db tables. """ test_database_name = self._get_test_db_name() test_db_params = { "dbname": self.connection.ops.quote_name(test_database_name), "suffix": self.sql_table_creation_suffix(), } # Create the test database and connect to it. with self._nodb_cursor() as cursor: try: self._execute_create_test_db(cursor, test_db_params, keepdb) except Exception as e: # if we want to keep the db, then no need to do any of the below, # just return and skip it all. if keepdb: return test_database_name self.log("Got an error creating the test database: %s" % e) if not autoclobber: confirm = input( "Type 'yes' if you would like to try deleting the test " "database '%s', or 'no' to cancel: " % test_database_name ) if autoclobber or confirm == "yes": try: if verbosity >= 1: self.log( "Destroying old test database for alias %s..." % ( self._get_database_display_str( verbosity, test_database_name ), ) ) cursor.execute("DROP DATABASE %(dbname)s" % test_db_params) self._execute_create_test_db(cursor, test_db_params, keepdb) except Exception as e: self.log("Got an error recreating the test database: %s" % e) sys.exit(2) else: self.log("Tests cancelled.") sys.exit(1) return test_database_name def clone_test_db(self, suffix, verbosity=1, autoclobber=False, keepdb=False): """ Clone a test database. """ source_database_name = self.connection.settings_dict["NAME"] if verbosity >= 1: action = "Cloning test database" if keepdb: action = "Using existing clone" self.log( "%s for alias %s..." % ( action, self._get_database_display_str(verbosity, source_database_name), ) ) # We could skip this call if keepdb is True, but we instead # give it the keepdb param. See create_test_db for details. self._clone_test_db(suffix, verbosity, keepdb) def get_test_db_clone_settings(self, suffix): """ Return a modified connection settings dict for the n-th clone of a DB. """ # When this function is called, the test database has been created # already and its name has been copied to settings_dict['NAME'] so # we don't need to call _get_test_db_name. orig_settings_dict = self.connection.settings_dict return { **orig_settings_dict, "NAME": "{}_{}".format(orig_settings_dict["NAME"], suffix), } def _clone_test_db(self, suffix, verbosity, keepdb=False): """ Internal implementation - duplicate the test db tables. """ raise NotImplementedError( "The database backend doesn't support cloning databases. " "Disable the option to run tests in parallel processes." ) def destroy_test_db( self, old_database_name=None, verbosity=1, keepdb=False, suffix=None ): """ Destroy a test database, prompting the user for confirmation if the database already exists. """ self.connection.close() if suffix is None: test_database_name = self.connection.settings_dict["NAME"] else: test_database_name = self.get_test_db_clone_settings(suffix)["NAME"] if verbosity >= 1: action = "Destroying" if keepdb: action = "Preserving" self.log( "%s test database for alias %s..." % ( action, self._get_database_display_str(verbosity, test_database_name), ) ) # if we want to preserve the database # skip the actual destroying piece. if not keepdb: self._destroy_test_db(test_database_name, verbosity) # Restore the original database name if old_database_name is not None: settings.DATABASES[self.connection.alias]["NAME"] = old_database_name self.connection.settings_dict["NAME"] = old_database_name def _destroy_test_db(self, test_database_name, verbosity): """ Internal implementation - remove the test db tables. """ # Remove the test database to clean up after # ourselves. Connect to the previous database (not the test database) # to do so, because it's not allowed to delete a database while being # connected to it. with self._nodb_cursor() as cursor: cursor.execute( "DROP DATABASE %s" % self.connection.ops.quote_name(test_database_name) ) def mark_expected_failures_and_skips(self): """ Mark tests in Django's test suite which are expected failures on this database and test which should be skipped on this database. """ # Only load unittest if we're actually testing. from unittest import expectedFailure, skip for test_name in self.connection.features.django_test_expected_failures: test_case_name, _, test_method_name = test_name.rpartition(".") test_app = test_name.split(".")[0] # Importing a test app that isn't installed raises RuntimeError. if test_app in settings.INSTALLED_APPS: test_case = import_string(test_case_name) test_method = getattr(test_case, test_method_name) setattr(test_case, test_method_name, expectedFailure(test_method)) for reason, tests in self.connection.features.django_test_skips.items(): for test_name in tests: test_case_name, _, test_method_name = test_name.rpartition(".") test_app = test_name.split(".")[0] # Importing a test app that isn't installed raises RuntimeError. if test_app in settings.INSTALLED_APPS: test_case = import_string(test_case_name) test_method = getattr(test_case, test_method_name) setattr(test_case, test_method_name, skip(reason)(test_method)) def sql_table_creation_suffix(self): """ SQL to append to the end of the test table creation statements. """ return "" def test_db_signature(self): """ Return a tuple with elements of self.connection.settings_dict (a DATABASES setting value) that uniquely identify a database accordingly to the RDBMS particularities. """ settings_dict = self.connection.settings_dict return ( settings_dict["HOST"], settings_dict["PORT"], settings_dict["ENGINE"], self._get_test_db_name(), ) def setup_worker_connection(self, _worker_id): settings_dict = self.get_test_db_clone_settings(str(_worker_id)) # connection.settings_dict must be updated in place for changes to be # reflected in django.db.connections. If the following line assigned # connection.settings_dict = settings_dict, new threads would connect # to the default database instead of the appropriate clone. self.connection.settings_dict.update(settings_dict) self.connection.close() PK �"�Z�>���z �z & __pycache__/operations.cpython-310.pycnu �[��� o �h q � @ s~ d dl Z d dlZd dlZd dlmZ d dlZd dlmZ d dlm Z m Z d dl m Z d dl mZ d dlmZ G dd � d �ZdS ) � N)� import_module)�settings)�NotSupportedError� transaction)�utils)�timezone�� force_strc @ s� e Zd ZdZdZdddddddddd � Zd d d d �Zi ZdZdZ dZ de Z de Z dZ dZdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd�d!d"�Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd�d+d,�Zd-d.� Z d/d0� Z d1d2� Z d3d4� Z d5d6� Z d7d8� Z!d�d;d<�Z"d=d>� Z#d?d@� Z$dAdB� Z%dCdD� Z&d�dEdF�Z'dGdH� Z(dIdJ� Z)dKdL� Z*dMdN� Z+dOdP� Z,dQdR� Z-dSdT� Z.dUdV� Z/dWdX� Z0dYdZ� Z1d[d\� Z2d]d^� Z3d_d`� Z4dadb� Z5d9d9dc�ddde�Z6dfdg� Z7dhdi� Z8djdk� Z9dldm� Z:d�dodp�Z;d�dqdr�Z<dsdt� Z=e=Z>dudv� Z?dwdx� Z@dydz� ZAd{d|� ZBd}d~� ZCdd�� ZDd�d�d��ZEd�d�� ZFd�d�� ZGd�d�d��ZHd�d�d��ZId�d�� ZJd�d�� ZKd�d�� ZLd�d�� ZMd�d�� ZNd�d�� ZOd�d�� ZPd�d�� ZQd�d�� ZRd�d�� ZSd�d�� ZTd�d�� ZUd�d�d��ZVd�d�d��ZWd�d�d��ZXd�d�d��ZYd�d�� ZZdS )��BaseDatabaseOperationsz� Encapsulate backend-specific differences, such as the way a backend performs ordering or calculates the ID of a recently-inserted row. z django.db.models.sql.compiler)i ���� )i ���)l���� � ���� )r r )r r )r r ) �SmallIntegerField� IntegerField�BigIntegerField�PositiveBigIntegerField�PositiveSmallIntegerField�PositiveIntegerField�SmallAutoField� AutoField� BigAutoField�UNION� INTERSECT�EXCEPT)�union� intersection� differenceN� PRECEDING� FOLLOWINGz UNBOUNDED z CURRENT ROWc C s || _ d | _d S �N)� connection�_cache)�selfr � r# �U/usr/local/CyberCP/lib/python3.10/site-packages/django/db/backends/base/operations.py�__init__: s z BaseDatabaseOperations.__init__c C � dS )z� Return any SQL needed to support auto-incrementing primary keys, or None if no SQL is necessary. This SQL is executed when a table is created. Nr# )r" �table�columnr# r# r$ � autoinc_sql> � z"BaseDatabaseOperations.autoinc_sqlc C s t |�S )z� Return the maximum allowed batch size for the backend. The fields are the fields going to be inserted in the batch, the objs contains all the objects to be inserted. )�len)r" �fields�objsr# r# r$ �bulk_batch_sizeG s z&BaseDatabaseOperations.bulk_batch_sizec C � t d��)Nz[subclasses of BaseDatabaseOperations may require a format_for_duration_arithmetic() method.��NotImplementedError�r" �sqlr# r# r$ � format_for_duration_arithmeticO s �z5BaseDatabaseOperations.format_for_duration_arithmeticc C s | � d�}d|� d|� d�S )z� Return an SQL query that retrieves the first cache key greater than the n smallest. This is used by the 'db' cache backend to determine where to start culling. � cache_keyzSELECT z FROM %s ORDER BY z LIMIT 1 OFFSET %%s�� quote_name)r" r5 r# r# r$ �cache_key_culling_sqlU s z,BaseDatabaseOperations.cache_key_culling_sqlc C r& )z� Given a field instance, return the SQL that casts the result of a union to that type. The resulting string should contain a '%s' placeholder for the expression being cast. �%sr# )r" � output_fieldr# r# r$ �unification_cast_sql` � z+BaseDatabaseOperations.unification_cast_sqlc C r/ )z� Given a lookup_type of 'year', 'month', or 'day', return the SQL that extracts a value from the given date field field_name. zLsubclasses of BaseDatabaseOperations may require a date_extract_sql() methodr0 �r" � lookup_typer3 �paramsr# r# r$ �date_extract_sqlh � �z'BaseDatabaseOperations.date_extract_sqlc C r/ )a. Given a lookup_type of 'year', 'month', or 'day', return the SQL that truncates the given date or datetime field field_name to a date object with only the given specificity. If `tzname` is provided, the given value is truncated in a specific timezone. zKsubclasses of BaseDatabaseOperations may require a date_trunc_sql() method.r0 �r" r> r3 r? �tznamer# r# r$ �date_trunc_sqlr � �z%BaseDatabaseOperations.date_trunc_sqlc C r/ )zH Return the SQL to cast a datetime value to date value. zSsubclasses of BaseDatabaseOperations may require a datetime_cast_date_sql() method.r0 �r" r3 r? rC r# r# r$ �datetime_cast_date_sql� � �z-BaseDatabaseOperations.datetime_cast_date_sqlc C r/ )zH Return the SQL to cast a datetime value to time value. zRsubclasses of BaseDatabaseOperations may require a datetime_cast_time_sql() methodr0 rF r# r# r$ �datetime_cast_time_sql� rH z-BaseDatabaseOperations.datetime_cast_time_sqlc C r/ )z� Given a lookup_type of 'year', 'month', 'day', 'hour', 'minute', or 'second', return the SQL that extracts a value from the given datetime field field_name. zPsubclasses of BaseDatabaseOperations may require a datetime_extract_sql() methodr0 rB r# r# r$ �datetime_extract_sql� � �z+BaseDatabaseOperations.datetime_extract_sqlc C r/ )z� Given a lookup_type of 'year', 'month', 'day', 'hour', 'minute', or 'second', return the SQL that truncates the given datetime field field_name to a datetime object with only the given specificity. zNsubclasses of BaseDatabaseOperations may require a datetime_trunc_sql() methodr0 rB r# r# r$ �datetime_trunc_sql� rK z)BaseDatabaseOperations.datetime_trunc_sqlc C r/ )a1 Given a lookup_type of 'hour', 'minute' or 'second', return the SQL that truncates the given time or datetime field field_name to a time object with only the given specificity. If `tzname` is provided, the given value is truncated in a specific timezone. zJsubclasses of BaseDatabaseOperations may require a time_trunc_sql() methodr0 rB r# r# r$ �time_trunc_sql� rE z%BaseDatabaseOperations.time_trunc_sqlc C s | � |||�S )z� Given a lookup_type of 'hour', 'minute', or 'second', return the SQL that extracts a value from the given time field field_name. )r@ r= r# r# r$ �time_extract_sql� � z'BaseDatabaseOperations.time_extract_sqlc C r& )zs Return the SQL to make a constraint "initially deferred" during a CREATE TABLE statement. � r# �r" r# r# r$ �deferrable_sql� � z%BaseDatabaseOperations.deferrable_sqlc C s |rt d��dgg fS )z� Return an SQL DISTINCT clause which removes duplicate rows from the result set. If any fields are given, only check the given fields for duplicates. z<DISTINCT ON fields is not supported by this database backend�DISTINCT)r )r" r, r? r# r# r$ � distinct_sql� s � z#BaseDatabaseOperations.distinct_sqlc C s |� � S )z� Given a cursor object that has just performed an INSERT...RETURNING statement into a table, return the newly created data. )�fetchone)r" �cursor�returning_paramsr# r# r$ � fetch_returned_insert_columns� � z4BaseDatabaseOperations.fetch_returned_insert_columnsc C r& )a) Given a column type (e.g. 'BLOB', 'VARCHAR') and an internal type (e.g. 'GenericIPAddressField'), return the SQL to cast it before using it in a WHERE statement. The resulting string should contain a '%s' placeholder for the column being searched against. r9 r# )r" �db_type� internal_typer# r# r$ �field_cast_sql� r* z%BaseDatabaseOperations.field_cast_sqlc C � g S )z� Return a list used in the "ORDER BY" clause to force no ordering at all. Return an empty list to include nothing in the ordering. r# rQ r# r# r$ �force_no_ordering� rS z(BaseDatabaseOperations.force_no_orderingFr# c C s> d|rdnd|rdd� |� nd|rdnd|rdf S df S )zX Return the FOR UPDATE SQL clause to lock rows for an update operation. zFOR%s UPDATE%s%s%sz NO KEYrP z OF %s�, z NOWAITz SKIP LOCKED��join)r" �nowait� skip_locked�of�no_keyr# r# r$ �for_update_sql� s ��z%BaseDatabaseOperations.for_update_sqlc C s8 |pd}|d ur|| |fS |r| j j�� |fS d |fS �Nr )r �ops�no_limit_value)r" �low_mark� high_mark�offsetr# r# r$ �_get_limit_offset_params� s z/BaseDatabaseOperations._get_limit_offset_paramsc C s@ | � ||�\}}d�dd� |rd| nd|rd| ndfD ��S )z Return LIMIT/OFFSET SQL clause.� c s s � | ]}|r|V qd S r r# )�.0r3 r# r# r$ � <genexpr>� s � � �z:BaseDatabaseOperations.limit_offset_sql.<locals>.<genexpr>zLIMIT %dNz OFFSET %d)rn rb )r" rk rl �limitrm r# r# r$ �limit_offset_sql� s ��z'BaseDatabaseOperations.limit_offset_sqlc s^ dd� � t |ttf�rt� fdd�|D ��}n|du r d}n � fdd�|�� D �}d ||f S ) a� Return a string of the query last executed by the given cursor, with placeholders replaced with actual values. `sql` is the raw query containing placeholders and `params` is the sequence of parameters. These are used by default, but this method exists for database backends to provide a better implementation according to their own quoting schemes. c S s t | ddd�S )NT�replace)� strings_only�errorsr )�sr# r# r$ � to_string � z=BaseDatabaseOperations.last_executed_query.<locals>.to_stringc 3 s � | ]}� |�V qd S r r# )rp �val�rx r# r$ rq s � z=BaseDatabaseOperations.last_executed_query.<locals>.<genexpr>Nr# c s i | ] \}}� |�� |��qS r# r# )rp �k�vr{ r# r$ � <dictcomp> s z>BaseDatabaseOperations.last_executed_query.<locals>.<dictcomp>zQUERY = %r - PARAMS = %r)� isinstance�list�tuple�items)r" rW r3 r? �u_paramsr# r{ r$ �last_executed_query s z*BaseDatabaseOperations.last_executed_queryc C s |j S )z� Given a cursor object that has just performed an INSERT statement into a table that has an auto-incrementing ID, return the newly created ID. `pk_name` is the name of the primary-key column. )� lastrowid)r" rW � table_name�pk_namer# r# r$ �last_insert_id s z%BaseDatabaseOperations.last_insert_idc C r& )z� Return the string to use in a query when performing lookups ("contains", "like", etc.). It should contain a '%s' placeholder for the column being searched against. r9 r# )r" r> r\ r# r# r$ � lookup_cast' r< z"BaseDatabaseOperations.lookup_castc C r& )z� Return the maximum number of items that can be passed in a single 'IN' list condition, or None if the backend does not impose a limit. Nr# rQ r# r# r$ �max_in_list_size/ rS z'BaseDatabaseOperations.max_in_list_sizec C r& )zl Return the maximum length of table and column names, or None if there is no limit. Nr# rQ r# r# r$ �max_name_length6 rS z&BaseDatabaseOperations.max_name_lengthc C r/ )z� Return the value to use for the LIMIT when we are wanting "LIMIT infinity". Return None if the limit clause can be omitted in this case. zJsubclasses of BaseDatabaseOperations may require a no_limit_value() methodr0 rQ r# r# r$ rj = rA z%BaseDatabaseOperations.no_limit_valuec C r& )z� Return the value to use during an INSERT statement to specify that the field should use its default value. �DEFAULTr# rQ r# r# r$ �pk_default_valueF rS z'BaseDatabaseOperations.pk_default_valuec C s dd� t �|�D �S )ag Take an SQL script that may contain multiple lines and return a list of statements to feed to successive cursor.execute() calls. Since few databases are able to process raw SQL scripts in a single cursor.execute() call and PEP 249 doesn't talk about this use case, the default implementation is conservative. c S s g | ] }|rt j|d d��qS )T)�strip_comments)�sqlparse�format)rp � statementr# r# r$ � <listcomp>V s � �z=BaseDatabaseOperations.prepare_sql_script.<locals>.<listcomp>)r� �splitr2 r# r# r$ �prepare_sql_scriptM s �z)BaseDatabaseOperations.prepare_sql_scriptc C � |S )z� Return the value of a CLOB column, for backends that return a locator object that requires additional processing. r# �r" �valuer# r# r$ � process_clob\ rS z#BaseDatabaseOperations.process_clobc C r& )z� For backends that support returning columns as part of an insert query, return the SQL and params to append to the INSERT query. The returned fragment should contain a format string to hold the appropriate column. Nr# )r" r, r# r# r$ �return_insert_columnsc r< z,BaseDatabaseOperations.return_insert_columnsc C s" | j du r t| j�| _ t| j |�S )z� Return the SQLCompiler class corresponding to the given name, in the namespace corresponding to the `compiler_module` attribute on this backend. N)r! r �compiler_module�getattr)r" � compiler_namer# r# r$ �compilerk s z BaseDatabaseOperations.compilerc C r/ )z� Return a quoted version of the given table, index, or column name. Do not quote the given name if it's already been quoted. zFsubclasses of BaseDatabaseOperations may require a quote_name() methodr0 )r" �namer# r# r$ r7 u rA z!BaseDatabaseOperations.quote_namec C r/ )aG Return the string to use in a query when performing regular expression lookups (using "regex" or "iregex"). It should contain a '%s' placeholder for the column being searched against. If the feature is not supported (or part of it is not supported), raise NotImplementedError. zHsubclasses of BaseDatabaseOperations may require a regex_lookup() methodr0 )r" r> r# r# r$ � regex_lookup~ rE z#BaseDatabaseOperations.regex_lookupc C � d| � |� S )z� Return the SQL for starting a new savepoint. Only required if the "uses_savepoints" feature is True. The "sid" parameter is a string for the savepoint id. z SAVEPOINT %sr6 �r" �sidr# r# r$ �savepoint_create_sql� s z+BaseDatabaseOperations.savepoint_create_sqlc C r� )zD Return the SQL for committing the given savepoint. zRELEASE SAVEPOINT %sr6 r� r# r# r$ �savepoint_commit_sql� � z+BaseDatabaseOperations.savepoint_commit_sqlc C r� )zF Return the SQL for rolling back the given savepoint. zROLLBACK TO SAVEPOINT %sr6 r� r# r# r$ �savepoint_rollback_sql� r� z-BaseDatabaseOperations.savepoint_rollback_sqlc C r& )z� Return the SQL that will set the connection's time zone. Return '' if the backend doesn't support time zones. rP r# rQ r# r# r$ �set_time_zone_sql� r< z(BaseDatabaseOperations.set_time_zone_sql)�reset_sequences� allow_cascadec C r/ )a� Return a list of SQL statements required to remove all data from the given database tables (without actually removing the tables themselves). The `style` argument is a Style object as returned by either color_style() or no_style() in django.core.management.color. If `reset_sequences` is True, the list includes SQL statements required to reset the sequences. The `allow_cascade` argument determines whether truncation may cascade to tables with foreign keys pointing the tables being truncated. PostgreSQL requires a cascade even if these tables are empty. zGsubclasses of BaseDatabaseOperations must provide an sql_flush() methodr0 )r" �style�tablesr� r� r# r# r$ � sql_flush� s �z BaseDatabaseOperations.sql_flushc C s� t j| jj| jjjd��0 | j�� �}|D ]}|�|� qW d � n1 s'w Y W d � dS W d � dS 1 s?w Y dS )z7Execute a list of SQL statements to flush the database.)�using� savepointN)r �atomicr �alias�features�can_rollback_ddlrW �execute)r" �sql_listrW r3 r# r# r$ �execute_sql_flush� s � � ��"�z(BaseDatabaseOperations.execute_sql_flushc C r^ )z� Return a list of the SQL statements required to reset sequences passed in `sequences`. The `style` argument is a Style object as returned by either color_style() or no_style() in django.core.management.color. r# )r" r� � sequencesr# r# r$ �sequence_reset_by_name_sql� � z1BaseDatabaseOperations.sequence_reset_by_name_sqlc C r^ )z� Return a list of the SQL statements required to reset sequences for the given models. The `style` argument is a Style object as returned by either color_style() or no_style() in django.core.management.color. r# )r" r� � model_listr# r# r$ �sequence_reset_sql� r� z)BaseDatabaseOperations.sequence_reset_sqlc C r& )z9Return the SQL statement required to start a transaction.zBEGIN;r# rQ r# r# r$ �start_transaction_sql� s z,BaseDatabaseOperations.start_transaction_sqlTc C s |sdS dS )z7Return the SQL statement required to end a transaction.z ROLLBACK;zCOMMIT;r# )r" �successr# r# r$ �end_transaction_sql� s z*BaseDatabaseOperations.end_transaction_sqlc C r& )a Return the SQL that will be used in a query to define the tablespace. Return '' if the backend doesn't support tablespaces. If `inline` is True, append the SQL to a row; otherwise append it to the entire CREATE TABLE or CREATE INDEX statement. rP r# )r" � tablespace�inliner# r# r$ �tablespace_sql� � z%BaseDatabaseOperations.tablespace_sqlc C s t |��dd��dd��dd�S )z(Prepare a value for use in a LIKE query.�\z\\�%z\%�_z\_)�strrt )r" �xr# r# r$ �prep_for_like_query� s z*BaseDatabaseOperations.prep_for_like_queryc C r� )z� Certain backends do not accept some values for "serial" fields (for example zero in MySQL). Raise a ValueError if the value is invalid, otherwise return the validated value. r# r� r# r# r$ �validate_autopk_value� r< z,BaseDatabaseOperations.validate_autopk_valuec C s\ t |tj�r | �|�S t |tj�r| �|�S t |tj�r!| �|�S t |tj�r,| � |�S |S )a8 Transform a value to something compatible with the backend driver. This method only depends on the type of the value. It's designed for cases where the target type isn't known, such as .raw() SQL queries. As a consequence it may not work perfectly in all circumstances. ) r �datetime�adapt_datetimefield_value�date�adapt_datefield_value�time�adapt_timefield_value�decimal�Decimal�adapt_decimalfield_valuer� r# r# r$ �adapt_unknown_value� s z*BaseDatabaseOperations.adapt_unknown_valuec C r� r r# )r" r� r\ r# r# r$ �adapt_integerfield_value � z/BaseDatabaseOperations.adapt_integerfield_valuec C s |du rdS t |�S )z� Transform a date value to an object compatible with what is expected by the backend driver for date columns. N)r� r� r# r# r$ r� s z,BaseDatabaseOperations.adapt_datefield_valuec C s" |du rdS t |d�r |S t|�S )z� Transform a datetime value to an object compatible with what is expected by the backend driver for datetime columns. N�resolve_expression)�hasattrr� r� r# r# r$ r� s z0BaseDatabaseOperations.adapt_datetimefield_valuec C s4 |du rdS t |d�r |S t�|�rtd��t|�S )z� Transform a time value to an object compatible with what is expected by the backend driver for time columns. Nr� z-Django does not support timezone-aware times.)r� r �is_aware� ValueErrorr� r� r# r# r$ r� * s z,BaseDatabaseOperations.adapt_timefield_valuec C s t �|||�S )z� Transform a decimal.Decimal value to an object compatible with what is expected by the backend driver for decimal (numeric) columns. )r � format_number)r" r� � max_digits�decimal_placesr# r# r$ r� 9 rO z/BaseDatabaseOperations.adapt_decimalfield_valuec C s |pdS )z{ Transform a string representation of an IP address into the expected type for the backend driver. Nr# r� r# r# r$ �adapt_ipaddressfield_value@ rZ z1BaseDatabaseOperations.adapt_ipaddressfield_valuec C s t j||d�S )N)�cls)�json�dumps)r" r� �encoderr# r# r$ �adapt_json_valueG ry z'BaseDatabaseOperations.adapt_json_valuec C sn |rt j�|dd�}t j�|d dd�t jdd� }nt �|dd�}t �|dd�}| �|�}| �|�}||gS )a9 Return a two-elements list with the lower and upper bound to be used with a BETWEEN operator to query a DateField value using a year lookup. `value` is an int, containing the looked-up year. If `iso_year` is True, return bounds for ISO-8601 week-numbering years. � )�days� � )r� r� �fromisocalendar� timedeltar� )r" r� �iso_year�first�secondr# r# r$ �!year_lookup_bounds_for_date_fieldJ s � � z8BaseDatabaseOperations.year_lookup_bounds_for_date_fieldc C s� |rt j �|dd�}t j �|d dd�t jdd� }nt � |dd�}t � |dddddd�}tjr@t�� }t�||�}t�||�}| �|�}| �|�}||gS )a= Return a two-elements list with the lower and upper bound to be used with a BETWEEN operator to query a DateTimeField value using a year lookup. `value` is an int, containing the looked-up year. If `iso_year` is True, return bounds for ISO-8601 week-numbering years. r� )� microsecondsr� r� � �; i?B ) r� r� r� r �USE_TZr �get_current_timezone� make_awarer� )r" r� r� r� r� �tzr# r# r$ �%year_lookup_bounds_for_datetime_field_ s � � z<BaseDatabaseOperations.year_lookup_bounds_for_datetime_fieldc C r^ )z� Return a list of functions needed to convert field data. Some field types on some backends do not provide data in the correct format, this is the hook for converter functions. r# �r" � expressionr# r# r$ �get_db_convertersx r* z(BaseDatabaseOperations.get_db_convertersc C s |d ur t �dd|�S d S rh )r� r� )r" r� r� r r# r# r$ �convert_durationfield_value� s �z2BaseDatabaseOperations.convert_durationfield_valuec C r& )a4 Check that the backend supports the provided expression. This is used on specific backends to rule out known expressions that have problematic or nonexistent implementations. If the expression has a known problem, the backend should raise NotSupportedError. Nr# r� r# r# r$ �check_expression_support� r� z/BaseDatabaseOperations.check_expression_supportc C r& )zf Return True, if the conditional expression is supported in the WHERE clause. Tr# r� r# r# r$ �0conditional_expression_supported_in_where_clause� rS zGBaseDatabaseOperations.conditional_expression_supported_in_where_clausec C s d| }|� |�S )a Combine a list of subexpressions into a single expression, using the provided connecting operator. This is required because operators can vary between backends (e.g., Oracle with %% and &) and between subexpression types (e.g., date expressions). z %s ra )r" � connector�sub_expressions�connr# r# r$ �combine_expression� s z)BaseDatabaseOperations.combine_expressionc C s | � ||�S r )r� )r" r� r� r# r# r$ �combine_duration_expression� s z2BaseDatabaseOperations.combine_duration_expressionc C r& )z~ Some backends require special syntax to insert binary content (MySQL for example uses '_binary %s'). r9 r# r� r# r# r$ �binary_placeholder_sql� rS z-BaseDatabaseOperations.binary_placeholder_sqlc C s |S )zs Allow modification of insert parameters. Needed for Oracle Spatial backend due to #10888. r# )r" � placeholderr? r# r# r$ �modify_insert_params� rS z+BaseDatabaseOperations.modify_insert_paramsc C s | j | S )z� Given an integer field internal type (e.g. 'PositiveIntegerField'), return a tuple of the (min_value, max_value) form representing the range of the column type bound to the field. )�integer_field_ranges)r" r\ r# r# r$ �integer_field_range� s z*BaseDatabaseOperations.integer_field_rangec C s@ | j jjr|\}}|\}}d||f g |�|�R fS td| ��)Nz (%s - %s)z-This backend does not support %s subtraction.)r r� � supports_temporal_subtractionr )r" r\ �lhs�rhs�lhs_sql� lhs_params�rhs_sql� rhs_paramsr# r# r$ �subtract_temporals� s �z)BaseDatabaseOperations.subtract_temporalsc C sN t |t�r|dk rdt|�| jf S |dkr| jS n|d u r!| jS td| ��)Nr �%d %szGstart argument must be a negative integer, zero, or None, but got '%s'.)r �int�absr � CURRENT_ROW�UNBOUNDED_PRECEDINGr� )r" �startr# r# r$ �window_frame_start� s ���z)BaseDatabaseOperations.window_frame_startc C sJ t |t�r|dkr | jS |dkrd|| jf S n|d u r | jS td| ��)Nr r zEend argument must be a positive integer, zero, or None, but got '%s'.)r r r r �UNBOUNDED_FOLLOWINGr� )r" �endr# r# r$ �window_frame_end� s ���z'BaseDatabaseOperations.window_frame_endc C s& | j jjs td��| �|�| �|�fS )zU Return SQL for start and end points in an OVER clause window frame. z1This backend does not support window expressions.)r r� �supports_over_clauser r r )r" r r r# r# r$ �window_frame_rows_start_end� s z2BaseDatabaseOperations.window_frame_rows_start_endc C sN | � ||�\}}| jj}|jr#|r|dk s|r#|dkr#td| jj ��||fS )Nr zA%s only supports UNBOUNDED together with PRECEDING and FOLLOWING.)r r r� �4only_supports_unbounded_with_preceding_and_followingr � display_name)r" r r �start_�end_r� r# r# r$ � window_frame_range_start_end� s ���z3BaseDatabaseOperations.window_frame_range_start_endc K s� | j jjs td��|r;| j jj}|�� }||vr;d| }|r-|dd�t|�� 7 }t |��|d| j j� d�7 }t |��|rJt dd�t|� � �� ��| j S )Nz9This backend does not support explaining query execution.z %s is not a recognized format.z Allowed formats: %sr` ro z does not support any formats.zUnknown options: %s) r r� �#supports_explaining_query_executionr �supported_explain_formats�upperrb �sortedr r� �keys�explain_prefix)r" r� �options�supported_formats�normalized_format�msgr# r# r$ �explain_query_prefix� s& � ��z+BaseDatabaseOperations.explain_query_prefixc C r& )Nz INSERT INTOr# )r" � on_conflictr# r# r$ �insert_statement r� z'BaseDatabaseOperations.insert_statementc C r& )NrP r# )r" r, r( � update_fields� unique_fieldsr# r# r$ �on_conflict_suffix_sql r� z-BaseDatabaseOperations.on_conflict_suffix_sqlr )FFr# F)T)F)NN)[�__name__� __module__� __qualname__�__doc__r� r � set_operators�cast_data_types�"cast_char_field_without_max_lengthr r r r r r" r% r) r. r4 r8 r; r@ rD rG rI rJ rL rM rN rR rU rY r] r_ rg rn rs r� r� r� r� r� rj r� r� r� r� r� r7 r� r� r� r� r� r� r� r� r� r� r� r� r� �prep_for_iexact_queryr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r' r) r, r# r# r# r$ r s� � � r )r� r� r� � importlibr r� � django.confr � django.dbr r �django.db.backendsr � django.utilsr �django.utils.encodingr r r# r# r# r$ �<module> s PK �"�Z� q�� � $ __pycache__/__init__.cpython-310.pycnu �[��� o �h � @ s d S )N� r r r �S/usr/local/CyberCP/lib/python3.10/site-packages/django/db/backends/base/__init__.py�<module> s PK �"�Z�R��� � " __pycache__/client.cpython-310.pycnu �[��� o �h� � @ s" d dl Z d dlZG dd� d�ZdS )� Nc @ s0 e Zd ZdZdZdd� Zedd� �Zdd� ZdS ) �BaseDatabaseClientz@Encapsulate backend-specific methods for opening a client shell.Nc C s || _ d S )N)� connection)�selfr � r �Q/usr/local/CyberCP/lib/python3.10/site-packages/django/db/backends/base/client.py�__init__ s zBaseDatabaseClient.__init__c C s t d��)Nzksubclasses of BaseDatabaseClient must provide a settings_to_cmd_args_env() method or override a runshell().)�NotImplementedError)�cls� settings_dict� parametersr r r �settings_to_cmd_args_env s �z+BaseDatabaseClient.settings_to_cmd_args_envc C s> | � | jj|�\}}|ri tj�|�nd }tj||dd� d S )NT)�env�check)r r r �os�environ� subprocess�run)r r �argsr r r r �runshell s �zBaseDatabaseClient.runshell) �__name__� __module__� __qualname__�__doc__�executable_namer � classmethodr r r r r r r s r )r r r r r r r �<module> s PK �"�Z����* �* $ __pycache__/creation.cpython-310.pycnu �[��� o �h4= � @ sz d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlm Z d dl m Z d dl m Z d dlmZ d ZG d d � d �ZdS ) � N)�StringIO)�apps)�settings)� serializers)�router)�atomic)� import_string�test_c @ s� e Zd ZdZdd� Zdd� Zdd� Z d.d d �Zd d� Zdd� Z dd� Z dd� Z dd� Z d/dd�Z d/dd�Zd0dd �Zd d � Zd/d d �Z !d1d"d#�Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd!S )2�BaseDatabaseCreationzs Encapsulate backend-specific differences pertaining to creation and destruction of the test database. c C s || _ d S �N)� connection)�selfr � r �S/usr/local/CyberCP/lib/python3.10/site-packages/django/db/backends/base/creation.py�__init__ � z BaseDatabaseCreation.__init__c C s | j �� S r )r � _nodb_cursor�r r r r r r z!BaseDatabaseCreation._nodb_cursorc C s t j�|tj � d S r )�sys�stderr�write�os�linesep)r �msgr r r �log s zBaseDatabaseCreation.log� FTc C sH ddl m} | �� }|dkr!d}|rd}| �d|| �||�f � | �|||� | j�� |tj | jj d< || jj d< z6| jj d d d u rTtj }d d � t �� D �t_ |d t|d d�d | jj dd� W | jj d d d u rr|t_ n| jj d d d u r�|t_ w |r�| �� | j_|d| jj d� | j�� tj�d�dkr�| �� |S )z� Create a test database, prompting the user for confirmation if the database already exists. Return the name of the test database created. r )� call_commandr �CreatingzUsing existing� %s test database for alias %s...�NAME�TEST�MIGRATEFc S s i | ]}|j d �qS r )�label)�.0�appr r r � <dictcomp>H s �z7BaseDatabaseCreation.create_test_db.<locals>.<dictcomp>�migrateT)� verbosity� interactive�database� run_syncdb�createcachetable)r) �RUNNING_DJANGOS_TEST_SUITE�true)�django.core.managementr �_get_test_db_namer �_get_database_display_str�_create_test_dbr �closer � DATABASES�alias� settings_dict�MIGRATION_MODULESr �get_app_configs�max�serialize_db_to_string�_test_serialized_contents�ensure_connectionr �environ�get� mark_expected_failures_and_skips) r r' � autoclobber� serialize�keepdbr �test_database_name�action�old_migration_modulesr r r �create_test_db sT ��� � ��� z#BaseDatabaseCreation.create_test_dbc C s |d | j jd< dS )z� Set this database up to be used in testing as a mirror of a primary database whose settings are given. r N)r r5 )r �primary_settings_dictr r r �set_as_test_mirrorj s z'BaseDatabaseCreation.set_as_test_mirrorc s. � fdd�}t � }tjd|� d|d� |�� S )z� Serialize all data in the database into a JSON string. Designed only for test runner usage; will not handle large amounts of data. c 3 s� � ddl m} | � j�}t�� D ]>}|jd urN|j|jv rN|jt j vrN|� � D ]&}|j � � j�rMt�� jj|�rM|j�� jj��|j jj�}|�� E d H q'qd S )Nr )�MigrationLoader)�django.db.migrations.loaderrH r r r7 � models_moduler" � migrated_apps�namer �TEST_NON_SERIALIZED_APPS� get_models�_meta� can_migrater �allow_migrate_modelr4 � _base_manager�using�order_by�pk�iterator)rH �loader� app_config�model�querysetr r r � get_objectsy s* � ��� ���z@BaseDatabaseCreation.serialize_db_to_string.<locals>.get_objects�jsonN)�indent�stream)r r r@ �getvalue)r r[ �outr r r r9 q s z+BaseDatabaseCreation.serialize_db_to_stringc C s� t |�}t� }t| jjd��? | j�� �" tjd|| jjd�D ]}|�� |� |j j j j � q W d � n1 s9w Y | jj|d� W d � dS 1 sPw Y dS )zw Reload the database with data from a string generated by the serialize_db_to_string() method. )rS r\ N)� table_names)r �setr r r4 �constraint_checks_disabledr � deserialize�save�add�object� __class__rO �db_table�check_constraints)r �datara �objr r r �deserialize_db_from_string� s �� �"�z/BaseDatabaseCreation.deserialize_db_from_stringc C s$ d| j j|dkrd| f S df S )zR Return display string for a database for use in various actions. z'%s'%s� z ('%s')� )r r4 )r r' � database_namer r r r0 � s ��z.BaseDatabaseCreation._get_database_display_strc C s0 | j jd d r| j jd d S t| j jd S )z� Internal implementation - return the name of the test DB that will be created. Only useful when called from create_test_db() and _create_test_db() and when no external munging is done with the 'NAME' settings. r r )r r5 �TEST_DATABASE_PREFIXr r r r r/ � s z&BaseDatabaseCreation._get_test_db_namec C s |� d| � d S )Nz%CREATE DATABASE %(dbname)s %(suffix)s)�execute)r �cursor� parametersrA r r r �_execute_create_test_db� s z,BaseDatabaseCreation._execute_create_test_dbc C st | � � }| jj�|�| �� d�}| �� ��}z | �|||� W n� ty� } zu|r7|W Y d}~W d � S | �d| � |sFt d| �}|sL|dkr�z |dkr]| �d| � ||�f � |� d| � | �|||� W n( ty� } z| �d | � t � d � W Y d}~nd}~ww | �d � t � d� W Y d}~n d}~ww W d � |S W d � |S 1 s�w Y |S ) zF Internal implementation - create the test db tables. )�dbname�suffixNz+Got an error creating the test database: %szXType 'yes' if you would like to try deleting the test database '%s', or 'no' to cancel: �yesr z,Destroying old test database for alias %s...zDROP DATABASE %(dbname)sz-Got an error recreating the test database: %srn zTests cancelled.)r/ r �ops� quote_name�sql_table_creation_suffixr ru � Exceptionr �inputr0 rr r �exit) r r' r? rA rB �test_db_paramsrs �e�confirmr r r r1 � s` � � �� ������ ��� �#� �#�#z$BaseDatabaseCreation._create_test_dbc C sL | j jd }|dkr d}|rd}| �d|| �||�f � | �|||� dS )z( Clone a test database. r r zCloning test databasezUsing existing clonez%s for alias %s...N)r r5 r r0 �_clone_test_db)r rw r' r? rA �source_database_namerC r r r � clone_test_db� s ��� z"BaseDatabaseCreation.clone_test_dbc C s$ | j j}i |�dd�|d |�i�S )zX Return a modified connection settings dict for the n-th clone of a DB. r z{}_{})r r5 �format)r rw �orig_settings_dictr r r �get_test_db_clone_settings s ��z/BaseDatabaseCreation.get_test_db_clone_settingsc C s t d��)zI Internal implementation - duplicate the test db tables. znThe database backend doesn't support cloning databases. Disable the option to run tests in parallel processes.)�NotImplementedError)r rw r' rA r r r r� s �z#BaseDatabaseCreation._clone_test_dbNc C s� | j �� |du r| j jd }n| �|�d }|dkr.d}|r!d}| �d|| �||�f � |s6| �||� |durK|tj| j j d< || j jd< dS dS )zv Destroy a test database, prompting the user for confirmation if the database already exists. Nr r � Destroying� Preservingr ) r r2 r5 r� r r0 �_destroy_test_dbr r3 r4 )r �old_database_namer' rA rw rB rC r r r �destroy_test_db s* ��� �z$BaseDatabaseCreation.destroy_test_dbc C sF | � � �}|�d| jj�|� � W d � dS 1 s w Y dS )zF Internal implementation - remove the test db tables. zDROP DATABASE %sN)r rr r ry rz )r rB r' rs r r r r� ; s �"�z%BaseDatabaseCreation._destroy_test_dbc C s� ddl m}m} | jjjD ]'}|�d�\}}}|�d�d }|tj v r4t |�}t ||�} t |||| �� q | jjj �� D ]0\} } | D ])}|�d�\}}}|�d�d }|tj v rkt |�}t ||�} t |||| �| �� qBq<dS )z� Mark tests in Django's test suite which are expected failures on this database and test which should be skipped on this database. r )�expectedFailure�skip�.N)�unittestr� r� r �features� django_test_expected_failures� rpartition�splitr �INSTALLED_APPSr �getattr�setattr�django_test_skips�items) r r� r� � test_name�test_case_name�_�test_method_name�test_app� test_case� test_method�reason�testsr r r r> H s( � ���z5BaseDatabaseCreation.mark_expected_failures_and_skipsc C s dS )zQ SQL to append to the end of the test table creation statements. ro r r r r r r{ b s z.BaseDatabaseCreation.sql_table_creation_suffixc C s$ | j j}|d |d |d | �� fS )z� Return a tuple with elements of self.connection.settings_dict (a DATABASES setting value) that uniquely identify a database accordingly to the RDBMS particularities. �HOST�PORT�ENGINE)r r5 r/ )r r5 r r r �test_db_signatureh s �z&BaseDatabaseCreation.test_db_signaturec C s* | � t|��}| jj�|� | j�� d S r )r� �strr r5 �updater2 )r � _worker_idr5 r r r �setup_worker_connectionv s z,BaseDatabaseCreation.setup_worker_connection)r FTF)F)r FF)Nr FN)�__name__� __module__� __qualname__�__doc__r r r rE rG r9 rm r0 r/ ru r1 r� r� r� r� r� r> r{ r� r� r r r r r s0 �J / �# r )r r �ior � django.appsr � django.confr � django.corer � django.dbr �django.db.transactionr �django.utils.module_loadingr rq r r r r r �<module> s PK �"�Z��9� 9� " __pycache__/schema.cpython-310.pycnu �[��� o �hd � @ s� d dl Z d dlZd dlmZ d dlmZ d dlmZmZmZm Z m Z m Z d dl m Z mZmZ d dlmZmZ d dlmZ d dlmZmZ d d lmZ e �d �Zd d � Z d d� Z dd� Z G dd� d�Z dS )� N)�datetime)�settings)�Columns� Expressions�ForeignKeyName� IndexName� Statement�Table)� names_digest�split_identifier� truncate_name)� Deferrable�Index)�Query)�TransactionManagementError�atomic)�timezonezdjango.db.backends.schemac C s2 | j }|jrdS |jr|jdgkrdS |j|jv S )zz When altering the given field, must constraints on its model from the given relation be temporarily dropped? FNT)�field� many_to_many� primary_key� to_fields�name)�relation� altered_fieldr � r �Q/usr/local/CyberCP/lib/python3.10/site-packages/django/db/backends/base/schema.py�_is_relevant_relation s r c C s" t | jjddddd�t�d�d�S )NFT)�forward�reverse�include_hidden�include_parentsr )�key)�sorted�_meta� _get_fields�operator� attrgetter��modelr r r �_all_related_fields' s ��r) c # sd � t �fdd�t�j�D �� fdd�t� j�D ��}|D ]\}}||fV t|j|j�E d H q d S )Nc 3 � � | ] }t |� �r|V qd S �N�r ��.0�obj)� old_fieldr r � <genexpr>8 � � � �z+_related_non_m2m_objects.<locals>.<genexpr>c 3 r* r+ r, r- )� new_fieldr r r1 = r2 )�zipr) r( �_related_non_m2m_objects� remote_field)r0 r3 �related_fields�old_rel�new_relr )r3 r0 r r5 4 s � � �� ��r5 c @ sL e Zd ZdZdZdZdZdZdZdZ dZ d Z d Z d Z d ZeZd ZdZdZdZdZdZdZdZeZdZeZdZdZ dZ eZ dZ dZ dZ!dZ"d Z#eZ$d Z%d Z&d Z'd�d"d#�Z(d$d%� Z)d&d'� Z*d�d)d*�Z+d+d,� Z,d-d.� Z-d/d0� Z.d�d1d2�Z/d3d4� Z0d5d6� Z1d7d8� Z2d9d:� Z3e4d;d<� �Z5d=d>� Z6d?d@� Z7dAdB� Z8dCdD� Z9dEdF� Z:dGdH� Z;dIdJ� Z<dKdL� Z=dMdN� Z>dOdP� Z?dQdR� Z@dSdT� ZAdUdV� ZBdWdX� ZCdYdZ� ZDd[d\� ZEd]d^� ZFd�d_d`�ZG d�dadb�ZHdcdd� ZId�dedf�ZJdgdh� ZKdidj� ZLdkdl� ZMdmdn� ZNd�dpdq�ZOd�drds�ZPdtdu� ZQdvdw� ZRdddododd(dd(ddddx� dydz�ZSd�d{d|�ZTd}d~� ZUdd�� ZVd�d�� ZWd�d�� ZXd�d�d��ZYd�d�� ZZd�d�� Z[d�d�� Z\d�d�� Z]d�d�� Z^d�d�� Z_d�d�� Z`d�d�� Za d�d�d��Zb d�d�d��Zcd�d�d��Zd d�d�d��Zed�d�� Zfd�d�� Zgd�d�� Zhd�d�� Zi d�d�d��Zjd�d�d��Zkd�d�� Zld�d�� Zmd�d�d��Znd�d�d��ZodS )��BaseDatabaseSchemaEditorz� This class and its subclasses are responsible for emitting schema-changing statements to the databases - model creation/removal/alteration, field renaming, index fiddling, and so on. z'CREATE TABLE %(table)s (%(definition)s)z1ALTER TABLE %(old_table)s RENAME TO %(new_table)sz7ALTER TABLE %(table)s SET TABLESPACE %(new_tablespace)sz DROP TABLE %(table)s CASCADEz:ALTER TABLE %(table)s ADD COLUMN %(column)s %(definition)sz!ALTER TABLE %(table)s %(changes)sz2ALTER COLUMN %(column)s TYPE %(type)s%(collation)sz%ALTER COLUMN %(column)s DROP NOT NULLz$ALTER COLUMN %(column)s SET NOT NULLz/ALTER COLUMN %(column)s SET DEFAULT %(default)sz$ALTER COLUMN %(column)s DROP DEFAULTz4ALTER TABLE %(table)s DROP COLUMN %(column)s CASCADEzDALTER TABLE %(table)s RENAME COLUMN %(old_column)s TO %(new_column)szFUPDATE %(table)s SET %(column)s = %(default)s WHERE %(column)s IS NULLz"UNIQUE (%(columns)s)%(deferrable)szCHECK (%(check)s)z.ALTER TABLE %(table)s DROP CONSTRAINT %(name)sz"CONSTRAINT %(name)s %(constraint)sz?ALTER TABLE %(table)s ADD CONSTRAINT %(name)s CHECK (%(check)s)zPALTER TABLE %(table)s ADD CONSTRAINT %(name)s UNIQUE (%(columns)s)%(deferrable)sz|ALTER TABLE %(table)s ADD CONSTRAINT %(name)s FOREIGN KEY (%(column)s) REFERENCES %(to_table)s (%(to_column)s)%(deferrable)sNzQCREATE INDEX %(name)s ON %(table)s (%(columns)s)%(include)s%(extra)s%(condition)szOCREATE UNIQUE INDEX %(name)s ON %(table)s (%(columns)s)%(include)s%(condition)sz/ALTER INDEX %(old_name)s RENAME TO %(new_name)szDROP INDEX %(name)szGALTER TABLE %(table)s ADD CONSTRAINT %(name)s PRIMARY KEY (%(columns)s)z DROP PROCEDURE %(procedure)sz)COMMENT ON TABLE %(table)s IS %(comment)sz5COMMENT ON COLUMN %(table)s.%(column)s IS %(comment)sFTc C s, || _ || _| jr g | _| j jjo|| _d S r+ )� connection� collect_sql� collected_sql�features�can_rollback_ddl�atomic_migration)�selfr; r< r r r r �__init__� s z!BaseDatabaseSchemaEditor.__init__c C s( g | _ | jrt| jj�| _| j�� | S r+ )� deferred_sqlr@ r r; �alias� __enter__�rA r r r rE � s z"BaseDatabaseSchemaEditor.__enter__c C s< |d u r| j D ]}| �|� q| jr | j�|||� d S d S r+ )rC �executer@ r �__exit__)rA �exc_type� exc_value� traceback�sqlr r r rH � s �z!BaseDatabaseSchemaEditor.__exit__r c C s� | j s| jjr| jjjstd��t|�}tjd||||d�d� | j rN|� � � d�r,dnd}|durD| j � |t t| j|�� | � dS | j � || � dS | j�� �}|�||� W d � dS 1 sew Y dS )z:Execute the given SQL statement, with optional parameters.ziExecuting DDL statements while in a transaction on databases that can't perform a rollback is prohibited.z%s; (params %r))�paramsrL )�extra�;� N)r< r; �in_atomic_blockr> r? r �str�logger�debug�rstrip�endswithr= �append�tuple�map� quote_value�cursorrG )rA rL rM �endingr[ r r r rG � s. ������ "�z BaseDatabaseSchemaEditor.executec C s | j j�|�S r+ )r; �ops� quote_name)rA r r r r r^ � � z#BaseDatabaseSchemaEditor.quote_namec s� � j jD ]}� fdd�|D �}�j���� |�� qg }g }� j jD ]�}��� |�\}}|du r1q"|j�jd�} | d rE|d�j | 7 }|j �jd�} | rT|d| 7 }|� |� |j r�|j r�|j jj j} |j jj �|j j�j} �jr�|d�j��| ���| �d� 7 }n�jjjr��j���� |d �� |�d ��|j�|f � |�� d v r��jj�� j j|j�} | r��j� | � q"� �fd d�� j jD �}�j ��� j j�d � dd� g |�|�R D ��d� }� j j r��jj� � j j �}|r�|d| 7 }||fS )z-Take a model and return its table definition.c � g | ]}� j �|��qS r �r# � get_field�r. r r' r r � <listcomp>� � z6BaseDatabaseSchemaEditor.table_sql.<locals>.<listcomp>N�r; �check� z %s)�to_table� to_column� _fk_%(to_table)s_%(to_column)sz%s %s)� AutoField� BigAutoField�SmallAutoFieldc s g | ]}|� � ���qS r )�constraint_sql�r. � constraint�r( rA r r rd s ���, c s s � | ] }|rt |�V qd S r+ )rR rp r r r r1 s � � �z5BaseDatabaseSchemaEditor.table_sql.<locals>.<genexpr>)�table� definition) r# �unique_togetherrC rW �_create_unique_sql� local_fields� column_sql� db_parametersr; �sql_check_constraint�db_type_suffix�extendr6 � db_constraintr( �db_tablerb � field_name�column�sql_create_inline_fkr^ r> �supports_foreign_keys�_create_fk_sql�get_internal_typer] � autoinc_sql� constraints�sql_create_table�join� db_tablespace�tablespace_sql)rA r( � field_names�fields� column_sqlsrM r ru � extra_params� db_params�col_type_suffixri rj r� r� rL r� r rr r � table_sql� s� ��� �� ��� � � � ��� z"BaseDatabaseSchemaEditor.table_sqlc c sL � |V |� d� }r| �|�V | jjjr |jr | �|j�V |j}|o2| �|� o2|o1| � |� }|r[| � |�} | d ur[d| � |� } | jjj rS| | � | � V n| V |�| � |jrh|jsh| jjjrhd}|sndV n| jjjsvdV |jr}dV n|jr�dV |jp�|jj} | r�| jjjr�|jr�| jjj| dd�V d S d S d S d S ) N� collationzDEFAULT TzNOT NULL�NULLz PRIMARY KEY�UNIQUE)�inline)�get� _collate_sqlr; r> �supports_comments_inline� db_comment� _comment_sql�null� skip_default�skip_default_on_alter�effective_default�_column_default_sql�requires_literal_defaults�prepare_defaultrW �empty_strings_allowedr �!interprets_empty_strings_as_nulls�implied_column_null�uniquer� r# �supports_tablespacesr] r� ) rA �column_db_typerM r( r �field_db_params�include_defaultr� r� � default_value�column_default� tablespacer r r �_iter_column_sql! sX � �� ��� ��� �z)BaseDatabaseSchemaEditor._iter_column_sqlc C sD |j | jd�}|d }|du rdS g }d�| �||||||��|fS )z� Return the column definition for a field. The field must already have had set_attributes_from_name() called. rf �typeN�NNrh )rz r; r� r� )rA r( r r� r� r� rM r r r ry Z s" �� �z#BaseDatabaseSchemaEditor.column_sqlc C � dS )z� Some backends don't accept default values for certain columns types (i.e. MySQL longtext and longblob). Fr �rA r r r r r� u � z%BaseDatabaseSchemaEditor.skip_defaultc C r� )z� Some backends don't accept default values for certain columns types (i.e. MySQL longtext and longblob) in the ALTER COLUMN statement. Fr r� r r r r� | r� z.BaseDatabaseSchemaEditor.skip_default_on_alterc C s t d��)zU Only used for backends which have requires_literal_defaults feature z�subclasses of BaseDatabaseSchemaEditor for backends which have requires_literal_defaults must provide a prepare_default() method��NotImplementedError�rA �valuer r r r� � s �z(BaseDatabaseSchemaEditor.prepare_defaultc C r� )z� Return the SQL to use in a DEFAULT clause. The resulting string should contain a '%s' placeholder for a default value. �%sr r� r r r r� � r� z,BaseDatabaseSchemaEditor._column_default_sqlc C s� | � � r | �� }|S | js!| jr!| jr!| �� dkr d}|S d}|S t| dd�s-t| dd�rS| �� }|dkr;t�� }|S t �� }|dkrI|� � }|S |d krQ|� � }|S d }|S ) N� BinaryField� rP �auto_nowF� auto_now_add� DateTimeField� DateField� TimeField) � has_default� get_defaultr� �blankr� r� �getattrr �nowr �date�time)r �default� internal_typer r r �_effective_default� s. � � � ���z+BaseDatabaseSchemaEditor._effective_defaultc C s |� | �|�| j�S )z2Return a field's effective database default value.)�get_db_prep_saver� r; r� r r r r� � s z*BaseDatabaseSchemaEditor.effective_defaultc C s t � �)aX Return a quoted version of the value so it's safe to use in an SQL string. This is not safe against injection from user code; it is intended only for use in making SQL scripts or preparing default values for particularly tricky backends (defaults are not user-defined, though, so this is safe). r� r� r r r rZ � s z$BaseDatabaseSchemaEditor.quote_valuec C s� | � |�\}}| �||p d� | jjjrG|jjr!| �|d|jj� | jjjsG|jj D ] }|j rF|j | jd�}|d }| j| � ||||j �� q*| j �| �|�� |jjD ]}|jjjjrc| �|jj� qTdS )zr Create a table and any accompanying indexes or unique constraints for the given `model`. Nrf r� )r� rG r; r> �supports_commentsr# �db_table_comment�alter_db_table_commentr� rx r� rz �_alter_column_comment_sqlrC r} �_model_indexes_sql�local_many_to_manyr6 �through� auto_created� create_model)rA r( rL rM r r� � field_typer r r r� � s0 � ��� ��z%BaseDatabaseSchemaEditor.create_modelc C s~ |j jD ]}|jjj jr| �|jj� q| �| jd| �|j j �i � t | j �D ]}t |t �r<|�|j j �r<| j �|� q(dS )z!Delete a model from the database.rt N)r# r� r6 r� r� � delete_modelrG �sql_delete_tabler^ r �listrC � isinstancer �references_table�remove)rA r( r rL r r r r� � s" ����� ��z%BaseDatabaseSchemaEditor.delete_modelc C s. |j r | jjjs dS | j|�|| �dd� dS )zAdd an index on a model.N�rM )�contains_expressionsr; r> �supports_expression_indexesrG � create_sql�rA r( �indexr r r � add_index� s ��z"BaseDatabaseSchemaEditor.add_indexc C s* |j r | jjjs dS | �|�|| �� dS )z Remove an index from a model.N)r� r; r> r� rG � remove_sqlr� r r r � remove_index� s ��z%BaseDatabaseSchemaEditor.remove_indexc C sF | j jjr| j| �||j|j�d d� d S | �||� | �||� d S )Nr� )r; r> �can_rename_indexrG �_rename_index_sqlr r� r� )rA r( � old_index� new_indexr r r � rename_index s � z%BaseDatabaseSchemaEditor.rename_indexc C s& |� || �}|r| j|dd� dS dS )z Add a constraint to a model.Nr� )r� rG �rA r( rq rL r r r �add_constraint s �z'BaseDatabaseSchemaEditor.add_constraintc C s" |� || �}|r| �|� dS dS )z!Remove a constraint from a model.N)r� rG r� r r r �remove_constraint s �z*BaseDatabaseSchemaEditor.remove_constraintc s| dd� |D �}dd� |D �}|� |�D ]}| �� |ddd�| j� q|� |�D ]}� fdd�|D �}| �| �� |�� q'd S ) z� Deal with a model changing its unique_together. The input unique_togethers must be doubly-nested, not the single-nested ["foo", "bar"] format. c S � h | ]}t |��qS r �rX �r. r� r r r � <setcomp>& � zABaseDatabaseSchemaEditor.alter_unique_together.<locals>.<setcomp>c S r� r r� r� r r r r� ' r� TF)r� r c r` r ra rc r' r r rd 2 re zBBaseDatabaseSchemaEditor.alter_unique_together.<locals>.<listcomp>N)� difference�_delete_composed_index�sql_delete_uniquerG rw )rA r( �old_unique_together�new_unique_together�olds�newsr� r� r r' r �alter_unique_together s ��z.BaseDatabaseSchemaEditor.alter_unique_togetherc s� dd� |D �}dd� |D �}|� |�D ]}| �� |ddd�| j� q|� |�D ]}� fdd�|D �}| �| j� |d d �� q'd S ) z� Deal with a model changing its index_together. The input index_togethers must be doubly-nested, not the single-nested ["foo", "bar"] format. c S r� r r� r� r r r r� ; r� z@BaseDatabaseSchemaEditor.alter_index_together.<locals>.<setcomp>c S r� r r� r� r r r r� < r� TF)r� r� c r` r ra rc r' r r rd G re zABaseDatabaseSchemaEditor.alter_index_together.<locals>.<listcomp>�_idx�r� �suffixN)r� r� �sql_delete_indexrG �_create_index_sql)rA r( �old_index_together�new_index_togetherr� r� r� r� r r' r �alter_index_together5 s ��z-BaseDatabaseSchemaEditor.alter_index_togetherc s� dd� � j jD �}dd� � j jD �}� fdd�|D �}| j� |fd||B i|��}|�d�du rJ|rJ| jjjrJt| j � j j |d d ��} | |v rJ| g}t |�d kr`t d t |�� j j d � |�f ��| �| �|� |d �� d S )Nc S � h | ]}|j �qS r �r rp r r r r� K � �zBBaseDatabaseSchemaEditor._delete_composed_index.<locals>.<setcomp>c S r r r rp r r r r� N � c s g | ] }� j �|�j�qS r )r# rb r� rc r' r r rd O s zCBaseDatabaseSchemaEditor._delete_composed_index.<locals>.<listcomp>�excluder� TF��quote� z1Found wrong number (%s) of constraints for %s(%s)rs r )r# r� �indexes�_constraint_namesr� r; r> �*allows_multiple_constraints_on_same_fieldsrR �_unique_constraint_namer �len� ValueErrorr� rG �_delete_constraint_sql) rA r( r� �constraint_kwargsrL �meta_constraint_names�meta_index_names�columns�constraint_names� default_namer r' r r� J sB ������� ��� z/BaseDatabaseSchemaEditor._delete_composed_indexc C sn ||ks| j jjr|�� |�� krdS | �| j| �|�| �|�d� � | jD ] }t|t �r4|� ||� q'dS )z#Rename the table a model points to.N)� old_table� new_table) r; r> �ignores_table_name_case�lowerrG �sql_rename_tabler^ rC r� r �rename_table_references)rA r( � old_db_table� new_db_tablerL r r r �alter_db_tablel s" ���� ��z'BaseDatabaseSchemaEditor.alter_db_tablec C sF | j r | jjjr!| �| j | �|jj�| �|pd�d� � d S d S d S )NrP )rt �comment) �sql_alter_table_commentr; r> r� rG r^ r# r rZ )rA r( �old_db_table_comment�new_db_table_commentr r r r� s ����z/BaseDatabaseSchemaEditor.alter_db_table_commentc C s2 | � | j| �|jj�| �|�| �|�d� � dS )z)Move a model's table between tablespaces.)rt �old_tablespace�new_tablespaceN)rG �sql_retablespace_tabler^ r# r )rA r( �old_db_tablespace�new_db_tablespacer r r �alter_db_tablespace� s ���z,BaseDatabaseSchemaEditor.alter_db_tablespacec C s@ |j r|jjjjr| �|jj�S | j||dd�\}}|du r dS |j| jd� }r0|d|� �7 }|j | jd�}|d rD|d| j | 7 }|jr�| jj j r�|j r�d}| jr�|jjjj}|jjj�|jj�j} t|jj�\} } |d| j| �|||�| r�d| �| � nd | �|j�| �|�| �| �| jj�� d � 7 }n | j�| �|||�� | j | �|jj�| �|j�|d � } | � | |� | � |�s�| � |�dur�| j |d|dd �\} }| j!| �|jj�| d � } | � | |� |j"�r| jj j#�r| jj j$�s|d }| j | �%||||j"�� | j�&| �'||�� | jj j(�r | j�)� dS dS )z� Create a field on a model. Usually involves adding a column, but may involve adding a table instead (for M2M fields). T)r� Nrf rh rg rk z%s.rP )r � namespacer� ri rj � deferrable)rt r� ru ��drop�rt �changesr� )*r r6 r� r# r� r� ry r| r; rz r{ r> r� r~ �sql_create_column_inline_fkr( r rb r� r� r �_fk_constraint_namer^ r] �deferrable_sqlrC rW r� �sql_create_columnrG r� r� �_alter_column_default_sql�sql_alter_columnr� r� r� r� r} �_field_indexes_sql� connection_persists_old_columns�close)rA r( r ru rM r� r� �constraint_suffixri rj r) �_rL � changes_sqlr� r r r � add_field� s� ��� �� � � � � � � � ��� �� �z"BaseDatabaseSchemaEditor.add_fieldc C s� |j r|jjjjr| �|jj�S |j| jd�d du r dS |jr8| j||j gdd�}|D ] }| � | � ||�� q,| j | � |jj�| � |j �d� }| � |� | jjjrX| j�� t| j�D ]}t|t�rs|�|jj|j �rs| j�|� q]dS )z� Remove a field from a model. Usually involves deleting a column, but for M2Ms may involve deleting a table. rf r� NT�� foreign_key)rt r� )r r6 r� r# r� r� rz r; r r� rG �_delete_fk_sql�sql_delete_columnr^ r r> r6 r7 r� rC r� r �references_columnr� )rA r( r �fk_names�fk_namerL r r r � remove_field� s, � � ��z%BaseDatabaseSchemaEditor.remove_fieldc C s0 | � ||�sdS |j| jd�}|d }|j| jd�}|d }|du r'|jdu s0|du r8|jdu r8td||f ��|du r\|du r\|jjr\|jjr\|jjjjr\|jjjjr\| �||||�S |du rz|du rz|jjrz|jjrz|jjjjsz|jjjjszdS |du s�|du r�td||f ��| � ||||||||� dS )a' Allow a field's type, uniqueness, nullability, default, column, constraints, etc. to be modified. `old_field` is required to compute the necessary changes. If `strict` is True, raise errors if the old column does not match `old_field` precisely. Nrf r� zqCannot alter field %s into %s - they do not properly define db_type (are you using a badly-written custom field?)z�Cannot alter field %s into %s - they are not compatible types (you cannot alter to or from M2M fields, or add or remove through= on M2M fields)) �_field_should_be_alteredrz r; r6 r r� r# r� �_alter_many_to_many� _alter_field) rA r( r0 r3 �strict� old_db_params�old_type� new_db_params�new_typer r r � alter_field sf ���� � ��� � � ���z$BaseDatabaseSchemaEditor.alter_fieldc / C s� t � } | jjjrL|jrL|jrL| j||dhd�rL| j||jgdd�} |r7t | �dkr7t dt | �|j j |jf ��| D ]} | � |jf� | �| �|| �� q9|jr�|jrX| �||�r�dd� |j jD �} | j||jgdd | d �} |r�t | �dkr�t d t | �|j j |jf ��| D ] }| �| �||�� q�|�d �}|�d �}| jjjo�|jr�|jp�|jo�|jo�||kp�||k}|r�t||�D ] \}}| j|j|jjgdd�}|D ] } | �| �|j| �� q�q�|j�r|j�s|jr�|j�rd d� |j jD �}| j||jgdtj |d�}|D ] }| �| � ||�� �q|d |d k�rX|d �rXdd� |j jD �} | j||jgd| d�} |�rIt | �dk�rIt dt | �|j j |jf ��| D ] }| �| � ||�� �qK|j|jk�r�| �| � |j j |||�� | j D ]}t!|t"��r�|�#|j j |j|j� �qog }g }g }|j$| jd�} |j$| jd�} ||k�s�| | k�s�||k�s�| jjj%�r�|j&|j&k�r�| �'||||||�\} } |�(| � |�)| � d } |j*�r�|j*�s�| �+|�}!| �+|�}"| �,|��s�|!|"k�r�|"du�r�d} |�(| �-|||�� |j*|j*k�r| �.|||�} | �r|�(| � |�/� �o |j*�o |j* }#|�s#|�r�|#�s*||7 }| jjj0�rF|�rFt1t2|� �\}}$d�3|�t4|$g �fg}|D ]\}}$| �| j5| �6|j j �|d� |$� �qH|#�r�| �| j7| �6|j j �| �6|j�dd� |"g� |D ]\}}$| �| j5| �6|j j �|d� |$� �q{|�r�|D ] \}}$| �||$� �q�|j�r�|j�s�| �8||� | �9||��r�| �| �:||g�� |j�r�|j�r�|j�r�|j�s�| �| j;||gd�� g }%|�r�|%�)t||�� | �||��r| �| �<||�� |%�)t||�� |%D ]V\}&}|jj=| jd�}'|'d }(|'�d �})|&jj=| jd�}*|*�d �}+| �'|j|&j|j|(|+|)�\} } | �| j5| �6|jj j �| d d� | d � | D ] \}}$| �||$� �qM�q| jjj�r~|j�r~| �sp|j�rp|j�s~|j�r~| �| �>||d �� |�r�|%D ]\},}-|-jj�r�| �| �>|-j|-jd �� �q�|d |d k�r�|d �r�| j?|j j |jgd d �}| �| �@|||d �� | �r�| j-|||dd �\}.}$| j5| �6|j j �|.d� }| �||$� | jjjA�r�| j�B� dS dS )!z3Perform a "physical" (non-ManyToMany) field update.r� )�ignoreTr< r z<Found wrong number (%s) of foreign key constraints for %s.%sc S r r r rp r r r r� v r z8BaseDatabaseSchemaEditor._alter_field.<locals>.<setcomp>F)r� r r z7Found wrong number (%s) of unique constraints for %s.%sr� c S r r r )r. r� r r r r� � r )r� �type_r rg c S r r r rp r r r r� � r )rg r z6Found wrong number (%s) of check constraints for %s.%srf Nrs r- r� )rt r� r� �r� r� r rk �_fk�_check�r� r+ )C�setr; r> r� r6 r~ rD r r� r r r# r �addrG r> r� �_field_became_primary_keyr� �_delete_unique_sqlr� r r5 � related_modelr �db_indexr r r� �_delete_index_sql�_delete_check_sql�_rename_field_sqlrC r� r �rename_column_referencesr| r� r� �_alter_column_type_sqlrW r} r� r� r� r3 �_alter_column_null_sqlr� �supports_combined_altersrX r4 r� �sumr4 r^ �sql_update_with_default�_delete_primary_key�_unique_should_be_addedrw r� �_create_primary_key_sqlrz r� �_create_index_name�_create_check_sqlr6 r7 )/rA r( r0 r3 rI rK rH rJ rG � fks_droppedrA rB r r �constraint_name� old_collation� new_collation�drop_foreign_keys�_old_relr9 � rel_fk_namesr � index_names� index_namerL �actions� null_actions� post_actions�old_type_suffix�new_type_suffix�fragment� other_actions�needs_database_default� old_default� new_default�four_way_default_alterationrM �rels_to_updater8 � rel_db_params�rel_type� rel_collation�old_rel_db_params�old_rel_collationr9 �relr: r r r rF J s, ����� ����� ������ ���� ����� ����� �� �� � � � � � ��� ��� ��� ���� ���� ������� � �� �� � � �z%BaseDatabaseSchemaEditor._alter_fieldc C sR | j jjr |jr dS |j| j d�}|jr| jn| j}|| �|j �|d d� g fS )z� Hook to specialize column null alteration. Return a (sql, params) fragment to set a column to null or non-null as required by new_field, or None if no changes are required. Nrf r� )r� r� ) r; r> r� r� rz r� �sql_alter_column_null�sql_alter_column_not_nullr^ r� )rA r( r0 r3 rJ rL r r r r^ � s" ���� ���z/BaseDatabaseSchemaEditor._alter_column_null_sqlc C s� | � |�}| �|�}|g}|rg }n | jjjr | �|�}g }|j| jd�}|r2|jr.| j} n| j } n| j } | | � |j �|d |d� |fS )z� Hook to specialize column default alteration. Return a (sql, params) fragment to add or drop (depending on the drop argument) a default to new_field's column. rf r� )r� r� r� ) r� r� r; r> r� r� rz r� � sql_alter_column_no_default_null�sql_alter_column_no_default�sql_alter_column_defaultr^ r� ) rA r( r0 r3 r, ry r� rM rJ rL r r r r3 � s, ���z2BaseDatabaseSchemaEditor._alter_column_default_sqlc C s� g }| � |||jj� }rd|� �}nd}d} | jjjrB|jsB|j|jkr9| �||||j�\} } | r9|� | | f� |jrB| � |j�} | j | � |j �||| d� g f|fS )a� Hook to specialize column type alteration for different backends, for cases when a creation type is different to an alteration type (e.g. SERIAL in PostgreSQL, PostGIS fields). Return a two-tuple of: an SQL fragment of (sql, params) to insert into an ALTER TABLE statement and a list of extra (sql, params) tuples to run once the field is altered. rh rP )r� r� r� r )r� r# r r; r> r� r r� r� rW r� �sql_alter_column_typer^ r� ) rA r( r0 r3 rK ri rj rv � collate_sql� comment_sqlrL rM r r r r] � s6 � � ��� �z/BaseDatabaseSchemaEditor._alter_column_type_sqlc C s. | j | �|jj�| �|j�| �|�d� g fS )N)rt r� r )�sql_alter_column_commentr^ r# r r� r� )rA r( r3 rK �new_db_commentr r r r� s ���z2BaseDatabaseSchemaEditor._alter_column_comment_sqlc C s | � |pd�S )NrP )rZ )rA r r r r r� r_ z%BaseDatabaseSchemaEditor._comment_sqlc C s� |j jjj|j jjjkr | �|j j|j jjj|j jjj� | �|j j|j jj�|�� �|j jj�|�� �� | �|j j|j jj�|�� �|j jj�|�� �� dS )z*Alter M2Ms to repoint their to= endpoints.N) r6 r� r# r r rL rb �m2m_reverse_field_name�m2m_field_name)rA r( r0 r3 rG r r r rE # s, � � � �� �z,BaseDatabaseSchemaEditor._alter_many_to_manyrP c C s� t |�\}}dt|g|�R ddi�|f }| jj�� p d}d|d�|�|f }t|�|kr/|S t|�|d kr?|d|d � }|t|� d d }d|d|� d�|�d|� |f }|d dksg|d �� rod |dd � }|S )z� Generate a unique name for an index/unique constraint. The name is divided into 3 parts: the table name, the column names, and a unique digest and suffix. z%s%s�length� �� z%s_%s_%sr9 � N� r r zD%s���)r r r; r] �max_name_lengthr� r �isdigit) rA � table_name� column_namesr� r9 �hash_suffix_part� max_lengthro � other_lengthr r r re C s( � �z+BaseDatabaseSchemaEditor._create_index_namec C sf |d u r$t |�dkr|d jr|d j}ntjr tj}n|jjr$|jj}|d ur1d| jj�|� S dS )Nr r rh rP )r r� r �DEFAULT_INDEX_TABLESPACEr# r; r] r� )rA r( r� r� r r r �_get_index_tablespace_sqlc s z2BaseDatabaseSchemaEditor._get_index_tablespace_sqlc C s |rd| S dS )Nz WHERE rP r )rA � conditionr r r �_index_condition_sqlo s z-BaseDatabaseSchemaEditor._index_condition_sqlc C s, |r| j jjs dS tdt|jj|| j�d�S )NrP z INCLUDE (%(columns)s))r )r; r> �supports_covering_indexesr r r# r r^ )rA r( r r r r �_index_include_sqlt s �z+BaseDatabaseSchemaEditor._index_include_sql) r� r r� �usingr� � col_suffixesrL � opclassesr� �include� expressionsc s� |pg }| pg } t |dd�j�jd�} �j|||d�}dd� |D �}|p&�j}|jj}� �fdd�}t|t|�j �t ||||�||rJ�� |||| �nt || | �j �|��| ���|| �d �S ) z� Return the SQL statement to create the index for one or several fields or expressions. `sql` can be specified if the syntax differs from the standard (GIS indexes, ...). F�� alias_colsrf )r� c S � g | ]}|j �qS r �r� rc r r r rd � r z>BaseDatabaseSchemaEditor._create_index_sql.<locals>.<listcomp>c s" � d u r �j | i |��� ��� �S r+ )re r^ ��args�kwargs�r rA r r �create_index_name� s zEBaseDatabaseSchemaEditor._create_index_sql.<locals>.create_index_name)rt r r� r rN r� r� )r � get_compilerr; r� �sql_create_indexr# r r r r^ r �_index_columnsr rZ r� r� )rA r( r� r r� r� r� r� rL r� r� r� r� �compilerr� r r� rt r� r r� r r� | s0 �� � �z*BaseDatabaseSchemaEditor._create_index_sqlc C s& t |p| jt|jj| j�| �|�d�S �N)rt r )r r� r r# r r^ )rA r( r rL r r r rY � s �z*BaseDatabaseSchemaEditor._delete_index_sqlc C s* t | jt|jj| j�| �|�| �|�d�S )N)rt �old_name�new_name)r �sql_rename_indexr r# r r^ )rA r( r� r� r r r r� � s �z*BaseDatabaseSchemaEditor._rename_index_sqlc C s t ||| j|d�S )N)r� )r r^ )rA rt r r� r� r r r r� � s z'BaseDatabaseSchemaEditor._index_columnsc s� � j jr � j js � j jrg S g }� j jD ] }|�| �� |�� q� j jD ]}� fdd�|D �}|�| j � |dd�� q$� j j D ]}|j rI| j j jrR|�|�� | �� q?|S )z� Return a list of all index SQL statements (field indexes, index_together, Meta.indexes) for the specified model. c r` r ra rc r' r r rd � re z?BaseDatabaseSchemaEditor._model_indexes_sql.<locals>.<listcomp>r� r� )r# �managed�proxy�swappedrx r} r5 �index_togetherrW r� r r� r; r> r� r� )rA r( �outputr r� r� r� r r' r r� � s ���z+BaseDatabaseSchemaEditor._model_indexes_sqlc C s* g }| � ||�r|�| j||gd�� |S )zT Return a list of all index SQL statements for the specified field. rO )�_field_should_be_indexedrW r� )rA r( r r� r r r r5 � s z+BaseDatabaseSchemaEditor._field_indexes_sqlc C s� |pt � }|�� \}}}}|�� \}}} } |�|j�D ]} |�| d � q|�|j�D ]} | �| d � q*| �|j�| �|j�kpH|||f|| | fkS r+ )rS � deconstruct�union� non_db_attrs�popr^ r� ) rA r0 r3 rM r9 �old_path�old_args� old_kwargs�new_path�new_args� new_kwargs�attrr r r rD � s ��z1BaseDatabaseSchemaEditor._field_should_be_alteredc C s |j o|j S r+ )rX r� �rA r( r r r r r� � r_ z1BaseDatabaseSchemaEditor._field_should_be_indexedc C s |j o|j S r+ �r �rA r0 r3 r r r rU � r_ z2BaseDatabaseSchemaEditor._field_became_primary_keyc C s |j o |jo |j p |j S r+ )r r� r� r r r rc � s � �z0BaseDatabaseSchemaEditor._unique_should_be_addedc C s* | j | �|�| �|j�| �|j�|d� S )N)rt � old_column� new_columnr� )�sql_rename_columnr^ r� )rA rt r0 r3 rK r r r r[ s �z*BaseDatabaseSchemaEditor._rename_field_sqlc C s� t |jj| j�}| �|||�}t|jj|jg| j�}t |jjjj| j�}t|jjjj|jjg| j�}| j j � � } t | j |||||| d�S )N)rt r r� ri rj r* )r r# r r^ r0 r r� � target_fieldr( r; r] r1 r � sql_create_fk) rA r( r r� rt r r� ri rj r* r r r r� s& � �z'BaseDatabaseSchemaEditor._create_fk_sqlc s< � fdd�}t |jj|jgt|jjjj�d |jjg||�S )Nc � � � � j| i |���S r+ �r^ re r� rF r r �create_fk_name � zDBaseDatabaseSchemaEditor._fk_constraint_name.<locals>.create_fk_namer )r r# r r� r r� r( )rA r( r r� r� r rF r r0 s �z,BaseDatabaseSchemaEditor._fk_constraint_namec C � | � | j||�S r+ )r � sql_delete_fk�rA r( r r r r r> , � z'BaseDatabaseSchemaEditor._delete_fk_sqlc C s, |d u rdS |t jkr dS |t jkrdS d S )NrP z DEFERRABLE INITIALLY DEFERREDz DEFERRABLE INITIALLY IMMEDIATE)r �DEFERRED� IMMEDIATE)rA r* r r r �_deferrable_constraint_sql/ s �z3BaseDatabaseSchemaEditor._deferrable_constraint_sqlc s� |r � j jjs d S |s|s|s|r'� j|||||||d�} | r%� j�| � d S � jd�� fdd�|D ��� �|�d� } � j � � |�| d� S )N)r r� r� r� r� rs c s g | ]}� � |j��qS r )r^ r� rc rF r r rd W re z8BaseDatabaseSchemaEditor._unique_sql.<locals>.<listcomp>)r r* �r rq ) r; r> �&supports_deferrable_unique_constraintsrw rC rW �sql_unique_constraintr� r� �sql_constraintr^ ) rA r( r� r r� r* r� r� r� rL rq r rF r � _unique_sql7 s4 ��� ��z$BaseDatabaseSchemaEditor._unique_sqlc C s |r| j jjr |r| j jjr |r| j jjr |r | j jjs d S t|dd�j| j d�} |jj } dd� |D �} |d u rA| j | | dd�}n| � |�}|sN|sN|sN|rR| j } n| j } | ra| j| | d|d �} nt| || | j�} t| t| | j �|| | �|�| �|�| �||�d �S ) NFr� rf c S r� r r� rc r r r rd { r z?BaseDatabaseSchemaEditor._create_unique_sql.<locals>.<listcomp>Tr r )r� r� )rt r r r� r* r� )r; r> r� �supports_partial_indexesr� r� r r� r# r r r^ �sql_create_unique_index�sql_create_uniquer� r rZ r r r� r� r� ) rA r( r� r r� r* r� r� r� r� rt r rL r r r rw _ sT �������� � � �z+BaseDatabaseSchemaEditor._create_unique_sqlc s& |r � fdd�}n� j }t||d|�S )Nc r� r+ r� r� rF r r �create_unique_name� r� zLBaseDatabaseSchemaEditor._unique_constraint_name.<locals>.create_unique_name�_uniq)re r )rA rt r r r� r rF r r � s z0BaseDatabaseSchemaEditor._unique_constraint_namec C sh |r| j jjr |r| j jjr |r| j jjr |r | j jjs d S |s&|s&|s&|r*| j}n| j}| �|||�S r+ ) r; r> r� r� r� r� r� r� r ) rA r( r r� r* r� r� r� rL r r r rV � s* �������� z+BaseDatabaseSchemaEditor._delete_unique_sqlc C s | j | �|�| jd|i d� S )Nrg r� )r� r^ r{ )rA r rg r r r � _check_sql� s �z#BaseDatabaseSchemaEditor._check_sqlc C s$ t | jt|jj| j�| �|�|d�S )N)rt r rg )r �sql_create_checkr r# r r^ )rA r( r rg r r r rf � s �z*BaseDatabaseSchemaEditor._create_check_sqlc C s | j jjsd S | �| j||�S r+ )r; r> � supports_table_check_constraintsr �sql_delete_checkr� r r r rZ � s z*BaseDatabaseSchemaEditor._delete_check_sqlc C s t |t|jj| j�| �|�d�S r� )r r r# r r^ )rA �templater( r r r r r � s �z/BaseDatabaseSchemaEditor._delete_constraint_sqlc s |dur � fdd�|D �}� j �� �} � j j�| |jj�} W d � n1 s'w Y g } | �� D ]Y\} }|du s@||d kr�|durK|d |krKq2|durV|d |krVq2|dura|d |kraq2|durl|d |krlq2|duru|d suq2|dur�|d |kr�q2| r�| | vr�| �| � q2| S ) z@Return all constraint names matching the columns and conditions.Nc s@ g | ] }� j jjr� j j�t|� j j�� ��n� j j�|��qS r )r; r> �truncates_names� introspection�identifier_converterr r] r� )r. r rF r r rd � s � �� �z>BaseDatabaseSchemaEditor._constraint_names.<locals>.<listcomp>r r� r r� rg r= r� )r; r[ r� �get_constraintsr# r �itemsrW )rA r( r� r� r r� r= rg rN r r[ r� �resultr �infodictr rF r r � s8 � � � �z*BaseDatabaseSchemaEditor._constraint_namesc C sV | j |dd�}|rt|�dkrtdt|�|jjf ��|D ] }| �| �||�� q d S )NTr� r z0Found wrong number (%s) of PK constraints for %s)r r r r# r rG �_delete_primary_key_sql)rA r( rG r rh r r r rb s ����z,BaseDatabaseSchemaEditor._delete_primary_keyc C sJ t | jt|jj| j�| �| j|jj|jgdd��t|jj|jg| j�d�S )N�_pkrR )rt r r ) r � sql_create_pkr r# r r^ re r� r r� r r r rd s ���z0BaseDatabaseSchemaEditor._create_primary_key_sqlc C r� r+ )r � sql_delete_pkr� r r r r� r� z0BaseDatabaseSchemaEditor._delete_primary_key_sqlc C s |r d| � |� S dS )NzCOLLATE rP )r^ )rA r� ri r� r r r r� r� z%BaseDatabaseSchemaEditor._collate_sqlc C s* | j | �|�d�|�d� }| �|� d S )N�,)� procedure� param_types)�sql_delete_procedurer^ r� rG )rA �procedure_namer� rL r r r �remove_procedure! s �z)BaseDatabaseSchemaEditor.remove_procedure)FT)r )F)rP r+ )NNNNN)NNNNNN)T)NNNNNNNNr� )p�__name__� __module__� __qualname__�__doc__r� r r% r� r2 r4 r� r� r� r� r� r� r? r� ra r� r{ �sql_delete_constraintr� r� r� r� r� r� r� r/ r� r� r� r� r� r� r� r� r r� rB rE rH rG r^ r� r� ry r� r� r� r� � staticmethodr� r� rZ r� r� r� r� r� r� r� r� r r� r r� r( r; rC rL rF r^ r3 r] r� r� rE re r� r� r� r� rY r� r� r� r5 rD r� rU rc r[ r� r0 r> r� r� rw r rV r� rf rZ r r rb rd r� r� r� r r r r r: K s6 ������� S 9 $ " V I � \ &. � 6 �, � 5 � � - r: ) �loggingr% r � django.confr �!django.db.backends.ddl_referencesr r r r r r �django.db.backends.utilsr r r �django.db.modelsr r �django.db.models.sqlr �django.db.transactionr r � django.utilsr � getLoggerrS r r) r5 r: r r r r �<module> s PK �"�Z�F�8 8 & __pycache__/validation.cpython-310.pycnu �[��� o �h+ � @ s G d d� d�Z dS )c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �BaseDatabaseValidationz(Encapsulate backend-specific validation.c C s || _ d S �N)� connection)�selfr � r �U/usr/local/CyberCP/lib/python3.10/site-packages/django/db/backends/base/validation.py�__init__ s z BaseDatabaseValidation.__init__c K s g S r r )r �kwargsr r r �check s z BaseDatabaseValidation.checkc sd g }t � d�r0t|dd �s0t� fdd�|jjjD ��}|r0|�� j�}|d ur0|�� � ||�� |S )N�check_field_type� remote_fieldc 3 s � | ] }t � jj|d �V qdS )FN)�getattrr �features)�.0�feature�r r r � <genexpr> s � � �z5BaseDatabaseValidation.check_field.<locals>.<genexpr>) �hasattrr �all�model�_meta�required_db_features�db_typer �extendr )r �fieldr �errors�!db_supports_all_required_features� field_typer r r � check_field s � � � z"BaseDatabaseValidation.check_fieldN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r N)r r r r r �<module> s PK �"�Z 2�& & $ __pycache__/features.cpython-310.pycnu �[��� o �hi: � @ s* d dl mZ d dlmZ G dd� d�ZdS )� )�ProgrammingError)�cached_propertyc @ sf e Zd ZdZdZdZdZdZg ZdZ dZ dZ dZ dZ dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*dZ+dZ,dZ-dZ.dZ/dZ0dZ1dZ2dZ3dZ4dddddd d d d d dddddd�Z5dZ6dZ7dZ8dZ9dZ:dZ;dZ<dZ=dZ>dZ?dZ@dZAdZBdZCdZDdZEdZFdZGeHZIdZJdZKdZLdZMdZNdZOdZPdZQdZRdZSdZTdZUdZVdZWdZXdZYdZZdZ[dZ\dZ]dZ^dZ_dZ`dZadZbec� ZddZedZfdZgdZhdZidZjdZkdZldZmdZndZodZpdZqdZrdZsdZtdZudZvdZwdZxdZydZzdZ{dZ|dZ}dZ~dZdZ�dZ�ddddd�Z�dZ�ec� Z�i Z�dd� Z�e�dd� �Z�e�dd � �Z�d d � Z�dS ) �BaseDatabaseFeaturesNFT� AutoField� BigAutoField�BigIntegerField� BinaryField� BooleanField� CharField� DurationField�GenericIPAddressField� IntegerField�PositiveBigIntegerField�PositiveIntegerField�PositiveSmallIntegerField�SmallAutoField�SmallIntegerField� TimeField)r r r r r r r r r r r r r r r � � )�ci�cs� non_default� swedish_cic C s || _ d S )N)� connection)�selfr � r �S/usr/local/CyberCP/lib/python3.10/site-packages/django/db/backends/base/features.py�__init__p s z BaseDatabaseFeatures.__init__c C s | j jjduS )z5Does this backend support explaining query execution?N)r �ops�explain_prefix)r r r r �#supports_explaining_query_executions s z8BaseDatabaseFeatures.supports_explaining_query_executionc C s� | j �� �5}|�d� | j �d� |�d� | j �� | j �d� |�d� |�� \}|�d� W d � |dkS 1 s=w Y |dkS ) z!Confirm support for transactions.z"CREATE TABLE ROLLBACK_TEST (X INT)Fz(INSERT INTO ROLLBACK_TEST (X) VALUES (8)Tz"SELECT COUNT(X) FROM ROLLBACK_TESTzDROP TABLE ROLLBACK_TESTNr )r �cursor�execute�set_autocommit�rollback�fetchone)r r" �countr r r �supports_transactionsx s � � z*BaseDatabaseFeatures.supports_transactionsc C s | j sdS |jjS )NF)� allows_group_by_selected_pks�_meta�managed)r �modelr r r �%allows_group_by_selected_pks_on_model� s z:BaseDatabaseFeatures.allows_group_by_selected_pks_on_model)��__name__� __module__� __qualname__�minimum_database_version� gis_enabled�allows_group_by_lobr) � allows_group_by_select_index�empty_fetchmany_value�update_can_self_select�!interprets_empty_strings_as_nulls�$supports_nullable_unique_constraints�.supports_partially_nullable_unique_constraints�&supports_deferrable_unique_constraints�can_use_chunked_reads� can_return_columns_from_insert� can_return_rows_from_bulk_insert�has_bulk_insert�uses_savepoints�can_release_savepoints�related_fields_match_type� allow_sliced_subqueries_with_in�has_select_for_update� has_select_for_update_nowait�!has_select_for_update_skip_locked�has_select_for_update_of� has_select_for_no_key_update�select_for_update_of_column�#test_db_allows_multiple_connections�supports_unspecified_pk�supports_forward_references�truncates_names�has_real_datatype� supports_subqueries_in_group_by�*ignores_unnecessary_order_by_in_subqueries�has_native_uuid_field�has_native_duration_field� supports_temporal_subtraction� supports_regex_backreferencing�!supports_date_lookup_using_string�supports_timezones�has_zoneinfo_database�-requires_explicit_null_ordering_when_grouping�nulls_order_largest� supports_order_by_nulls_modifier�order_by_nulls_first�max_query_params�allows_auto_pk_0�can_defer_constraint_checks�supports_tablespaces�supports_sequence_reset�can_introspect_default�can_introspect_foreign_keys�introspected_field_types� supports_index_column_ordering�!can_introspect_materialized_views�can_distinct_on_fields�atomic_transactions�can_rollback_ddl�+schema_editor_uses_clientside_param_binding�!supports_atomic_references_rename�supports_combined_alters�supports_foreign_keys�can_create_inline_fk�can_rename_index�indexes_foreign_keys�!supports_column_check_constraints� supports_table_check_constraints� can_introspect_check_constraints� supports_paramstyle_pyformat�requires_literal_defaults� connection_persists_old_columnsr �closed_cursor_error_class�has_case_insensitive_like�bare_select_suffix�implied_column_null�%supports_select_for_update_with_limit� greatest_least_ignores_nulls�can_clone_databases�ignores_table_name_case�for_update_after_from�supports_select_union� supports_select_intersection�supports_select_difference�%supports_slicing_ordering_in_compound� supports_parentheses_in_compound�#requires_compound_order_by_subquery� supports_aggregate_filter_clause� supports_index_on_text_field�supports_over_clause�#supports_frame_range_fixed_distance�4only_supports_unbounded_with_preceding_and_following� supports_cast_with_precision�time_cast_precision�(create_test_procedure_without_params_sql�(create_test_procedure_with_int_param_sql�,create_test_table_with_composite_primary_key�supports_callproc_kwargs�set�supported_explain_formats� supports_default_in_lead_lag�supports_ignore_conflicts�supports_update_conflicts�%supports_update_conflicts_with_target� requires_casted_case_in_updates�supports_partial_indexes�%supports_functions_in_partial_indexes�supports_covering_indexes�supports_expression_indexes�collate_as_index_expression�*allows_multiple_constraints_on_same_fields�&supports_boolean_expr_in_select_clause� supports_comparing_boolean_expr�supports_json_field�can_introspect_json_field�!supports_primitives_in_json_field�has_native_json_field�has_json_operators� supports_json_field_contains�-json_key_contains_list_matching_requires_list�has_json_object_function� supports_collation_on_charfield� supports_collation_on_textfield�%supports_non_deterministic_collations�supports_comments�supports_comments_inline�supports_logical_xor�+prohibits_null_characters_in_text_exception� supports_unlimited_charfield�test_collations�test_now_utc_template� django_test_expected_failures�django_test_skipsr r r! r( r- r r r r r s6 �� r N)� django.dbr �django.utils.functionalr r r r r r �<module> s PK �"�Z��,Z_ Z_ __pycache__/base.cpython-310.pycnu �[��� o �h�o � @ s6 d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlmZ d dl m Z d dl m Z zd dl Z W n eyC d dlm Z Y nw d dlmZ d dlmZ d dlmZmZmZ d d lmZ d d lmZ d d l m Z d d l m Z d d l m!Z! d dl"m#Z# d dl$m%Z% dZ&e'� a(e�)d�Z*dd� Z+G dd� d�Z,dS )� N)�deque)�contextmanager)�debug_transaction)�zoneinfo)�settings)�ImproperlyConfigured)�DEFAULT_DB_ALIAS� DatabaseError�NotSupportedError)�utils)�BaseDatabaseValidation)�connection_created)�TransactionManagementError��DatabaseErrorWrapper)� async_unsafe)�cached_property� __no_db__zdjango.db.backends.basec C s" t jr dd l}|�| �S t�| �S �Nr )r �USE_DEPRECATED_PYTZ�pytz�timezoner �ZoneInfo)�tznamer � r �O/usr/local/CyberCP/lib/python3.10/site-packages/django/db/backends/base/base.py�timezone_constructor$ s r c @ s� e Zd ZdZi Zi Zi ZdZdZdZ dZ dZ dZ dZ dZdZeZdZefdd�Zdd� Zd d � Zed d � �Zed d� �Zedd� �Zedd� �Z dd� Z dd� Z dd� Z dd� Z dd � Z!d�d d �Z"e#d d � �Z$d!d"� Z%e#d#d$� �Z&d%d&� Z'd�d'd(�Z(d)d*� Z)d+d,� Z*d-d.� Z+e#d/d0� �Z,e#d1d2� �Z-e#d3d4� �Z.e#d5d6� �Z/d7d8� Z0d9d:� Z1d;d<� Z2d=d>� Z3e#d?d@� �Z4e#dAdB� �Z5e#dCdD� �Z6e#dEdF� �Z7dGdH� Z8dIdJ� Z9 Kd�dLdM�Z:dNdO� Z;dPdQ� Z<dRdS� Z=dTdU� Z>e?dVdW� �Z@dXdY� ZAdZd[� ZBd�d\d]�ZCd^d_� ZDd`da� ZEdbdc� ZFeddde� �ZGdfdg� ZHdhdi� ZIdjdk� ZJdldm� ZKedndo� �ZLdpdq� ZMdrds� ZNdtdu� ZOe?dvdw� �ZPe?dxdy� �ZQdzd{� ZRd�d|d}�ZSd~d� ZTe?d�d�� �ZUd�d�d��ZVdS )��BaseDatabaseWrapperz Represent a database connection.N�unknowni(# c C s� d | _ || _|| _t| jd�| _d| _d| _d| _d| _ g | _ g | _ d| _ d| _ d | _d | _d| _d| _d| _d| _t�� | _d| _t�� | _g | _d| _ g | _ | � | �| _ | � | �| _!| �"| �| _#| �$| �| _%| �&| �| _'| �(| �| _)d S )N)�maxlenFr T)*� connection� settings_dict�aliasr � queries_limit� queries_log�force_debug_cursor� autocommit�in_atomic_block�savepoint_state� savepoint_ids� atomic_blocks�commit_on_exit�needs_rollback� rollback_exc�close_at�closed_in_transaction�errors_occurred�health_check_enabled�health_check_done� threading�Lock�_thread_sharing_lock�_thread_sharing_count�_thread� get_ident� _thread_ident� run_on_commit�%run_commit_hooks_on_set_autocommit_on�execute_wrappers� client_class�client�creation_class�creation�features_class�features�introspection_class� introspection� ops_class�ops�validation_class� validation)�selfr! r" r r r �__init__C s< z BaseDatabaseWrapper.__init__c C s d| j j� d| j�d| j�d�S )N�<z vendor=z alias=�>)� __class__� __qualname__�vendorr" �rI r r r �__repr__� s ���z BaseDatabaseWrapper.__repr__c C � dS )z Ensure the connection's timezone is set to `self.timezone_name` and return whether it changed or not. Fr rP r r r �ensure_timezone� � z#BaseDatabaseWrapper.ensure_timezonec C s. t jsdS | jd du rtjjS t| jd �S )a Return a tzinfo of the database connection time zone. This is only used when time zone support is enabled. When a datetime is read from the database, it is always returned in this time zone. When the database backend supports time zones, it doesn't matter which time zone Django uses, as long as aware datetimes are used everywhere. Other users connecting to the database can choose their own time zone. When the database backend doesn't support time zones, the time zone Django uses may be constrained by the requirements of other users of the database. N� TIME_ZONE)r �USE_TZr! �datetimer �utcr rP r r r r � s z BaseDatabaseWrapper.timezonec C s( t jst jS | jd du rdS | jd S )zC Name of the time zone of the database connection. rU N�UTC)r rV rU r! rP r r r � timezone_name� s z!BaseDatabaseWrapper.timezone_namec C s | j ptjS �N)r% r �DEBUGrP r r r �queries_logged� � z"BaseDatabaseWrapper.queries_loggedc C s0 t | j�| jjkrt�d�| jj�� t| j�S )NzLLimit for query logging exceeded, only the last {} queries will be returned.)�lenr$ r �warnings�warn�format�listrP r r r �queries� s � zBaseDatabaseWrapper.queriesc C � t d��)z)Return a tuple of the database's version.zNsubclasses of BaseDatabaseWrapper may require a get_database_version() method.��NotImplementedErrorrP r r r �get_database_version� � �z(BaseDatabaseWrapper.get_database_versionc C sh | j jdur0| �� | j jk r2d�tt| �� ��}d�tt| j j��}t| j� d|� d|� d���dS dS )zk Raise an error if the database version isn't supported by this version of Django. N�.� z or later is required (found z).)rB �minimum_database_versionrh �join�map�strr � display_name)rI � db_version�min_db_versionr r r � check_database_version_supported� s ���z4BaseDatabaseWrapper.check_database_version_supportedc C re )z<Return a dict of parameters suitable for get_new_connection.zNsubclasses of BaseDatabaseWrapper may require a get_connection_params() methodrf rP r r r �get_connection_params� ri z)BaseDatabaseWrapper.get_connection_paramsc C re )z"Open a connection to the database.zKsubclasses of BaseDatabaseWrapper may require a get_new_connection() methodrf )rI � conn_paramsr r r �get_new_connection� ri z&BaseDatabaseWrapper.get_new_connectionc C s& | j tvr| �� t�| j � dS dS )z,Initialize the database connection settings.N)r" �RAN_DB_VERSION_CHECKrs �addrP r r r �init_connection_state� s �z)BaseDatabaseWrapper.init_connection_statec C re )z9Create a cursor. Assume that a connection is established.zFsubclasses of BaseDatabaseWrapper may require a create_cursor() methodrf �rI �namer r r � create_cursor� ri z!BaseDatabaseWrapper.create_cursorc C s� | � � d| _g | _g | _d| _| jd | _| jd }|du r!dnt�� | | _ d| _ d| _ d| _ | � � }| �|�| _| �| jd � | �� tj| j| d� g | _dS )z>Connect to the database. Assume that the connection is closed.F�CONN_HEALTH_CHECKS� CONN_MAX_AGENT� AUTOCOMMIT)�senderr )�check_settingsr' r) r* r, r! r1 �time� monotonicr. r/ r0 r2 rt rv r �set_autocommitry r �sendrM r: )rI �max_ageru r r r �connect� s" zBaseDatabaseWrapper.connectc C s* | j d d urtjstd| j ��d S d S )NrU z=Connection '%s' cannot set TIME_ZONE because USE_TZ is False.)r! r rV r r" rP r r r r� s ���z"BaseDatabaseWrapper.check_settingsc C sB | j du r | j� | �� W d � dS 1 sw Y dS dS )z;Guarantee that a connection to the database is established.N)r �wrap_database_errorsr� rP r r r �ensure_connection s "��z%BaseDatabaseWrapper.ensure_connectionc C s* | � � | jr| �|�}|S | �|�}|S )zY Validate the connection is usable and perform database cursor wrapping. )�validate_thread_sharingr] �make_debug_cursor� make_cursor)rI �cursor�wrapped_cursorr r r �_prepare_cursor% s �z#BaseDatabaseWrapper._prepare_cursorc C sJ | � � | �� | j� | �| �|��W d � S 1 s w Y d S r[ )� close_if_health_check_failedr� r� r� r| rz r r r �_cursor0 s $�zBaseDatabaseWrapper._cursorc C �| | j d ur<t| d��( | j� | j �� W d � W d � S 1 s%w Y W d � d S 1 s5w Y d S d S )N�COMMIT)r r r� �commitrP r r r �_commit6 � R��zBaseDatabaseWrapper._commitc C r� )N�ROLLBACK)r r r� �rollbackrP r r r � _rollback; r� z BaseDatabaseWrapper._rollbackc C sB | j d ur | j� | j �� W d � S 1 sw Y d S d S r[ )r r� �closerP r r r �_close@ s $��zBaseDatabaseWrapper._closec C � | � � S )z3Create a cursor, opening a connection if necessary.)r� rP r r r r� G s zBaseDatabaseWrapper.cursorc C s( | � � | �� | �� d| _d| _dS )z.Commit a transaction and reset the dirty flag.FTN)r� �validate_no_atomic_blockr� r0 r; rP r r r r� L s zBaseDatabaseWrapper.commitc C s. | � � | �� | �� d| _d| _g | _dS )z1Roll back a transaction and reset the dirty flag.FN)r� r� r� r0 r, r: rP r r r r� V s z BaseDatabaseWrapper.rollbackc C sj | � � g | _| js| jdu rdS z| �� W | jr"d| _d| _dS d| _dS | jr1d| _d| _w d| _w )z%Close the connection to the database.NT)r� r: r/ r r� r' r, rP r r r r� a s � zBaseDatabaseWrapper.closec C �@ | � � �}|�| j�|�� W d � d S 1 sw Y d S r[ )r� �executerF �savepoint_create_sql�rI �sidr� r r r � _savepointw � "�z BaseDatabaseWrapper._savepointc C r� r[ )r� r� rF �savepoint_rollback_sqlr� r r r �_savepoint_rollback{ r� z'BaseDatabaseWrapper._savepoint_rollbackc C r� r[ )r� r� rF �savepoint_commit_sqlr� r r r �_savepoint_commit r� z%BaseDatabaseWrapper._savepoint_commitc C s | j jo| �� S r[ )rB �uses_savepoints�get_autocommitrP r r r �_savepoint_allowed� s z&BaseDatabaseWrapper._savepoint_allowedc C sV | � � sdS t�� }t|��dd�}| jd7 _d|| jf }| �� | �|� |S )z� Create a savepoint inside the current transaction. Return an identifier for the savepoint that will be used for the subsequent rollback or commit. Do nothing if savepoints are not supported. N�-� � zs%s_x%d)r� r7 r8 ro �replacer( r� r� )rI � thread_ident�tidr� r r r � savepoint� s z BaseDatabaseWrapper.savepointc s8 | � � sdS | �� | �� � � fdd�| jD �| _dS )zW Roll back to a savepoint. Do nothing if savepoints are not supported. Nc s$ g | ]\}}}� |vr|||f�qS r r )�.0�sids�func�robust�r� r r � <listcomp>� s �z:BaseDatabaseWrapper.savepoint_rollback.<locals>.<listcomp>)r� r� r� r: �rI r� r r� r �savepoint_rollback� s �z&BaseDatabaseWrapper.savepoint_rollbackc C s" | � � sdS | �� | �|� dS )zR Release a savepoint. Do nothing if savepoints are not supported. N)r� r� r� r� r r r �savepoint_commit� s z$BaseDatabaseWrapper.savepoint_commitc C s d| _ dS )zY Reset the counter used to generate unique savepoint ids in this thread. r N)r( rP r r r �clean_savepoints� s z$BaseDatabaseWrapper.clean_savepointsc C re )zR Backend-specific implementation to enable or disable autocommit. zHsubclasses of BaseDatabaseWrapper may require a _set_autocommit() methodrf )rI r& r r r �_set_autocommit� s �z#BaseDatabaseWrapper._set_autocommitc C s | � � | jS )zGet the autocommit state.)r� r& rP r r r r� � s z"BaseDatabaseWrapper.get_autocommitFc C s� | � � | �� | �� |o| ot| d�}|r | �� n"|r%| �|� nt| d�� | �|� W d � n1 s:w Y || _|rP| jrR| � � d| _dS dS dS )a� Enable or disable autocommit. The usual way to start a transaction is to turn autocommit off. SQLite does not properly start a transaction when disabling autocommit. To avoid this buggy behavior and to actually enter a new transaction, an explicit BEGIN is required. Using force_begin_transaction_with_broken_autocommit=True will issue an explicit BEGIN with SQLite. This option will be ignored for other backends. �#_start_transaction_under_autocommit�BEGINNF) r� r� r� �hasattrr� r� r r& r; �run_and_clear_commit_hooks)rI r& �.force_begin_transaction_with_broken_autocommit�"start_transaction_under_autocommitr r r r� � s( �� � �z"BaseDatabaseWrapper.set_autocommitc C s | j std��| jS )z9Get the "needs rollback" flag -- for *advanced use* only.�<The rollback flag doesn't work outside of an 'atomic' block.�r' r r, rP r r r � get_rollback� s �z BaseDatabaseWrapper.get_rollbackc C s | j std��|| _dS )zT Set or unset the "needs rollback" flag -- for *advanced use* only. r� Nr� )rI r� r r r � set_rollback s � z BaseDatabaseWrapper.set_rollbackc C s | j rtd��dS )z,Raise an error if an atomic block is active.z3This is forbidden when an 'atomic' block is active.N)r' r rP r r r r� s ��z,BaseDatabaseWrapper.validate_no_atomic_blockc C s | j r td�| j�d S )NzlAn error occurred in the current transaction. You can't execute queries until the end of the 'atomic' block.)r, r r- rP r r r � validate_no_broken_transaction s ���z2BaseDatabaseWrapper.validate_no_broken_transactionc c s8 � | � � }zdV W |r| �� dS dS |r| �� w w )z: Disable foreign key constraint checking. N)�disable_constraint_checking�enable_constraint_checking)rI �disabledr r r �constraint_checks_disabled s � � �z.BaseDatabaseWrapper.constraint_checks_disabledc C rR )z� Backends can implement as needed to temporarily disable foreign key constraint checking. Should return True if the constraints were disabled and will need to be reenabled. Fr rP r r r r� & � z/BaseDatabaseWrapper.disable_constraint_checkingc C rR )zh Backends can implement as needed to re-enable foreign key constraint checking. Nr rP r r r r� . rT z.BaseDatabaseWrapper.enable_constraint_checkingc C rR )z� Backends can override this method if they can apply constraint checking (e.g. via "SET CONSTRAINTS ALL IMMEDIATE"). Should raise an IntegrityError if any invalid foreign key references are encountered. Nr )rI � table_namesr r r �check_constraints5 r� z%BaseDatabaseWrapper.check_constraintsc C re )a Test if the database connection is usable. This method may assume that self.connection is not None. Actual implementations should take care not to raise exceptions as that may prevent Django from recycling unusable connections. zCsubclasses of BaseDatabaseWrapper may require an is_usable() methodrf rP r r r � is_usable? s �z BaseDatabaseWrapper.is_usablec C s4 | j du s | jr | jr dS | �� s| �� d| _dS )z5Close existing connection if it fails a health check.NT)r r1 r2 r� r� rP r r r r� L s �� z0BaseDatabaseWrapper.close_if_health_check_failedc C s� | j dur=d| _| �� | jd kr| �� dS | jr+| �� r%d| _d| _n| �� dS | jdur?t� � | jkrA| �� dS dS dS dS )z Close the current connection if unrecoverable errors have occurred or if it outlived its maximum age. NFr T) r r2 r� r! r� r0 r� r. r� r� rP r r r � close_if_unusable_or_obsoleteY s �z1BaseDatabaseWrapper.close_if_unusable_or_obsoletec C s4 | j � | jdkW d � S 1 sw Y d S r �r5 r6 rP r r r �allow_thread_sharingv s $�z(BaseDatabaseWrapper.allow_thread_sharingc C s: | j � | jd7 _W d � d S 1 sw Y d S )Nr� r� rP r r r �inc_thread_sharing{ s "�z&BaseDatabaseWrapper.inc_thread_sharingc C sL | j � | jdkr td��| jd8 _W d � d S 1 s w Y d S )Nr z5Cannot decrement the thread sharing count below zero.r� )r5 r6 � RuntimeErrorrP r r r �dec_thread_sharing s �"�z&BaseDatabaseWrapper.dec_thread_sharingc C s6 | j s| jt�� kstd| j| jt�� f ��dS dS )a3 Validate that the connection isn't accessed by another thread than the one which originally created it, unless the connection was explicitly authorized to be shared between threads (via the `inc_thread_sharing()` method). Raise an exception if the validation fails. z�DatabaseWrapper objects created in a thread can only be used in that same thread. The object with alias '%s' was created in thread id %s and this is thread id %s.N)r� r9 r7 r8 r r" rP r r r r� � s ���z+BaseDatabaseWrapper.validate_thread_sharingc C rR )z~ Hook to do any database check or preparation, generally called before migrating a project or an app. Nr rP r r r �prepare_database� rT z$BaseDatabaseWrapper.prepare_databasec C s t | �S )z� Context manager and decorator that re-throws backend-specific database exceptions using Django's common wrappers. r rP r r r r� � s z(BaseDatabaseWrapper.wrap_database_errorsc C r� )z� Return a cursor that tries to avoid caching in the database (if supported by the database), otherwise return a regular cursor. )r� rP r r r �chunked_cursor� s z"BaseDatabaseWrapper.chunked_cursorc C � t �|| �S )z:Create a cursor that logs all queries in self.queries_log.)r �CursorDebugWrapper�rI r� r r r r� � r^ z%BaseDatabaseWrapper.make_debug_cursorc C r� )z&Create a cursor without debug logging.)r � CursorWrapperr� r r r r� � r^ z BaseDatabaseWrapper.make_cursorc c sb � | j du }z"| �� � }|V W d � n1 sw Y W |r'| �� dS dS |r0| �� w w )a8 Context manager that ensures that a connection is established, and if it opened one, closes it to avoid leaving a dangling connection. This is useful for operations outside of the request-response cycle. Provide a cursor: with self.temporary_connection() as cursor: ... N)r r� r� )rI � must_closer� r r r �temporary_connection� s � �� � �z(BaseDatabaseWrapper.temporary_connectionc c st � | j i | j�ddi�td�}z%|�� � }|V W d � n1 s"w Y W |�� dS W |�� dS |�� w )aq Return a cursor from an alternative connection to be used when there is no need to access the main database, specifically for test db creation/deletion. This also prevents the production database from being exposed to potential child threads while (or after) the test database is destroyed. Refs #10868, #17786, #16969. �NAMEN)r" )rM r! � NO_DB_ALIASr� r� )rI �connr� r r r � _nodb_cursor� s � � �z BaseDatabaseWrapper._nodb_cursorc O s* | j du r td��| j | g|�R i |��S )zG Return a new instance of this backend's SchemaEditor. NzFThe SchemaEditorClass attribute of this database wrapper is still None)�SchemaEditorClassrg )rI �args�kwargsr r r � schema_editor� s �z!BaseDatabaseWrapper.schema_editorc C s� t |�std��| jr| j�t| j�||f� d S | �� s!td��|rJz|� W d S t yI } zt j d|j � d�|dd� W Y d }~d S d }~ww |� d S )Nz*on_commit()'s callback must be a callable.z;on_commit() cannot be used in manual transaction management�Error calling z in on_commit() (%s).T��exc_info) �callable� TypeErrorr' r: �append�setr) r� r � Exception�logger�errorrN )rI r� r� �er r r � on_commit� s( � ��� z BaseDatabaseWrapper.on_commitc C s� | � � | j}g | _|rB|�d�\}}}|r;z|� W n" ty: } ztjd|j� d�|dd� W Y d }~nd }~ww |� |s d S d S )Nr r� z( in on_commit() during transaction (%s).Tr� )r� r: �popr� r� r� rN )rI �current_run_on_commit�_r� r� r� r r r r� � s$ ��� �z.BaseDatabaseWrapper.run_and_clear_commit_hooksc c s2 � | j �|� z dV W | j �� dS | j �� w )z| Return a context manager under which the wrapper is applied to suitable database query executions. N)r< r� r� )rI �wrapperr r r �execute_wrapper s � z#BaseDatabaseWrapper.execute_wrapperc C s( t �| j�}|du r | j}t| �||�S )zy Return a copy of this connection. For tests that require two connections to the same database. N)�copy�deepcopyr! r" �type)rI r" r! r r r r� s zBaseDatabaseWrapper.copyr[ )F)W�__name__� __module__rN �__doc__� data_types�data_types_suffix�data_type_check_constraintsrF rO rp r� r= r? rA rC rE r rG r# r rJ rQ rS r r rZ �propertyr] rd rh rs rt rv ry r| r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r , s� D �% r )-r7 r� rW �loggingr3 r� r` � collectionsr � contextlibr �django.db.backends.utilsr r � ImportError� backports� django.confr �django.core.exceptionsr � django.dbr r r �django.db.backendsr �"django.db.backends.base.validationr �django.db.backends.signalsr �django.db.transactionr �django.db.utilsr �django.utils.asyncior �django.utils.functionalr r� r� rw � getLoggerr� r r r r r r �<module> s< � PK �"�Zɕ��! �! ) __pycache__/introspection.cpython-310.pycnu �[��� o �h� � @ s6 d dl mZ edddg�Zedd�ZG dd� d�Zd S ) � )� namedtuple� TableInfo�name�type� FieldInfozSname type_code display_size internal_size precision scale null_ok default collationc @ s� e Zd ZdZi Zdd� Zdd� Zdd� Zd$d d �Zd d � Z dd� Z dd� Z d%dd�Z dd� Z dd� Zd&dd�Zd d � Zd d � Zd d!� Zd"d#� ZdS )'�BaseDatabaseIntrospectionz5Encapsulate backend-specific introspection utilities.c C s || _ d S �N)� connection)�selfr � r �X/usr/local/CyberCP/lib/python3.10/site-packages/django/db/backends/base/introspection.py�__init__ s z"BaseDatabaseIntrospection.__init__c C s | j | S )a Hook for a database backend to use the cursor description to match a Django field type to a database column. For Oracle, the column data_type on its own is insufficient to distinguish between a FloatField and IntegerField, for example. )�data_types_reverse)r � data_type� descriptionr r r �get_field_type s z(BaseDatabaseIntrospection.get_field_typec C s |S )z� Apply a conversion to the identifier for the purposes of comparison. The default identifier converter is for case sensitive comparison. r )r r r r r �identifier_converter s z.BaseDatabaseIntrospection.identifier_converterNFc sP � �fdd�}|du r$�j �� � }||�W d � S 1 s w Y ||�S )a Return a list of names of all tables that exist in the database. Sort the returned table list by Python's default sorting. Do NOT use the database's ORDER BY here to avoid subtle differences in sorting order between databases. c s t � fdd���| �D ��S )Nc 3 s$ � | ] }� s |j d kr|jV qdS )�tN)r r )�.0�ti�� include_viewsr r � <genexpr>1 s � � ��zKBaseDatabaseIntrospection.table_names.<locals>.get_names.<locals>.<genexpr>)�sorted�get_table_list)�cursor�r r r r � get_names0 s �z8BaseDatabaseIntrospection.table_names.<locals>.get_namesN)r r )r r r r r r r � table_names( s �z%BaseDatabaseIntrospection.table_namesc C � t d��)z Return an unsorted list of TableInfo named tuples of all tables and views that exist in the database. zMsubclasses of BaseDatabaseIntrospection may require a get_table_list() method��NotImplementedError)r r r r r r < � �z(BaseDatabaseIntrospection.get_table_listc C r )zi Return a description of the table with the DB-API cursor.description interface. zUsubclasses of BaseDatabaseIntrospection may require a get_table_description() method.r �r r � table_namer r r �get_table_descriptionF r" z/BaseDatabaseIntrospection.get_table_descriptionc s0 ddl m} ddlm� � �fdd�|�� D �S )Nr )�apps)�routerc 3 s8 � | ]}� � |�jj�D ] }|j��j�r |V q qd S r )�get_migratable_modelsr �alias�_meta� can_migrate)r � app_config�model�r' r r r r T s � � � �zBBaseDatabaseIntrospection.get_migratable_models.<locals>.<genexpr>)� django.appsr& � django.dbr' �get_app_configs)r r& r r. r r( P s �z/BaseDatabaseIntrospection.get_migratable_modelsTc sx t � }��� D ]}|jjsq|�|jj� |�dd� |jjD �� qt|�}|r:t �j |d��� � �fdd�|D �}|S )z� Return a list of all table names that have associated Django models and are in INSTALLED_APPS. If only_existing is True, include only the tables in the database. c s s$ � | ] }|j jjjr|�� V qd S r )� remote_field�throughr* �managed� m2m_db_table)r �fr r r r g s � � �z?BaseDatabaseIntrospection.django_table_names.<locals>.<genexpr>r c s g | ] }�� |�� v r|�qS r )r )r r ��existing_tablesr r r � <listcomp>o s z@BaseDatabaseIntrospection.django_table_names.<locals>.<listcomp>) �setr( r* r4 �add�db_table�update�local_many_to_many�listr )r � only_existingr �tablesr- r r7 r �django_table_names[ s � �z,BaseDatabaseIntrospection.django_table_namesc s( t t� j����� �fdd�� �� D �S )ze Return a set of all models represented by the provided list of table names. c s" h | ] }� � |jj��v r|�qS r )r r* r< )r �m�r rA r r � <setcomp>z s �z=BaseDatabaseIntrospection.installed_models.<locals>.<setcomp>)r: �mapr r( rD r rD r �installed_modelst s �z*BaseDatabaseIntrospection.installed_modelsc C s� g }| j �� �J}| �� D ]<}|jjsq |jjrq |�| �||jj|jj �� |jj D ] }|j j jj rG| �||�� �}|�|pE|�� dd�g� q*q W d � |S 1 sTw Y |S )zi Return a list of information about all DB sequences for all models in all apps. N)�table�column)r r r( r* r4 �swapped�extend� get_sequencesr< � local_fieldsr> r2 r3 � auto_createdr5 )r � sequence_listr r- r6 �sequencer r r rO � s2 �� ���� ��z'BaseDatabaseIntrospection.sequence_listr c C r )z� Return a list of introspected sequences for table_name. Each sequence is a dict: {'table': <table_name>, 'column': <column_name>}. An optional 'name' key can be added if the backend supports named sequences. zLsubclasses of BaseDatabaseIntrospection may require a get_sequences() methodr )r r r$ � table_fieldsr r r rL � s �z'BaseDatabaseIntrospection.get_sequencesc C r )z� Return a dictionary of {field_name: (field_name_other_table, other_table)} representing all foreign keys in the given table. zMsubclasses of BaseDatabaseIntrospection may require a get_relations() method.r r# r r r � get_relations� r" z'BaseDatabaseIntrospection.get_relationsc C s | � ||�}|r |d S dS )zP Return the name of the primary key column for the given table. r N)�get_primary_key_columns)r r r$ �columnsr r r �get_primary_key_column� s z0BaseDatabaseIntrospection.get_primary_key_columnc C s. | � ||��� D ] }|d r|d S qdS )z9Return a list of primary key columns for the given table.� primary_keyrT N)�get_constraints�values)r r r$ � constraintr r r rS � s �z1BaseDatabaseIntrospection.get_primary_key_columnsc C r )a_ Retrieve any constraints or keys (unique, pk, fk, check, index) across one or more columns. Return a dict mapping constraint names to their attributes, where attributes is a dict with keys: * columns: List of columns this covers * primary_key: True if primary key, False otherwise * unique: True if this is a unique constraint, False otherwise * foreign_key: (table, column) of target, or None * check: True if check constraint, False otherwise * index: True if index, False otherwise. * orders: The order (ASC/DESC) defined for the columns of indexes * type: The type of the index (btree, hash, etc.) Some backends may return special constraint names that don't exist if they don't name constraints of a certain type (e.g. SQLite) zNsubclasses of BaseDatabaseIntrospection may require a get_constraints() methodr r# r r r rW � s �z)BaseDatabaseIntrospection.get_constraints)NF)FT)r )�__name__� __module__� __qualname__�__doc__r r r r r r r% r( rB rG rO rL rR rU rS rW r r r r r s$ r N)� collectionsr r r r r r r r �<module> s �PK �"�Z��� q q operations.pynu �[��� import datetime import decimal import json from importlib import import_module import sqlparse from django.conf import settings from django.db import NotSupportedError, transaction from django.db.backends import utils from django.utils import timezone from django.utils.encoding import force_str class BaseDatabaseOperations: """ Encapsulate backend-specific differences, such as the way a backend performs ordering or calculates the ID of a recently-inserted row. """ compiler_module = "django.db.models.sql.compiler" # Integer field safe ranges by `internal_type` as documented # in docs/ref/models/fields.txt. integer_field_ranges = { "SmallIntegerField": (-32768, 32767), "IntegerField": (-2147483648, 2147483647), "BigIntegerField": (-9223372036854775808, 9223372036854775807), "PositiveBigIntegerField": (0, 9223372036854775807), "PositiveSmallIntegerField": (0, 32767), "PositiveIntegerField": (0, 2147483647), "SmallAutoField": (-32768, 32767), "AutoField": (-2147483648, 2147483647), "BigAutoField": (-9223372036854775808, 9223372036854775807), } set_operators = { "union": "UNION", "intersection": "INTERSECT", "difference": "EXCEPT", } # Mapping of Field.get_internal_type() (typically the model field's class # name) to the data type to use for the Cast() function, if different from # DatabaseWrapper.data_types. cast_data_types = {} # CharField data type if the max_length argument isn't provided. cast_char_field_without_max_length = None # Start and end points for window expressions. PRECEDING = "PRECEDING" FOLLOWING = "FOLLOWING" UNBOUNDED_PRECEDING = "UNBOUNDED " + PRECEDING UNBOUNDED_FOLLOWING = "UNBOUNDED " + FOLLOWING CURRENT_ROW = "CURRENT ROW" # Prefix for EXPLAIN queries, or None EXPLAIN isn't supported. explain_prefix = None def __init__(self, connection): self.connection = connection self._cache = None def autoinc_sql(self, table, column): """ Return any SQL needed to support auto-incrementing primary keys, or None if no SQL is necessary. This SQL is executed when a table is created. """ return None def bulk_batch_size(self, fields, objs): """ Return the maximum allowed batch size for the backend. The fields are the fields going to be inserted in the batch, the objs contains all the objects to be inserted. """ return len(objs) def format_for_duration_arithmetic(self, sql): raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a " "format_for_duration_arithmetic() method." ) def cache_key_culling_sql(self): """ Return an SQL query that retrieves the first cache key greater than the n smallest. This is used by the 'db' cache backend to determine where to start culling. """ cache_key = self.quote_name("cache_key") return f"SELECT {cache_key} FROM %s ORDER BY {cache_key} LIMIT 1 OFFSET %%s" def unification_cast_sql(self, output_field): """ Given a field instance, return the SQL that casts the result of a union to that type. The resulting string should contain a '%s' placeholder for the expression being cast. """ return "%s" def date_extract_sql(self, lookup_type, sql, params): """ Given a lookup_type of 'year', 'month', or 'day', return the SQL that extracts a value from the given date field field_name. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a date_extract_sql() " "method" ) def date_trunc_sql(self, lookup_type, sql, params, tzname=None): """ Given a lookup_type of 'year', 'month', or 'day', return the SQL that truncates the given date or datetime field field_name to a date object with only the given specificity. If `tzname` is provided, the given value is truncated in a specific timezone. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a date_trunc_sql() " "method." ) def datetime_cast_date_sql(self, sql, params, tzname): """ Return the SQL to cast a datetime value to date value. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a " "datetime_cast_date_sql() method." ) def datetime_cast_time_sql(self, sql, params, tzname): """ Return the SQL to cast a datetime value to time value. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a " "datetime_cast_time_sql() method" ) def datetime_extract_sql(self, lookup_type, sql, params, tzname): """ Given a lookup_type of 'year', 'month', 'day', 'hour', 'minute', or 'second', return the SQL that extracts a value from the given datetime field field_name. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a datetime_extract_sql() " "method" ) def datetime_trunc_sql(self, lookup_type, sql, params, tzname): """ Given a lookup_type of 'year', 'month', 'day', 'hour', 'minute', or 'second', return the SQL that truncates the given datetime field field_name to a datetime object with only the given specificity. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a datetime_trunc_sql() " "method" ) def time_trunc_sql(self, lookup_type, sql, params, tzname=None): """ Given a lookup_type of 'hour', 'minute' or 'second', return the SQL that truncates the given time or datetime field field_name to a time object with only the given specificity. If `tzname` is provided, the given value is truncated in a specific timezone. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a time_trunc_sql() method" ) def time_extract_sql(self, lookup_type, sql, params): """ Given a lookup_type of 'hour', 'minute', or 'second', return the SQL that extracts a value from the given time field field_name. """ return self.date_extract_sql(lookup_type, sql, params) def deferrable_sql(self): """ Return the SQL to make a constraint "initially deferred" during a CREATE TABLE statement. """ return "" def distinct_sql(self, fields, params): """ Return an SQL DISTINCT clause which removes duplicate rows from the result set. If any fields are given, only check the given fields for duplicates. """ if fields: raise NotSupportedError( "DISTINCT ON fields is not supported by this database backend" ) else: return ["DISTINCT"], [] def fetch_returned_insert_columns(self, cursor, returning_params): """ Given a cursor object that has just performed an INSERT...RETURNING statement into a table, return the newly created data. """ return cursor.fetchone() def field_cast_sql(self, db_type, internal_type): """ Given a column type (e.g. 'BLOB', 'VARCHAR') and an internal type (e.g. 'GenericIPAddressField'), return the SQL to cast it before using it in a WHERE statement. The resulting string should contain a '%s' placeholder for the column being searched against. """ return "%s" def force_no_ordering(self): """ Return a list used in the "ORDER BY" clause to force no ordering at all. Return an empty list to include nothing in the ordering. """ return [] def for_update_sql(self, nowait=False, skip_locked=False, of=(), no_key=False): """ Return the FOR UPDATE SQL clause to lock rows for an update operation. """ return "FOR%s UPDATE%s%s%s" % ( " NO KEY" if no_key else "", " OF %s" % ", ".join(of) if of else "", " NOWAIT" if nowait else "", " SKIP LOCKED" if skip_locked else "", ) def _get_limit_offset_params(self, low_mark, high_mark): offset = low_mark or 0 if high_mark is not None: return (high_mark - offset), offset elif offset: return self.connection.ops.no_limit_value(), offset return None, offset def limit_offset_sql(self, low_mark, high_mark): """Return LIMIT/OFFSET SQL clause.""" limit, offset = self._get_limit_offset_params(low_mark, high_mark) return " ".join( sql for sql in ( ("LIMIT %d" % limit) if limit else None, ("OFFSET %d" % offset) if offset else None, ) if sql ) def last_executed_query(self, cursor, sql, params): """ Return a string of the query last executed by the given cursor, with placeholders replaced with actual values. `sql` is the raw query containing placeholders and `params` is the sequence of parameters. These are used by default, but this method exists for database backends to provide a better implementation according to their own quoting schemes. """ # Convert params to contain string values. def to_string(s): return force_str(s, strings_only=True, errors="replace") if isinstance(params, (list, tuple)): u_params = tuple(to_string(val) for val in params) elif params is None: u_params = () else: u_params = {to_string(k): to_string(v) for k, v in params.items()} return "QUERY = %r - PARAMS = %r" % (sql, u_params) def last_insert_id(self, cursor, table_name, pk_name): """ Given a cursor object that has just performed an INSERT statement into a table that has an auto-incrementing ID, return the newly created ID. `pk_name` is the name of the primary-key column. """ return cursor.lastrowid def lookup_cast(self, lookup_type, internal_type=None): """ Return the string to use in a query when performing lookups ("contains", "like", etc.). It should contain a '%s' placeholder for the column being searched against. """ return "%s" def max_in_list_size(self): """ Return the maximum number of items that can be passed in a single 'IN' list condition, or None if the backend does not impose a limit. """ return None def max_name_length(self): """ Return the maximum length of table and column names, or None if there is no limit. """ return None def no_limit_value(self): """ Return the value to use for the LIMIT when we are wanting "LIMIT infinity". Return None if the limit clause can be omitted in this case. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a no_limit_value() method" ) def pk_default_value(self): """ Return the value to use during an INSERT statement to specify that the field should use its default value. """ return "DEFAULT" def prepare_sql_script(self, sql): """ Take an SQL script that may contain multiple lines and return a list of statements to feed to successive cursor.execute() calls. Since few databases are able to process raw SQL scripts in a single cursor.execute() call and PEP 249 doesn't talk about this use case, the default implementation is conservative. """ return [ sqlparse.format(statement, strip_comments=True) for statement in sqlparse.split(sql) if statement ] def process_clob(self, value): """ Return the value of a CLOB column, for backends that return a locator object that requires additional processing. """ return value def return_insert_columns(self, fields): """ For backends that support returning columns as part of an insert query, return the SQL and params to append to the INSERT query. The returned fragment should contain a format string to hold the appropriate column. """ pass def compiler(self, compiler_name): """ Return the SQLCompiler class corresponding to the given name, in the namespace corresponding to the `compiler_module` attribute on this backend. """ if self._cache is None: self._cache = import_module(self.compiler_module) return getattr(self._cache, compiler_name) def quote_name(self, name): """ Return a quoted version of the given table, index, or column name. Do not quote the given name if it's already been quoted. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a quote_name() method" ) def regex_lookup(self, lookup_type): """ Return the string to use in a query when performing regular expression lookups (using "regex" or "iregex"). It should contain a '%s' placeholder for the column being searched against. If the feature is not supported (or part of it is not supported), raise NotImplementedError. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations may require a regex_lookup() method" ) def savepoint_create_sql(self, sid): """ Return the SQL for starting a new savepoint. Only required if the "uses_savepoints" feature is True. The "sid" parameter is a string for the savepoint id. """ return "SAVEPOINT %s" % self.quote_name(sid) def savepoint_commit_sql(self, sid): """ Return the SQL for committing the given savepoint. """ return "RELEASE SAVEPOINT %s" % self.quote_name(sid) def savepoint_rollback_sql(self, sid): """ Return the SQL for rolling back the given savepoint. """ return "ROLLBACK TO SAVEPOINT %s" % self.quote_name(sid) def set_time_zone_sql(self): """ Return the SQL that will set the connection's time zone. Return '' if the backend doesn't support time zones. """ return "" def sql_flush(self, style, tables, *, reset_sequences=False, allow_cascade=False): """ Return a list of SQL statements required to remove all data from the given database tables (without actually removing the tables themselves). The `style` argument is a Style object as returned by either color_style() or no_style() in django.core.management.color. If `reset_sequences` is True, the list includes SQL statements required to reset the sequences. The `allow_cascade` argument determines whether truncation may cascade to tables with foreign keys pointing the tables being truncated. PostgreSQL requires a cascade even if these tables are empty. """ raise NotImplementedError( "subclasses of BaseDatabaseOperations must provide an sql_flush() method" ) def execute_sql_flush(self, sql_list): """Execute a list of SQL statements to flush the database.""" with transaction.atomic( using=self.connection.alias, savepoint=self.connection.features.can_rollback_ddl, ): with self.connection.cursor() as cursor: for sql in sql_list: cursor.execute(sql) def sequence_reset_by_name_sql(self, style, sequences): """ Return a list of the SQL statements required to reset sequences passed in `sequences`. The `style` argument is a Style object as returned by either color_style() or no_style() in django.core.management.color. """ return [] def sequence_reset_sql(self, style, model_list): """ Return a list of the SQL statements required to reset sequences for the given models. The `style` argument is a Style object as returned by either color_style() or no_style() in django.core.management.color. """ return [] # No sequence reset required by default. def start_transaction_sql(self): """Return the SQL statement required to start a transaction.""" return "BEGIN;" def end_transaction_sql(self, success=True): """Return the SQL statement required to end a transaction.""" if not success: return "ROLLBACK;" return "COMMIT;" def tablespace_sql(self, tablespace, inline=False): """ Return the SQL that will be used in a query to define the tablespace. Return '' if the backend doesn't support tablespaces. If `inline` is True, append the SQL to a row; otherwise append it to the entire CREATE TABLE or CREATE INDEX statement. """ return "" def prep_for_like_query(self, x): """Prepare a value for use in a LIKE query.""" return str(x).replace("\\", "\\\\").replace("%", r"\%").replace("_", r"\_") # Same as prep_for_like_query(), but called for "iexact" matches, which # need not necessarily be implemented using "LIKE" in the backend. prep_for_iexact_query = prep_for_like_query def validate_autopk_value(self, value): """ Certain backends do not accept some values for "serial" fields (for example zero in MySQL). Raise a ValueError if the value is invalid, otherwise return the validated value. """ return value def adapt_unknown_value(self, value): """ Transform a value to something compatible with the backend driver. This method only depends on the type of the value. It's designed for cases where the target type isn't known, such as .raw() SQL queries. As a consequence it may not work perfectly in all circumstances. """ if isinstance(value, datetime.datetime): # must be before date return self.adapt_datetimefield_value(value) elif isinstance(value, datetime.date): return self.adapt_datefield_value(value) elif isinstance(value, datetime.time): return self.adapt_timefield_value(value) elif isinstance(value, decimal.Decimal): return self.adapt_decimalfield_value(value) else: return value def adapt_integerfield_value(self, value, internal_type): return value def adapt_datefield_value(self, value): """ Transform a date value to an object compatible with what is expected by the backend driver for date columns. """ if value is None: return None return str(value) def adapt_datetimefield_value(self, value): """ Transform a datetime value to an object compatible with what is expected by the backend driver for datetime columns. """ if value is None: return None # Expression values are adapted by the database. if hasattr(value, "resolve_expression"): return value return str(value) def adapt_timefield_value(self, value): """ Transform a time value to an object compatible with what is expected by the backend driver for time columns. """ if value is None: return None # Expression values are adapted by the database. if hasattr(value, "resolve_expression"): return value if timezone.is_aware(value): raise ValueError("Django does not support timezone-aware times.") return str(value) def adapt_decimalfield_value(self, value, max_digits=None, decimal_places=None): """ Transform a decimal.Decimal value to an object compatible with what is expected by the backend driver for decimal (numeric) columns. """ return utils.format_number(value, max_digits, decimal_places) def adapt_ipaddressfield_value(self, value): """ Transform a string representation of an IP address into the expected type for the backend driver. """ return value or None def adapt_json_value(self, value, encoder): return json.dumps(value, cls=encoder) def year_lookup_bounds_for_date_field(self, value, iso_year=False): """ Return a two-elements list with the lower and upper bound to be used with a BETWEEN operator to query a DateField value using a year lookup. `value` is an int, containing the looked-up year. If `iso_year` is True, return bounds for ISO-8601 week-numbering years. """ if iso_year: first = datetime.date.fromisocalendar(value, 1, 1) second = datetime.date.fromisocalendar( value + 1, 1, 1 ) - datetime.timedelta(days=1) else: first = datetime.date(value, 1, 1) second = datetime.date(value, 12, 31) first = self.adapt_datefield_value(first) second = self.adapt_datefield_value(second) return [first, second] def year_lookup_bounds_for_datetime_field(self, value, iso_year=False): """ Return a two-elements list with the lower and upper bound to be used with a BETWEEN operator to query a DateTimeField value using a year lookup. `value` is an int, containing the looked-up year. If `iso_year` is True, return bounds for ISO-8601 week-numbering years. """ if iso_year: first = datetime.datetime.fromisocalendar(value, 1, 1) second = datetime.datetime.fromisocalendar( value + 1, 1, 1 ) - datetime.timedelta(microseconds=1) else: first = datetime.datetime(value, 1, 1) second = datetime.datetime(value, 12, 31, 23, 59, 59, 999999) if settings.USE_TZ: tz = timezone.get_current_timezone() first = timezone.make_aware(first, tz) second = timezone.make_aware(second, tz) first = self.adapt_datetimefield_value(first) second = self.adapt_datetimefield_value(second) return [first, second] def get_db_converters(self, expression): """ Return a list of functions needed to convert field data. Some field types on some backends do not provide data in the correct format, this is the hook for converter functions. """ return [] def convert_durationfield_value(self, value, expression, connection): if value is not None: return datetime.timedelta(0, 0, value) def check_expression_support(self, expression): """ Check that the backend supports the provided expression. This is used on specific backends to rule out known expressions that have problematic or nonexistent implementations. If the expression has a known problem, the backend should raise NotSupportedError. """ pass def conditional_expression_supported_in_where_clause(self, expression): """ Return True, if the conditional expression is supported in the WHERE clause. """ return True def combine_expression(self, connector, sub_expressions): """ Combine a list of subexpressions into a single expression, using the provided connecting operator. This is required because operators can vary between backends (e.g., Oracle with %% and &) and between subexpression types (e.g., date expressions). """ conn = " %s " % connector return conn.join(sub_expressions) def combine_duration_expression(self, connector, sub_expressions): return self.combine_expression(connector, sub_expressions) def binary_placeholder_sql(self, value): """ Some backends require special syntax to insert binary content (MySQL for example uses '_binary %s'). """ return "%s" def modify_insert_params(self, placeholder, params): """ Allow modification of insert parameters. Needed for Oracle Spatial backend due to #10888. """ return params def integer_field_range(self, internal_type): """ Given an integer field internal type (e.g. 'PositiveIntegerField'), return a tuple of the (min_value, max_value) form representing the range of the column type bound to the field. """ return self.integer_field_ranges[internal_type] def subtract_temporals(self, internal_type, lhs, rhs): if self.connection.features.supports_temporal_subtraction: lhs_sql, lhs_params = lhs rhs_sql, rhs_params = rhs return "(%s - %s)" % (lhs_sql, rhs_sql), (*lhs_params, *rhs_params) raise NotSupportedError( "This backend does not support %s subtraction." % internal_type ) def window_frame_start(self, start): if isinstance(start, int): if start < 0: return "%d %s" % (abs(start), self.PRECEDING) elif start == 0: return self.CURRENT_ROW elif start is None: return self.UNBOUNDED_PRECEDING raise ValueError( "start argument must be a negative integer, zero, or None, but got '%s'." % start ) def window_frame_end(self, end): if isinstance(end, int): if end == 0: return self.CURRENT_ROW elif end > 0: return "%d %s" % (end, self.FOLLOWING) elif end is None: return self.UNBOUNDED_FOLLOWING raise ValueError( "end argument must be a positive integer, zero, or None, but got '%s'." % end ) def window_frame_rows_start_end(self, start=None, end=None): """ Return SQL for start and end points in an OVER clause window frame. """ if not self.connection.features.supports_over_clause: raise NotSupportedError("This backend does not support window expressions.") return self.window_frame_start(start), self.window_frame_end(end) def window_frame_range_start_end(self, start=None, end=None): start_, end_ = self.window_frame_rows_start_end(start, end) features = self.connection.features if features.only_supports_unbounded_with_preceding_and_following and ( (start and start < 0) or (end and end > 0) ): raise NotSupportedError( "%s only supports UNBOUNDED together with PRECEDING and " "FOLLOWING." % self.connection.display_name ) return start_, end_ def explain_query_prefix(self, format=None, **options): if not self.connection.features.supports_explaining_query_execution: raise NotSupportedError( "This backend does not support explaining query execution." ) if format: supported_formats = self.connection.features.supported_explain_formats normalized_format = format.upper() if normalized_format not in supported_formats: msg = "%s is not a recognized format." % normalized_format if supported_formats: msg += " Allowed formats: %s" % ", ".join(sorted(supported_formats)) else: msg += ( f" {self.connection.display_name} does not support any formats." ) raise ValueError(msg) if options: raise ValueError("Unknown options: %s" % ", ".join(sorted(options.keys()))) return self.explain_prefix def insert_statement(self, on_conflict=None): return "INSERT INTO" def on_conflict_suffix_sql(self, fields, on_conflict, update_fields, unique_fields): return "" PK �"�Z �Ved d schema.pynu �[��� import logging import operator from datetime import datetime from django.conf import settings from django.db.backends.ddl_references import ( Columns, Expressions, ForeignKeyName, IndexName, Statement, Table, ) from django.db.backends.utils import names_digest, split_identifier, truncate_name from django.db.models import Deferrable, Index from django.db.models.sql import Query from django.db.transaction import TransactionManagementError, atomic from django.utils import timezone logger = logging.getLogger("django.db.backends.schema") def _is_relevant_relation(relation, altered_field): """ When altering the given field, must constraints on its model from the given relation be temporarily dropped? """ field = relation.field if field.many_to_many: # M2M reverse field return False if altered_field.primary_key and field.to_fields == [None]: # Foreign key constraint on the primary key, which is being altered. return True # Is the constraint targeting the field being altered? return altered_field.name in field.to_fields def _all_related_fields(model): # Related fields must be returned in a deterministic order. return sorted( model._meta._get_fields( forward=False, reverse=True, include_hidden=True, include_parents=False, ), key=operator.attrgetter("name"), ) def _related_non_m2m_objects(old_field, new_field): # Filter out m2m objects from reverse relations. # Return (old_relation, new_relation) tuples. related_fields = zip( ( obj for obj in _all_related_fields(old_field.model) if _is_relevant_relation(obj, old_field) ), ( obj for obj in _all_related_fields(new_field.model) if _is_relevant_relation(obj, new_field) ), ) for old_rel, new_rel in related_fields: yield old_rel, new_rel yield from _related_non_m2m_objects( old_rel.remote_field, new_rel.remote_field, ) class BaseDatabaseSchemaEditor: """ This class and its subclasses are responsible for emitting schema-changing statements to the databases - model creation/removal/alteration, field renaming, index fiddling, and so on. """ # Overrideable SQL templates sql_create_table = "CREATE TABLE %(table)s (%(definition)s)" sql_rename_table = "ALTER TABLE %(old_table)s RENAME TO %(new_table)s" sql_retablespace_table = "ALTER TABLE %(table)s SET TABLESPACE %(new_tablespace)s" sql_delete_table = "DROP TABLE %(table)s CASCADE" sql_create_column = "ALTER TABLE %(table)s ADD COLUMN %(column)s %(definition)s" sql_alter_column = "ALTER TABLE %(table)s %(changes)s" sql_alter_column_type = "ALTER COLUMN %(column)s TYPE %(type)s%(collation)s" sql_alter_column_null = "ALTER COLUMN %(column)s DROP NOT NULL" sql_alter_column_not_null = "ALTER COLUMN %(column)s SET NOT NULL" sql_alter_column_default = "ALTER COLUMN %(column)s SET DEFAULT %(default)s" sql_alter_column_no_default = "ALTER COLUMN %(column)s DROP DEFAULT" sql_alter_column_no_default_null = sql_alter_column_no_default sql_delete_column = "ALTER TABLE %(table)s DROP COLUMN %(column)s CASCADE" sql_rename_column = ( "ALTER TABLE %(table)s RENAME COLUMN %(old_column)s TO %(new_column)s" ) sql_update_with_default = ( "UPDATE %(table)s SET %(column)s = %(default)s WHERE %(column)s IS NULL" ) sql_unique_constraint = "UNIQUE (%(columns)s)%(deferrable)s" sql_check_constraint = "CHECK (%(check)s)" sql_delete_constraint = "ALTER TABLE %(table)s DROP CONSTRAINT %(name)s" sql_constraint = "CONSTRAINT %(name)s %(constraint)s" sql_create_check = "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s CHECK (%(check)s)" sql_delete_check = sql_delete_constraint sql_create_unique = ( "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s " "UNIQUE (%(columns)s)%(deferrable)s" ) sql_delete_unique = sql_delete_constraint sql_create_fk = ( "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s FOREIGN KEY (%(column)s) " "REFERENCES %(to_table)s (%(to_column)s)%(deferrable)s" ) sql_create_inline_fk = None sql_create_column_inline_fk = None sql_delete_fk = sql_delete_constraint sql_create_index = ( "CREATE INDEX %(name)s ON %(table)s " "(%(columns)s)%(include)s%(extra)s%(condition)s" ) sql_create_unique_index = ( "CREATE UNIQUE INDEX %(name)s ON %(table)s " "(%(columns)s)%(include)s%(condition)s" ) sql_rename_index = "ALTER INDEX %(old_name)s RENAME TO %(new_name)s" sql_delete_index = "DROP INDEX %(name)s" sql_create_pk = ( "ALTER TABLE %(table)s ADD CONSTRAINT %(name)s PRIMARY KEY (%(columns)s)" ) sql_delete_pk = sql_delete_constraint sql_delete_procedure = "DROP PROCEDURE %(procedure)s" sql_alter_table_comment = "COMMENT ON TABLE %(table)s IS %(comment)s" sql_alter_column_comment = "COMMENT ON COLUMN %(table)s.%(column)s IS %(comment)s" def __init__(self, connection, collect_sql=False, atomic=True): self.connection = connection self.collect_sql = collect_sql if self.collect_sql: self.collected_sql = [] self.atomic_migration = self.connection.features.can_rollback_ddl and atomic # State-managing methods def __enter__(self): self.deferred_sql = [] if self.atomic_migration: self.atomic = atomic(self.connection.alias) self.atomic.__enter__() return self def __exit__(self, exc_type, exc_value, traceback): if exc_type is None: for sql in self.deferred_sql: self.execute(sql) if self.atomic_migration: self.atomic.__exit__(exc_type, exc_value, traceback) # Core utility functions def execute(self, sql, params=()): """Execute the given SQL statement, with optional parameters.""" # Don't perform the transactional DDL check if SQL is being collected # as it's not going to be executed anyway. if ( not self.collect_sql and self.connection.in_atomic_block and not self.connection.features.can_rollback_ddl ): raise TransactionManagementError( "Executing DDL statements while in a transaction on databases " "that can't perform a rollback is prohibited." ) # Account for non-string statement objects. sql = str(sql) # Log the command we're running, then run it logger.debug( "%s; (params %r)", sql, params, extra={"params": params, "sql": sql} ) if self.collect_sql: ending = "" if sql.rstrip().endswith(";") else ";" if params is not None: self.collected_sql.append( (sql % tuple(map(self.quote_value, params))) + ending ) else: self.collected_sql.append(sql + ending) else: with self.connection.cursor() as cursor: cursor.execute(sql, params) def quote_name(self, name): return self.connection.ops.quote_name(name) def table_sql(self, model): """Take a model and return its table definition.""" # Add any unique_togethers (always deferred, as some fields might be # created afterward, like geometry fields with some backends). for field_names in model._meta.unique_together: fields = [model._meta.get_field(field) for field in field_names] self.deferred_sql.append(self._create_unique_sql(model, fields)) # Create column SQL, add FK deferreds if needed. column_sqls = [] params = [] for field in model._meta.local_fields: # SQL. definition, extra_params = self.column_sql(model, field) if definition is None: continue # Check constraints can go on the column SQL here. db_params = field.db_parameters(connection=self.connection) if db_params["check"]: definition += " " + self.sql_check_constraint % db_params # Autoincrement SQL (for backends with inline variant). col_type_suffix = field.db_type_suffix(connection=self.connection) if col_type_suffix: definition += " %s" % col_type_suffix params.extend(extra_params) # FK. if field.remote_field and field.db_constraint: to_table = field.remote_field.model._meta.db_table to_column = field.remote_field.model._meta.get_field( field.remote_field.field_name ).column if self.sql_create_inline_fk: definition += " " + self.sql_create_inline_fk % { "to_table": self.quote_name(to_table), "to_column": self.quote_name(to_column), } elif self.connection.features.supports_foreign_keys: self.deferred_sql.append( self._create_fk_sql( model, field, "_fk_%(to_table)s_%(to_column)s" ) ) # Add the SQL to our big list. column_sqls.append( "%s %s" % ( self.quote_name(field.column), definition, ) ) # Autoincrement SQL (for backends with post table definition # variant). if field.get_internal_type() in ( "AutoField", "BigAutoField", "SmallAutoField", ): autoinc_sql = self.connection.ops.autoinc_sql( model._meta.db_table, field.column ) if autoinc_sql: self.deferred_sql.extend(autoinc_sql) constraints = [ constraint.constraint_sql(model, self) for constraint in model._meta.constraints ] sql = self.sql_create_table % { "table": self.quote_name(model._meta.db_table), "definition": ", ".join( str(constraint) for constraint in (*column_sqls, *constraints) if constraint ), } if model._meta.db_tablespace: tablespace_sql = self.connection.ops.tablespace_sql( model._meta.db_tablespace ) if tablespace_sql: sql += " " + tablespace_sql return sql, params # Field <-> database mapping functions def _iter_column_sql( self, column_db_type, params, model, field, field_db_params, include_default ): yield column_db_type if collation := field_db_params.get("collation"): yield self._collate_sql(collation) if self.connection.features.supports_comments_inline and field.db_comment: yield self._comment_sql(field.db_comment) # Work out nullability. null = field.null # Include a default value, if requested. include_default = ( include_default and not self.skip_default(field) and # Don't include a default value if it's a nullable field and the # default cannot be dropped in the ALTER COLUMN statement (e.g. # MySQL longtext and longblob). not (null and self.skip_default_on_alter(field)) ) if include_default: default_value = self.effective_default(field) if default_value is not None: column_default = "DEFAULT " + self._column_default_sql(field) if self.connection.features.requires_literal_defaults: # Some databases can't take defaults as a parameter (Oracle). # If this is the case, the individual schema backend should # implement prepare_default(). yield column_default % self.prepare_default(default_value) else: yield column_default params.append(default_value) # Oracle treats the empty string ('') as null, so coerce the null # option whenever '' is a possible value. if ( field.empty_strings_allowed and not field.primary_key and self.connection.features.interprets_empty_strings_as_nulls ): null = True if not null: yield "NOT NULL" elif not self.connection.features.implied_column_null: yield "NULL" if field.primary_key: yield "PRIMARY KEY" elif field.unique: yield "UNIQUE" # Optionally add the tablespace if it's an implicitly indexed column. tablespace = field.db_tablespace or model._meta.db_tablespace if ( tablespace and self.connection.features.supports_tablespaces and field.unique ): yield self.connection.ops.tablespace_sql(tablespace, inline=True) def column_sql(self, model, field, include_default=False): """ Return the column definition for a field. The field must already have had set_attributes_from_name() called. """ # Get the column's type and use that as the basis of the SQL. field_db_params = field.db_parameters(connection=self.connection) column_db_type = field_db_params["type"] # Check for fields that aren't actually columns (e.g. M2M). if column_db_type is None: return None, None params = [] return ( " ".join( # This appends to the params being returned. self._iter_column_sql( column_db_type, params, model, field, field_db_params, include_default, ) ), params, ) def skip_default(self, field): """ Some backends don't accept default values for certain columns types (i.e. MySQL longtext and longblob). """ return False def skip_default_on_alter(self, field): """ Some backends don't accept default values for certain columns types (i.e. MySQL longtext and longblob) in the ALTER COLUMN statement. """ return False def prepare_default(self, value): """ Only used for backends which have requires_literal_defaults feature """ raise NotImplementedError( "subclasses of BaseDatabaseSchemaEditor for backends which have " "requires_literal_defaults must provide a prepare_default() method" ) def _column_default_sql(self, field): """ Return the SQL to use in a DEFAULT clause. The resulting string should contain a '%s' placeholder for a default value. """ return "%s" @staticmethod def _effective_default(field): # This method allows testing its logic without a connection. if field.has_default(): default = field.get_default() elif not field.null and field.blank and field.empty_strings_allowed: if field.get_internal_type() == "BinaryField": default = b"" else: default = "" elif getattr(field, "auto_now", False) or getattr(field, "auto_now_add", False): internal_type = field.get_internal_type() if internal_type == "DateTimeField": default = timezone.now() else: default = datetime.now() if internal_type == "DateField": default = default.date() elif internal_type == "TimeField": default = default.time() else: default = None return default def effective_default(self, field): """Return a field's effective database default value.""" return field.get_db_prep_save(self._effective_default(field), self.connection) def quote_value(self, value): """ Return a quoted version of the value so it's safe to use in an SQL string. This is not safe against injection from user code; it is intended only for use in making SQL scripts or preparing default values for particularly tricky backends (defaults are not user-defined, though, so this is safe). """ raise NotImplementedError() # Actions def create_model(self, model): """ Create a table and any accompanying indexes or unique constraints for the given `model`. """ sql, params = self.table_sql(model) # Prevent using [] as params, in the case a literal '%' is used in the # definition. self.execute(sql, params or None) if self.connection.features.supports_comments: # Add table comment. if model._meta.db_table_comment: self.alter_db_table_comment(model, None, model._meta.db_table_comment) # Add column comments. if not self.connection.features.supports_comments_inline: for field in model._meta.local_fields: if field.db_comment: field_db_params = field.db_parameters( connection=self.connection ) field_type = field_db_params["type"] self.execute( *self._alter_column_comment_sql( model, field, field_type, field.db_comment ) ) # Add any field index and index_together's (deferred as SQLite # _remake_table needs it). self.deferred_sql.extend(self._model_indexes_sql(model)) # Make M2M tables for field in model._meta.local_many_to_many: if field.remote_field.through._meta.auto_created: self.create_model(field.remote_field.through) def delete_model(self, model): """Delete a model from the database.""" # Handle auto-created intermediary models for field in model._meta.local_many_to_many: if field.remote_field.through._meta.auto_created: self.delete_model(field.remote_field.through) # Delete the table self.execute( self.sql_delete_table % { "table": self.quote_name(model._meta.db_table), } ) # Remove all deferred statements referencing the deleted table. for sql in list(self.deferred_sql): if isinstance(sql, Statement) and sql.references_table( model._meta.db_table ): self.deferred_sql.remove(sql) def add_index(self, model, index): """Add an index on a model.""" if ( index.contains_expressions and not self.connection.features.supports_expression_indexes ): return None # Index.create_sql returns interpolated SQL which makes params=None a # necessity to avoid escaping attempts on execution. self.execute(index.create_sql(model, self), params=None) def remove_index(self, model, index): """Remove an index from a model.""" if ( index.contains_expressions and not self.connection.features.supports_expression_indexes ): return None self.execute(index.remove_sql(model, self)) def rename_index(self, model, old_index, new_index): if self.connection.features.can_rename_index: self.execute( self._rename_index_sql(model, old_index.name, new_index.name), params=None, ) else: self.remove_index(model, old_index) self.add_index(model, new_index) def add_constraint(self, model, constraint): """Add a constraint to a model.""" sql = constraint.create_sql(model, self) if sql: # Constraint.create_sql returns interpolated SQL which makes # params=None a necessity to avoid escaping attempts on execution. self.execute(sql, params=None) def remove_constraint(self, model, constraint): """Remove a constraint from a model.""" sql = constraint.remove_sql(model, self) if sql: self.execute(sql) def alter_unique_together(self, model, old_unique_together, new_unique_together): """ Deal with a model changing its unique_together. The input unique_togethers must be doubly-nested, not the single-nested ["foo", "bar"] format. """ olds = {tuple(fields) for fields in old_unique_together} news = {tuple(fields) for fields in new_unique_together} # Deleted uniques for fields in olds.difference(news): self._delete_composed_index( model, fields, {"unique": True, "primary_key": False}, self.sql_delete_unique, ) # Created uniques for field_names in news.difference(olds): fields = [model._meta.get_field(field) for field in field_names] self.execute(self._create_unique_sql(model, fields)) def alter_index_together(self, model, old_index_together, new_index_together): """ Deal with a model changing its index_together. The input index_togethers must be doubly-nested, not the single-nested ["foo", "bar"] format. """ olds = {tuple(fields) for fields in old_index_together} news = {tuple(fields) for fields in new_index_together} # Deleted indexes for fields in olds.difference(news): self._delete_composed_index( model, fields, {"index": True, "unique": False}, self.sql_delete_index, ) # Created indexes for field_names in news.difference(olds): fields = [model._meta.get_field(field) for field in field_names] self.execute(self._create_index_sql(model, fields=fields, suffix="_idx")) def _delete_composed_index(self, model, fields, constraint_kwargs, sql): meta_constraint_names = { constraint.name for constraint in model._meta.constraints } meta_index_names = {constraint.name for constraint in model._meta.indexes} columns = [model._meta.get_field(field).column for field in fields] constraint_names = self._constraint_names( model, columns, exclude=meta_constraint_names | meta_index_names, **constraint_kwargs, ) if ( constraint_kwargs.get("unique") is True and constraint_names and self.connection.features.allows_multiple_constraints_on_same_fields ): # Constraint matching the unique_together name. default_name = str( self._unique_constraint_name(model._meta.db_table, columns, quote=False) ) if default_name in constraint_names: constraint_names = [default_name] if len(constraint_names) != 1: raise ValueError( "Found wrong number (%s) of constraints for %s(%s)" % ( len(constraint_names), model._meta.db_table, ", ".join(columns), ) ) self.execute(self._delete_constraint_sql(sql, model, constraint_names[0])) def alter_db_table(self, model, old_db_table, new_db_table): """Rename the table a model points to.""" if old_db_table == new_db_table or ( self.connection.features.ignores_table_name_case and old_db_table.lower() == new_db_table.lower() ): return self.execute( self.sql_rename_table % { "old_table": self.quote_name(old_db_table), "new_table": self.quote_name(new_db_table), } ) # Rename all references to the old table name. for sql in self.deferred_sql: if isinstance(sql, Statement): sql.rename_table_references(old_db_table, new_db_table) def alter_db_table_comment(self, model, old_db_table_comment, new_db_table_comment): if self.sql_alter_table_comment and self.connection.features.supports_comments: self.execute( self.sql_alter_table_comment % { "table": self.quote_name(model._meta.db_table), "comment": self.quote_value(new_db_table_comment or ""), } ) def alter_db_tablespace(self, model, old_db_tablespace, new_db_tablespace): """Move a model's table between tablespaces.""" self.execute( self.sql_retablespace_table % { "table": self.quote_name(model._meta.db_table), "old_tablespace": self.quote_name(old_db_tablespace), "new_tablespace": self.quote_name(new_db_tablespace), } ) def add_field(self, model, field): """ Create a field on a model. Usually involves adding a column, but may involve adding a table instead (for M2M fields). """ # Special-case implicit M2M tables if field.many_to_many and field.remote_field.through._meta.auto_created: return self.create_model(field.remote_field.through) # Get the column's definition definition, params = self.column_sql(model, field, include_default=True) # It might not actually have a column behind it if definition is None: return if col_type_suffix := field.db_type_suffix(connection=self.connection): definition += f" {col_type_suffix}" # Check constraints can go on the column SQL here db_params = field.db_parameters(connection=self.connection) if db_params["check"]: definition += " " + self.sql_check_constraint % db_params if ( field.remote_field and self.connection.features.supports_foreign_keys and field.db_constraint ): constraint_suffix = "_fk_%(to_table)s_%(to_column)s" # Add FK constraint inline, if supported. if self.sql_create_column_inline_fk: to_table = field.remote_field.model._meta.db_table to_column = field.remote_field.model._meta.get_field( field.remote_field.field_name ).column namespace, _ = split_identifier(model._meta.db_table) definition += " " + self.sql_create_column_inline_fk % { "name": self._fk_constraint_name(model, field, constraint_suffix), "namespace": "%s." % self.quote_name(namespace) if namespace else "", "column": self.quote_name(field.column), "to_table": self.quote_name(to_table), "to_column": self.quote_name(to_column), "deferrable": self.connection.ops.deferrable_sql(), } # Otherwise, add FK constraints later. else: self.deferred_sql.append( self._create_fk_sql(model, field, constraint_suffix) ) # Build the SQL and run it sql = self.sql_create_column % { "table": self.quote_name(model._meta.db_table), "column": self.quote_name(field.column), "definition": definition, } self.execute(sql, params) # Drop the default if we need to # (Django usually does not use in-database defaults) if ( not self.skip_default_on_alter(field) and self.effective_default(field) is not None ): changes_sql, params = self._alter_column_default_sql( model, None, field, drop=True ) sql = self.sql_alter_column % { "table": self.quote_name(model._meta.db_table), "changes": changes_sql, } self.execute(sql, params) # Add field comment, if required. if ( field.db_comment and self.connection.features.supports_comments and not self.connection.features.supports_comments_inline ): field_type = db_params["type"] self.execute( *self._alter_column_comment_sql( model, field, field_type, field.db_comment ) ) # Add an index, if required self.deferred_sql.extend(self._field_indexes_sql(model, field)) # Reset connection if required if self.connection.features.connection_persists_old_columns: self.connection.close() def remove_field(self, model, field): """ Remove a field from a model. Usually involves deleting a column, but for M2Ms may involve deleting a table. """ # Special-case implicit M2M tables if field.many_to_many and field.remote_field.through._meta.auto_created: return self.delete_model(field.remote_field.through) # It might not actually have a column behind it if field.db_parameters(connection=self.connection)["type"] is None: return # Drop any FK constraints, MySQL requires explicit deletion if field.remote_field: fk_names = self._constraint_names(model, [field.column], foreign_key=True) for fk_name in fk_names: self.execute(self._delete_fk_sql(model, fk_name)) # Delete the column sql = self.sql_delete_column % { "table": self.quote_name(model._meta.db_table), "column": self.quote_name(field.column), } self.execute(sql) # Reset connection if required if self.connection.features.connection_persists_old_columns: self.connection.close() # Remove all deferred statements referencing the deleted column. for sql in list(self.deferred_sql): if isinstance(sql, Statement) and sql.references_column( model._meta.db_table, field.column ): self.deferred_sql.remove(sql) def alter_field(self, model, old_field, new_field, strict=False): """ Allow a field's type, uniqueness, nullability, default, column, constraints, etc. to be modified. `old_field` is required to compute the necessary changes. If `strict` is True, raise errors if the old column does not match `old_field` precisely. """ if not self._field_should_be_altered(old_field, new_field): return # Ensure this field is even column-based old_db_params = old_field.db_parameters(connection=self.connection) old_type = old_db_params["type"] new_db_params = new_field.db_parameters(connection=self.connection) new_type = new_db_params["type"] if (old_type is None and old_field.remote_field is None) or ( new_type is None and new_field.remote_field is None ): raise ValueError( "Cannot alter field %s into %s - they do not properly define " "db_type (are you using a badly-written custom field?)" % (old_field, new_field), ) elif ( old_type is None and new_type is None and ( old_field.remote_field.through and new_field.remote_field.through and old_field.remote_field.through._meta.auto_created and new_field.remote_field.through._meta.auto_created ) ): return self._alter_many_to_many(model, old_field, new_field, strict) elif ( old_type is None and new_type is None and ( old_field.remote_field.through and new_field.remote_field.through and not old_field.remote_field.through._meta.auto_created and not new_field.remote_field.through._meta.auto_created ) ): # Both sides have through models; this is a no-op. return elif old_type is None or new_type is None: raise ValueError( "Cannot alter field %s into %s - they are not compatible types " "(you cannot alter to or from M2M fields, or add or remove " "through= on M2M fields)" % (old_field, new_field) ) self._alter_field( model, old_field, new_field, old_type, new_type, old_db_params, new_db_params, strict, ) def _alter_field( self, model, old_field, new_field, old_type, new_type, old_db_params, new_db_params, strict=False, ): """Perform a "physical" (non-ManyToMany) field update.""" # Drop any FK constraints, we'll remake them later fks_dropped = set() if ( self.connection.features.supports_foreign_keys and old_field.remote_field and old_field.db_constraint and self._field_should_be_altered( old_field, new_field, ignore={"db_comment"}, ) ): fk_names = self._constraint_names( model, [old_field.column], foreign_key=True ) if strict and len(fk_names) != 1: raise ValueError( "Found wrong number (%s) of foreign key constraints for %s.%s" % ( len(fk_names), model._meta.db_table, old_field.column, ) ) for fk_name in fk_names: fks_dropped.add((old_field.column,)) self.execute(self._delete_fk_sql(model, fk_name)) # Has unique been removed? if old_field.unique and ( not new_field.unique or self._field_became_primary_key(old_field, new_field) ): # Find the unique constraint for this field meta_constraint_names = { constraint.name for constraint in model._meta.constraints } constraint_names = self._constraint_names( model, [old_field.column], unique=True, primary_key=False, exclude=meta_constraint_names, ) if strict and len(constraint_names) != 1: raise ValueError( "Found wrong number (%s) of unique constraints for %s.%s" % ( len(constraint_names), model._meta.db_table, old_field.column, ) ) for constraint_name in constraint_names: self.execute(self._delete_unique_sql(model, constraint_name)) # Drop incoming FK constraints if the field is a primary key or unique, # which might be a to_field target, and things are going to change. old_collation = old_db_params.get("collation") new_collation = new_db_params.get("collation") drop_foreign_keys = ( self.connection.features.supports_foreign_keys and ( (old_field.primary_key and new_field.primary_key) or (old_field.unique and new_field.unique) ) and ((old_type != new_type) or (old_collation != new_collation)) ) if drop_foreign_keys: # '_meta.related_field' also contains M2M reverse fields, these # will be filtered out for _old_rel, new_rel in _related_non_m2m_objects(old_field, new_field): rel_fk_names = self._constraint_names( new_rel.related_model, [new_rel.field.column], foreign_key=True ) for fk_name in rel_fk_names: self.execute(self._delete_fk_sql(new_rel.related_model, fk_name)) # Removed an index? (no strict check, as multiple indexes are possible) # Remove indexes if db_index switched to False or a unique constraint # will now be used in lieu of an index. The following lines from the # truth table show all True cases; the rest are False: # # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique # ------------------------------------------------------------------------------ # True | False | False | False # True | False | False | True # True | False | True | True if ( old_field.db_index and not old_field.unique and (not new_field.db_index or new_field.unique) ): # Find the index for this field meta_index_names = {index.name for index in model._meta.indexes} # Retrieve only BTREE indexes since this is what's created with # db_index=True. index_names = self._constraint_names( model, [old_field.column], index=True, type_=Index.suffix, exclude=meta_index_names, ) for index_name in index_names: # The only way to check if an index was created with # db_index=True or with Index(['field'], name='foo') # is to look at its name (refs #28053). self.execute(self._delete_index_sql(model, index_name)) # Change check constraints? if old_db_params["check"] != new_db_params["check"] and old_db_params["check"]: meta_constraint_names = { constraint.name for constraint in model._meta.constraints } constraint_names = self._constraint_names( model, [old_field.column], check=True, exclude=meta_constraint_names, ) if strict and len(constraint_names) != 1: raise ValueError( "Found wrong number (%s) of check constraints for %s.%s" % ( len(constraint_names), model._meta.db_table, old_field.column, ) ) for constraint_name in constraint_names: self.execute(self._delete_check_sql(model, constraint_name)) # Have they renamed the column? if old_field.column != new_field.column: self.execute( self._rename_field_sql( model._meta.db_table, old_field, new_field, new_type ) ) # Rename all references to the renamed column. for sql in self.deferred_sql: if isinstance(sql, Statement): sql.rename_column_references( model._meta.db_table, old_field.column, new_field.column ) # Next, start accumulating actions to do actions = [] null_actions = [] post_actions = [] # Type suffix change? (e.g. auto increment). old_type_suffix = old_field.db_type_suffix(connection=self.connection) new_type_suffix = new_field.db_type_suffix(connection=self.connection) # Type, collation, or comment change? if ( old_type != new_type or old_type_suffix != new_type_suffix or old_collation != new_collation or ( self.connection.features.supports_comments and old_field.db_comment != new_field.db_comment ) ): fragment, other_actions = self._alter_column_type_sql( model, old_field, new_field, new_type, old_collation, new_collation ) actions.append(fragment) post_actions.extend(other_actions) # When changing a column NULL constraint to NOT NULL with a given # default value, we need to perform 4 steps: # 1. Add a default for new incoming writes # 2. Update existing NULL rows with new default # 3. Replace NULL constraint with NOT NULL # 4. Drop the default again. # Default change? needs_database_default = False if old_field.null and not new_field.null: old_default = self.effective_default(old_field) new_default = self.effective_default(new_field) if ( not self.skip_default_on_alter(new_field) and old_default != new_default and new_default is not None ): needs_database_default = True actions.append( self._alter_column_default_sql(model, old_field, new_field) ) # Nullability change? if old_field.null != new_field.null: fragment = self._alter_column_null_sql(model, old_field, new_field) if fragment: null_actions.append(fragment) # Only if we have a default and there is a change from NULL to NOT NULL four_way_default_alteration = new_field.has_default() and ( old_field.null and not new_field.null ) if actions or null_actions: if not four_way_default_alteration: # If we don't have to do a 4-way default alteration we can # directly run a (NOT) NULL alteration actions += null_actions # Combine actions together if we can (e.g. postgres) if self.connection.features.supports_combined_alters and actions: sql, params = tuple(zip(*actions)) actions = [(", ".join(sql), sum(params, []))] # Apply those actions for sql, params in actions: self.execute( self.sql_alter_column % { "table": self.quote_name(model._meta.db_table), "changes": sql, }, params, ) if four_way_default_alteration: # Update existing rows with default value self.execute( self.sql_update_with_default % { "table": self.quote_name(model._meta.db_table), "column": self.quote_name(new_field.column), "default": "%s", }, [new_default], ) # Since we didn't run a NOT NULL change before we need to do it # now for sql, params in null_actions: self.execute( self.sql_alter_column % { "table": self.quote_name(model._meta.db_table), "changes": sql, }, params, ) if post_actions: for sql, params in post_actions: self.execute(sql, params) # If primary_key changed to False, delete the primary key constraint. if old_field.primary_key and not new_field.primary_key: self._delete_primary_key(model, strict) # Added a unique? if self._unique_should_be_added(old_field, new_field): self.execute(self._create_unique_sql(model, [new_field])) # Added an index? Add an index if db_index switched to True or a unique # constraint will no longer be used in lieu of an index. The following # lines from the truth table show all True cases; the rest are False: # # old_field.db_index | old_field.unique | new_field.db_index | new_field.unique # ------------------------------------------------------------------------------ # False | False | True | False # False | True | True | False # True | True | True | False if ( (not old_field.db_index or old_field.unique) and new_field.db_index and not new_field.unique ): self.execute(self._create_index_sql(model, fields=[new_field])) # Type alteration on primary key? Then we need to alter the column # referring to us. rels_to_update = [] if drop_foreign_keys: rels_to_update.extend(_related_non_m2m_objects(old_field, new_field)) # Changed to become primary key? if self._field_became_primary_key(old_field, new_field): # Make the new one self.execute(self._create_primary_key_sql(model, new_field)) # Update all referencing columns rels_to_update.extend(_related_non_m2m_objects(old_field, new_field)) # Handle our type alters on the other end of rels from the PK stuff above for old_rel, new_rel in rels_to_update: rel_db_params = new_rel.field.db_parameters(connection=self.connection) rel_type = rel_db_params["type"] rel_collation = rel_db_params.get("collation") old_rel_db_params = old_rel.field.db_parameters(connection=self.connection) old_rel_collation = old_rel_db_params.get("collation") fragment, other_actions = self._alter_column_type_sql( new_rel.related_model, old_rel.field, new_rel.field, rel_type, old_rel_collation, rel_collation, ) self.execute( self.sql_alter_column % { "table": self.quote_name(new_rel.related_model._meta.db_table), "changes": fragment[0], }, fragment[1], ) for sql, params in other_actions: self.execute(sql, params) # Does it have a foreign key? if ( self.connection.features.supports_foreign_keys and new_field.remote_field and ( fks_dropped or not old_field.remote_field or not old_field.db_constraint ) and new_field.db_constraint ): self.execute( self._create_fk_sql(model, new_field, "_fk_%(to_table)s_%(to_column)s") ) # Rebuild FKs that pointed to us if we previously had to drop them if drop_foreign_keys: for _, rel in rels_to_update: if rel.field.db_constraint: self.execute( self._create_fk_sql(rel.related_model, rel.field, "_fk") ) # Does it have check constraints we need to add? if old_db_params["check"] != new_db_params["check"] and new_db_params["check"]: constraint_name = self._create_index_name( model._meta.db_table, [new_field.column], suffix="_check" ) self.execute( self._create_check_sql(model, constraint_name, new_db_params["check"]) ) # Drop the default if we need to # (Django usually does not use in-database defaults) if needs_database_default: changes_sql, params = self._alter_column_default_sql( model, old_field, new_field, drop=True ) sql = self.sql_alter_column % { "table": self.quote_name(model._meta.db_table), "changes": changes_sql, } self.execute(sql, params) # Reset connection if required if self.connection.features.connection_persists_old_columns: self.connection.close() def _alter_column_null_sql(self, model, old_field, new_field): """ Hook to specialize column null alteration. Return a (sql, params) fragment to set a column to null or non-null as required by new_field, or None if no changes are required. """ if ( self.connection.features.interprets_empty_strings_as_nulls and new_field.empty_strings_allowed ): # The field is nullable in the database anyway, leave it alone. return else: new_db_params = new_field.db_parameters(connection=self.connection) sql = ( self.sql_alter_column_null if new_field.null else self.sql_alter_column_not_null ) return ( sql % { "column": self.quote_name(new_field.column), "type": new_db_params["type"], }, [], ) def _alter_column_default_sql(self, model, old_field, new_field, drop=False): """ Hook to specialize column default alteration. Return a (sql, params) fragment to add or drop (depending on the drop argument) a default to new_field's column. """ new_default = self.effective_default(new_field) default = self._column_default_sql(new_field) params = [new_default] if drop: params = [] elif self.connection.features.requires_literal_defaults: # Some databases (Oracle) can't take defaults as a parameter # If this is the case, the SchemaEditor for that database should # implement prepare_default(). default = self.prepare_default(new_default) params = [] new_db_params = new_field.db_parameters(connection=self.connection) if drop: if new_field.null: sql = self.sql_alter_column_no_default_null else: sql = self.sql_alter_column_no_default else: sql = self.sql_alter_column_default return ( sql % { "column": self.quote_name(new_field.column), "type": new_db_params["type"], "default": default, }, params, ) def _alter_column_type_sql( self, model, old_field, new_field, new_type, old_collation, new_collation ): """ Hook to specialize column type alteration for different backends, for cases when a creation type is different to an alteration type (e.g. SERIAL in PostgreSQL, PostGIS fields). Return a two-tuple of: an SQL fragment of (sql, params) to insert into an ALTER TABLE statement and a list of extra (sql, params) tuples to run once the field is altered. """ other_actions = [] if collate_sql := self._collate_sql( new_collation, old_collation, model._meta.db_table ): collate_sql = f" {collate_sql}" else: collate_sql = "" # Comment change? comment_sql = "" if self.connection.features.supports_comments and not new_field.many_to_many: if old_field.db_comment != new_field.db_comment: # PostgreSQL and Oracle can't execute 'ALTER COLUMN ...' and # 'COMMENT ON ...' at the same time. sql, params = self._alter_column_comment_sql( model, new_field, new_type, new_field.db_comment ) if sql: other_actions.append((sql, params)) if new_field.db_comment: comment_sql = self._comment_sql(new_field.db_comment) return ( ( self.sql_alter_column_type % { "column": self.quote_name(new_field.column), "type": new_type, "collation": collate_sql, "comment": comment_sql, }, [], ), other_actions, ) def _alter_column_comment_sql(self, model, new_field, new_type, new_db_comment): return ( self.sql_alter_column_comment % { "table": self.quote_name(model._meta.db_table), "column": self.quote_name(new_field.column), "comment": self._comment_sql(new_db_comment), }, [], ) def _comment_sql(self, comment): return self.quote_value(comment or "") def _alter_many_to_many(self, model, old_field, new_field, strict): """Alter M2Ms to repoint their to= endpoints.""" # Rename the through table if ( old_field.remote_field.through._meta.db_table != new_field.remote_field.through._meta.db_table ): self.alter_db_table( old_field.remote_field.through, old_field.remote_field.through._meta.db_table, new_field.remote_field.through._meta.db_table, ) # Repoint the FK to the other side self.alter_field( new_field.remote_field.through, # The field that points to the target model is needed, so we can # tell alter_field to change it - this is m2m_reverse_field_name() # (as opposed to m2m_field_name(), which points to our model). old_field.remote_field.through._meta.get_field( old_field.m2m_reverse_field_name() ), new_field.remote_field.through._meta.get_field( new_field.m2m_reverse_field_name() ), ) self.alter_field( new_field.remote_field.through, # for self-referential models we need to alter field from the other end too old_field.remote_field.through._meta.get_field(old_field.m2m_field_name()), new_field.remote_field.through._meta.get_field(new_field.m2m_field_name()), ) def _create_index_name(self, table_name, column_names, suffix=""): """ Generate a unique name for an index/unique constraint. The name is divided into 3 parts: the table name, the column names, and a unique digest and suffix. """ _, table_name = split_identifier(table_name) hash_suffix_part = "%s%s" % ( names_digest(table_name, *column_names, length=8), suffix, ) max_length = self.connection.ops.max_name_length() or 200 # If everything fits into max_length, use that name. index_name = "%s_%s_%s" % (table_name, "_".join(column_names), hash_suffix_part) if len(index_name) <= max_length: return index_name # Shorten a long suffix. if len(hash_suffix_part) > max_length / 3: hash_suffix_part = hash_suffix_part[: max_length // 3] other_length = (max_length - len(hash_suffix_part)) // 2 - 1 index_name = "%s_%s_%s" % ( table_name[:other_length], "_".join(column_names)[:other_length], hash_suffix_part, ) # Prepend D if needed to prevent the name from starting with an # underscore or a number (not permitted on Oracle). if index_name[0] == "_" or index_name[0].isdigit(): index_name = "D%s" % index_name[:-1] return index_name def _get_index_tablespace_sql(self, model, fields, db_tablespace=None): if db_tablespace is None: if len(fields) == 1 and fields[0].db_tablespace: db_tablespace = fields[0].db_tablespace elif settings.DEFAULT_INDEX_TABLESPACE: db_tablespace = settings.DEFAULT_INDEX_TABLESPACE elif model._meta.db_tablespace: db_tablespace = model._meta.db_tablespace if db_tablespace is not None: return " " + self.connection.ops.tablespace_sql(db_tablespace) return "" def _index_condition_sql(self, condition): if condition: return " WHERE " + condition return "" def _index_include_sql(self, model, columns): if not columns or not self.connection.features.supports_covering_indexes: return "" return Statement( " INCLUDE (%(columns)s)", columns=Columns(model._meta.db_table, columns, self.quote_name), ) def _create_index_sql( self, model, *, fields=None, name=None, suffix="", using="", db_tablespace=None, col_suffixes=(), sql=None, opclasses=(), condition=None, include=None, expressions=None, ): """ Return the SQL statement to create the index for one or several fields or expressions. `sql` can be specified if the syntax differs from the standard (GIS indexes, ...). """ fields = fields or [] expressions = expressions or [] compiler = Query(model, alias_cols=False).get_compiler( connection=self.connection, ) tablespace_sql = self._get_index_tablespace_sql( model, fields, db_tablespace=db_tablespace ) columns = [field.column for field in fields] sql_create_index = sql or self.sql_create_index table = model._meta.db_table def create_index_name(*args, **kwargs): nonlocal name if name is None: name = self._create_index_name(*args, **kwargs) return self.quote_name(name) return Statement( sql_create_index, table=Table(table, self.quote_name), name=IndexName(table, columns, suffix, create_index_name), using=using, columns=( self._index_columns(table, columns, col_suffixes, opclasses) if columns else Expressions(table, expressions, compiler, self.quote_value) ), extra=tablespace_sql, condition=self._index_condition_sql(condition), include=self._index_include_sql(model, include), ) def _delete_index_sql(self, model, name, sql=None): return Statement( sql or self.sql_delete_index, table=Table(model._meta.db_table, self.quote_name), name=self.quote_name(name), ) def _rename_index_sql(self, model, old_name, new_name): return Statement( self.sql_rename_index, table=Table(model._meta.db_table, self.quote_name), old_name=self.quote_name(old_name), new_name=self.quote_name(new_name), ) def _index_columns(self, table, columns, col_suffixes, opclasses): return Columns(table, columns, self.quote_name, col_suffixes=col_suffixes) def _model_indexes_sql(self, model): """ Return a list of all index SQL statements (field indexes, index_together, Meta.indexes) for the specified model. """ if not model._meta.managed or model._meta.proxy or model._meta.swapped: return [] output = [] for field in model._meta.local_fields: output.extend(self._field_indexes_sql(model, field)) for field_names in model._meta.index_together: fields = [model._meta.get_field(field) for field in field_names] output.append(self._create_index_sql(model, fields=fields, suffix="_idx")) for index in model._meta.indexes: if ( not index.contains_expressions or self.connection.features.supports_expression_indexes ): output.append(index.create_sql(model, self)) return output def _field_indexes_sql(self, model, field): """ Return a list of all index SQL statements for the specified field. """ output = [] if self._field_should_be_indexed(model, field): output.append(self._create_index_sql(model, fields=[field])) return output def _field_should_be_altered(self, old_field, new_field, ignore=None): ignore = ignore or set() _, old_path, old_args, old_kwargs = old_field.deconstruct() _, new_path, new_args, new_kwargs = new_field.deconstruct() # Don't alter when: # - changing only a field name # - changing an attribute that doesn't affect the schema # - changing an attribute in the provided set of ignored attributes # - adding only a db_column and the column name is not changed for attr in ignore.union(old_field.non_db_attrs): old_kwargs.pop(attr, None) for attr in ignore.union(new_field.non_db_attrs): new_kwargs.pop(attr, None) return self.quote_name(old_field.column) != self.quote_name( new_field.column ) or (old_path, old_args, old_kwargs) != (new_path, new_args, new_kwargs) def _field_should_be_indexed(self, model, field): return field.db_index and not field.unique def _field_became_primary_key(self, old_field, new_field): return not old_field.primary_key and new_field.primary_key def _unique_should_be_added(self, old_field, new_field): return ( not new_field.primary_key and new_field.unique and (not old_field.unique or old_field.primary_key) ) def _rename_field_sql(self, table, old_field, new_field, new_type): return self.sql_rename_column % { "table": self.quote_name(table), "old_column": self.quote_name(old_field.column), "new_column": self.quote_name(new_field.column), "type": new_type, } def _create_fk_sql(self, model, field, suffix): table = Table(model._meta.db_table, self.quote_name) name = self._fk_constraint_name(model, field, suffix) column = Columns(model._meta.db_table, [field.column], self.quote_name) to_table = Table(field.target_field.model._meta.db_table, self.quote_name) to_column = Columns( field.target_field.model._meta.db_table, [field.target_field.column], self.quote_name, ) deferrable = self.connection.ops.deferrable_sql() return Statement( self.sql_create_fk, table=table, name=name, column=column, to_table=to_table, to_column=to_column, deferrable=deferrable, ) def _fk_constraint_name(self, model, field, suffix): def create_fk_name(*args, **kwargs): return self.quote_name(self._create_index_name(*args, **kwargs)) return ForeignKeyName( model._meta.db_table, [field.column], split_identifier(field.target_field.model._meta.db_table)[1], [field.target_field.column], suffix, create_fk_name, ) def _delete_fk_sql(self, model, name): return self._delete_constraint_sql(self.sql_delete_fk, model, name) def _deferrable_constraint_sql(self, deferrable): if deferrable is None: return "" if deferrable == Deferrable.DEFERRED: return " DEFERRABLE INITIALLY DEFERRED" if deferrable == Deferrable.IMMEDIATE: return " DEFERRABLE INITIALLY IMMEDIATE" def _unique_sql( self, model, fields, name, condition=None, deferrable=None, include=None, opclasses=None, expressions=None, ): if ( deferrable and not self.connection.features.supports_deferrable_unique_constraints ): return None if condition or include or opclasses or expressions: # Databases support conditional, covering, and functional unique # constraints via a unique index. sql = self._create_unique_sql( model, fields, name=name, condition=condition, include=include, opclasses=opclasses, expressions=expressions, ) if sql: self.deferred_sql.append(sql) return None constraint = self.sql_unique_constraint % { "columns": ", ".join([self.quote_name(field.column) for field in fields]), "deferrable": self._deferrable_constraint_sql(deferrable), } return self.sql_constraint % { "name": self.quote_name(name), "constraint": constraint, } def _create_unique_sql( self, model, fields, name=None, condition=None, deferrable=None, include=None, opclasses=None, expressions=None, ): if ( ( deferrable and not self.connection.features.supports_deferrable_unique_constraints ) or (condition and not self.connection.features.supports_partial_indexes) or (include and not self.connection.features.supports_covering_indexes) or ( expressions and not self.connection.features.supports_expression_indexes ) ): return None compiler = Query(model, alias_cols=False).get_compiler( connection=self.connection ) table = model._meta.db_table columns = [field.column for field in fields] if name is None: name = self._unique_constraint_name(table, columns, quote=True) else: name = self.quote_name(name) if condition or include or opclasses or expressions: sql = self.sql_create_unique_index else: sql = self.sql_create_unique if columns: columns = self._index_columns( table, columns, col_suffixes=(), opclasses=opclasses ) else: columns = Expressions(table, expressions, compiler, self.quote_value) return Statement( sql, table=Table(table, self.quote_name), name=name, columns=columns, condition=self._index_condition_sql(condition), deferrable=self._deferrable_constraint_sql(deferrable), include=self._index_include_sql(model, include), ) def _unique_constraint_name(self, table, columns, quote=True): if quote: def create_unique_name(*args, **kwargs): return self.quote_name(self._create_index_name(*args, **kwargs)) else: create_unique_name = self._create_index_name return IndexName(table, columns, "_uniq", create_unique_name) def _delete_unique_sql( self, model, name, condition=None, deferrable=None, include=None, opclasses=None, expressions=None, ): if ( ( deferrable and not self.connection.features.supports_deferrable_unique_constraints ) or (condition and not self.connection.features.supports_partial_indexes) or (include and not self.connection.features.supports_covering_indexes) or ( expressions and not self.connection.features.supports_expression_indexes ) ): return None if condition or include or opclasses or expressions: sql = self.sql_delete_index else: sql = self.sql_delete_unique return self._delete_constraint_sql(sql, model, name) def _check_sql(self, name, check): return self.sql_constraint % { "name": self.quote_name(name), "constraint": self.sql_check_constraint % {"check": check}, } def _create_check_sql(self, model, name, check): return Statement( self.sql_create_check, table=Table(model._meta.db_table, self.quote_name), name=self.quote_name(name), check=check, ) def _delete_check_sql(self, model, name): if not self.connection.features.supports_table_check_constraints: return None return self._delete_constraint_sql(self.sql_delete_check, model, name) def _delete_constraint_sql(self, template, model, name): return Statement( template, table=Table(model._meta.db_table, self.quote_name), name=self.quote_name(name), ) def _constraint_names( self, model, column_names=None, unique=None, primary_key=None, index=None, foreign_key=None, check=None, type_=None, exclude=None, ): """Return all constraint names matching the columns and conditions.""" if column_names is not None: column_names = [ self.connection.introspection.identifier_converter( truncate_name(name, self.connection.ops.max_name_length()) ) if self.connection.features.truncates_names else self.connection.introspection.identifier_converter(name) for name in column_names ] with self.connection.cursor() as cursor: constraints = self.connection.introspection.get_constraints( cursor, model._meta.db_table ) result = [] for name, infodict in constraints.items(): if column_names is None or column_names == infodict["columns"]: if unique is not None and infodict["unique"] != unique: continue if primary_key is not None and infodict["primary_key"] != primary_key: continue if index is not None and infodict["index"] != index: continue if check is not None and infodict["check"] != check: continue if foreign_key is not None and not infodict["foreign_key"]: continue if type_ is not None and infodict["type"] != type_: continue if not exclude or name not in exclude: result.append(name) return result def _delete_primary_key(self, model, strict=False): constraint_names = self._constraint_names(model, primary_key=True) if strict and len(constraint_names) != 1: raise ValueError( "Found wrong number (%s) of PK constraints for %s" % ( len(constraint_names), model._meta.db_table, ) ) for constraint_name in constraint_names: self.execute(self._delete_primary_key_sql(model, constraint_name)) def _create_primary_key_sql(self, model, field): return Statement( self.sql_create_pk, table=Table(model._meta.db_table, self.quote_name), name=self.quote_name( self._create_index_name( model._meta.db_table, [field.column], suffix="_pk" ) ), columns=Columns(model._meta.db_table, [field.column], self.quote_name), ) def _delete_primary_key_sql(self, model, name): return self._delete_constraint_sql(self.sql_delete_pk, model, name) def _collate_sql(self, collation, old_collation=None, table_name=None): return "COLLATE " + self.quote_name(collation) if collation else "" def remove_procedure(self, procedure_name, param_types=()): sql = self.sql_delete_procedure % { "procedure": self.quote_name(procedure_name), "param_types": ",".join(param_types), } self.execute(sql) PK �"�Z7 �թ � client.pynu �[��� import os import subprocess class BaseDatabaseClient: """Encapsulate backend-specific methods for opening a client shell.""" # This should be a string representing the name of the executable # (e.g., "psql"). Subclasses must override this. executable_name = None def __init__(self, connection): # connection is an instance of BaseDatabaseWrapper. self.connection = connection @classmethod def settings_to_cmd_args_env(cls, settings_dict, parameters): raise NotImplementedError( "subclasses of BaseDatabaseClient must provide a " "settings_to_cmd_args_env() method or override a runshell()." ) def runshell(self, parameters): args, env = self.settings_to_cmd_args_env( self.connection.settings_dict, parameters ) env = {**os.environ, **env} if env else None subprocess.run(args, env=env, check=True) PK �"�Z����+ + validation.pynu �[��� class BaseDatabaseValidation: """Encapsulate backend-specific validation.""" def __init__(self, connection): self.connection = connection def check(self, **kwargs): return [] def check_field(self, field, **kwargs): errors = [] # Backends may implement a check_field_type() method. if ( hasattr(self, "check_field_type") and # Ignore any related fields. not getattr(field, "remote_field", None) ): # Ignore fields with unsupported features. db_supports_all_required_features = all( getattr(self.connection.features, feature, False) for feature in field.model._meta.required_db_features ) if db_supports_all_required_features: field_type = field.db_type(self.connection) # Ignore non-concrete fields. if field_type is not None: errors.extend(self.check_field_type(field, field_type)) return errors PK �"�ZJf7�� � introspection.pynu �[��� from collections import namedtuple # Structure returned by DatabaseIntrospection.get_table_list() TableInfo = namedtuple("TableInfo", ["name", "type"]) # Structure returned by the DB-API cursor.description interface (PEP 249) FieldInfo = namedtuple( "FieldInfo", "name type_code display_size internal_size precision scale null_ok " "default collation", ) class BaseDatabaseIntrospection: """Encapsulate backend-specific introspection utilities.""" data_types_reverse = {} def __init__(self, connection): self.connection = connection def get_field_type(self, data_type, description): """ Hook for a database backend to use the cursor description to match a Django field type to a database column. For Oracle, the column data_type on its own is insufficient to distinguish between a FloatField and IntegerField, for example. """ return self.data_types_reverse[data_type] def identifier_converter(self, name): """ Apply a conversion to the identifier for the purposes of comparison. The default identifier converter is for case sensitive comparison. """ return name def table_names(self, cursor=None, include_views=False): """ Return a list of names of all tables that exist in the database. Sort the returned table list by Python's default sorting. Do NOT use the database's ORDER BY here to avoid subtle differences in sorting order between databases. """ def get_names(cursor): return sorted( ti.name for ti in self.get_table_list(cursor) if include_views or ti.type == "t" ) if cursor is None: with self.connection.cursor() as cursor: return get_names(cursor) return get_names(cursor) def get_table_list(self, cursor): """ Return an unsorted list of TableInfo named tuples of all tables and views that exist in the database. """ raise NotImplementedError( "subclasses of BaseDatabaseIntrospection may require a get_table_list() " "method" ) def get_table_description(self, cursor, table_name): """ Return a description of the table with the DB-API cursor.description interface. """ raise NotImplementedError( "subclasses of BaseDatabaseIntrospection may require a " "get_table_description() method." ) def get_migratable_models(self): from django.apps import apps from django.db import router return ( model for app_config in apps.get_app_configs() for model in router.get_migratable_models(app_config, self.connection.alias) if model._meta.can_migrate(self.connection) ) def django_table_names(self, only_existing=False, include_views=True): """ Return a list of all table names that have associated Django models and are in INSTALLED_APPS. If only_existing is True, include only the tables in the database. """ tables = set() for model in self.get_migratable_models(): if not model._meta.managed: continue tables.add(model._meta.db_table) tables.update( f.m2m_db_table() for f in model._meta.local_many_to_many if f.remote_field.through._meta.managed ) tables = list(tables) if only_existing: existing_tables = set(self.table_names(include_views=include_views)) tables = [ t for t in tables if self.identifier_converter(t) in existing_tables ] return tables def installed_models(self, tables): """ Return a set of all models represented by the provided list of table names. """ tables = set(map(self.identifier_converter, tables)) return { m for m in self.get_migratable_models() if self.identifier_converter(m._meta.db_table) in tables } def sequence_list(self): """ Return a list of information about all DB sequences for all models in all apps. """ sequence_list = [] with self.connection.cursor() as cursor: for model in self.get_migratable_models(): if not model._meta.managed: continue if model._meta.swapped: continue sequence_list.extend( self.get_sequences( cursor, model._meta.db_table, model._meta.local_fields ) ) for f in model._meta.local_many_to_many: # If this is an m2m using an intermediate table, # we don't need to reset the sequence. if f.remote_field.through._meta.auto_created: sequence = self.get_sequences(cursor, f.m2m_db_table()) sequence_list.extend( sequence or [{"table": f.m2m_db_table(), "column": None}] ) return sequence_list def get_sequences(self, cursor, table_name, table_fields=()): """ Return a list of introspected sequences for table_name. Each sequence is a dict: {'table': <table_name>, 'column': <column_name>}. An optional 'name' key can be added if the backend supports named sequences. """ raise NotImplementedError( "subclasses of BaseDatabaseIntrospection may require a get_sequences() " "method" ) def get_relations(self, cursor, table_name): """ Return a dictionary of {field_name: (field_name_other_table, other_table)} representing all foreign keys in the given table. """ raise NotImplementedError( "subclasses of BaseDatabaseIntrospection may require a " "get_relations() method." ) def get_primary_key_column(self, cursor, table_name): """ Return the name of the primary key column for the given table. """ columns = self.get_primary_key_columns(cursor, table_name) return columns[0] if columns else None def get_primary_key_columns(self, cursor, table_name): """Return a list of primary key columns for the given table.""" for constraint in self.get_constraints(cursor, table_name).values(): if constraint["primary_key"]: return constraint["columns"] return None def get_constraints(self, cursor, table_name): """ Retrieve any constraints or keys (unique, pk, fk, check, index) across one or more columns. Return a dict mapping constraint names to their attributes, where attributes is a dict with keys: * columns: List of columns this covers * primary_key: True if primary key, False otherwise * unique: True if this is a unique constraint, False otherwise * foreign_key: (table, column) of target, or None * check: True if check constraint, False otherwise * index: True if index, False otherwise. * orders: The order (ASC/DESC) defined for the columns of indexes * type: The type of the index (btree, hash, etc.) Some backends may return special constraint names that don't exist if they don't name constraints of a certain type (e.g. SQLite) """ raise NotImplementedError( "subclasses of BaseDatabaseIntrospection may require a get_constraints() " "method" ) PK �"�Z __init__.pynu �[��� PK �"�Z���o �o base.pynu �[��� PK �"�Z>+�i: i: #p features.pynu �[��� PK �"�ZLh �4= 4= Ǫ creation.pynu �[��� PK �"�Z�>���z �z & 6� __pycache__/operations.cpython-310.pycnu �[��� PK �"�Z� q�� � $ c __pycache__/__init__.cpython-310.pycnu �[��� PK �"�Z�R��� � " d __pycache__/client.cpython-310.pycnu �[��� PK �"�Z����* �* $ Bi __pycache__/creation.cpython-310.pycnu �[��� PK �"�Z��9� 9� " Y� __pycache__/schema.cpython-310.pycnu �[��� PK �"�Z�F�8 8 & �? __pycache__/validation.cpython-310.pycnu �[��� PK �"�Z 2�& & $ rE __pycache__/features.cpython-310.pycnu �[��� PK �"�Z��,Z_ Z_ �_ __pycache__/base.cpython-310.pycnu �[��� PK �"�Zɕ��! �! ) �� __pycache__/introspection.cpython-310.pycnu �[��� PK �"�Z��� q q �� operations.pynu �[��� PK �"�Z �Ved d 7S schema.pynu �[��� PK �"�Z7 �թ � �r client.pynu �[��� PK �"�Z����+ + �v validation.pynu �[��� PK �"�ZJf7�� � { introspection.pynu �[��� PK �"�Z :� __init__.pynu �[��� PK ) u�
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings