SqlConnection Model 

Authentication method. The authentication method to use for the connection. Example: ‘Standard TCP/IP’, ‘Standard TCP/IP over SSH’, ‘LDAP User/Password’.

Choices:

none
tcpip
tcpip_ssh
ldap_user_pwd

The authentication method to use for the connection. Example: ‘Standard TCP/IP’, ‘Standard TCP/IP over SSH’, ‘LDAP User/Password’.

Type:: Type

cache_expiration = 60

classmethod check(**kwargs)

clean(): Hook for doing any extra model-wide validation after clean() has been called on every field by self.clean_fields. Any ValidationError raised by this method will not be associated with a particular field; it will have a special-case association with the field defined by NON_FIELD_ERRORS.

clean_fields(exclude=None): Clean all fields and raise a ValidationError containing a dict of all validation errors if any occur.

close()[source]

Close the database connection.

This method closes the current database connection associated with this SQL connection instance, if it exists. If an error occurs while closing the connection, it is logged and the connection reference is cleared.

Returns:: None

connect_ldap_user_pwd()[source]

Establish a database connection using LDAP User/Password authentication.

This method attempts to create and validate a database connection using LDAP User/Password authentication, based on the current SQL connection instance’s configuration. It emits signals for connection attempts, successes, and failures for observability.

Returns:: The database connection object if successful, otherwise None.
Return type:: Optional[BaseDatabaseWrapper]

connect_tcpip()[source]

Establish a test database connection using Standard TCP/IP.

This method attempts to create and validate a database connection using the standard TCP/IP authentication method, based on the current SQL connection instance’s configuration. It emits signals for connection attempts, successes, and failures for observability.

Returns:: The database connection object if successful, otherwise None.
Return type:: Optional[BaseDatabaseWrapper]

Example:

db_wrapper = sql_connection.connect_tcpip()
if db_wrapper:
    # Connection established, use db_wrapper...
    pass

See also:

django.db.utils.ConnectionHandler()
SqlConnection.django_db_connection()

connect_tcpip_ssh()[source]

Establish a database connection using Standard TCP/IP over SSH with Paramiko.

This method attempts to create and validate a database connection using the standard TCP/IP authentication method over an SSH tunnel, based on the current SQL connection instance’s configuration. It emits signals for connection attempts, successes, and failures for observability.

Returns:: The database connection object if successful, otherwise None.
Return type:: Optional[BaseDatabaseWrapper]

property connection: BaseDatabaseWrapper | None

Return the database connection if it exists, otherwise create a new one.

This property returns the current database connection for this SQL connection instance. If a connection has already been established, it is returned; otherwise, a new connection is created using the configured authentication method and connection parameters.

Returns:: The database connection object, or None if the connection could not be established.
Return type:: Optional[BaseDatabaseWrapper]

Example:

conn = sql_connection.connection
if conn:
    # Use the database connection
    ...

See also:

get_connection()

property connection_string: str

Return the database connection string. This property constructs and returns a database connection string based on the current SQL connection instance’s configuration.

Returns:: A database connection string.
Return type:: str

created_at

DateTimeField

Created at

Timestamp indicating when the model instance was created. This field is automatically set to the current date and time when the instance is first created. It is indexed in the database for efficient querying.

Type:: Type

data_to_dict(data)

Converts data to a dictionary, handling different types of input.

This method accepts either a dictionary or a string. If a string is provided, it will attempt to parse it as JSON first, and if that fails, as YAML. If parsing fails or the data type is unsupported, a SmarterValueError is raised.

Parameters:: data (dict or str) – The data to convert, either a dict or a JSON/YAML string.
Returns:: The data as a dictionary.
Return type:: dict
Raises:: SmarterValueError – If the data cannot be converted to a dictionary.

database

Database. The name of the database to connect to.

The name of the database to connect to.

Type:: Type

date_error_message(lookup_type, field_name, unique_for)

db_engine

Db engine. The type of database management system. Example: ‘MySQL’, ‘PostgreSQL’, ‘MS SQL Server’, ‘Oracle’.

Choices:

django.db.backends.mysql
django.db.backends.postgresql
django.db.backends.sqlite3
django.db.backends.oracle
django.db.backends.mssql
django.db.backends.sybase

The type of database management system. Example: ‘MySQL’, ‘PostgreSQL’, ‘MS SQL Server’, ‘Oracle’.

Type:: Type

property db_options: dict

Return the database connection options.

This property constructs and returns a dictionary of options for the database connection, including SSL/TLS settings and authentication method if applicable.

If SSL is enabled (use_ssl is True), the returned dictionary includes the keys ca, cert, and key for SSL configuration.
If the authentication method is LDAP user/password, the dictionary includes an authentication key set to LDAP.

Returns:: A dictionary of database connection options.
Return type:: dict

Example:

options = sql_connection.db_options
# returns: {'ssl': {'ca': '...', 'cert': '...', 'key': '...'}, 'authentication': 'LDAP'}

delete(using=None, keep_parents=False)

description

Description. A brief description of this resource. Be verbose, but not too verbose.

Type:: Type

property django_db_connection: dict

Return the database connection settings for Django.

This property constructs and returns a dictionary of settings compatible with Django’s database connection handler, using the current SQL connection instance’s configuration.

The returned dictionary includes the following keys:

ENGINE: The database backend engine (e.g., django.db.backends.mysql).
NAME: The name of the database.
USER: The database username.
PASSWORD: The password for authentication, if set.
HOST: The database host.
PORT: The database port as a string.
OPTIONS: Additional database connection options (such as SSL or authentication settings).

Returns:: A dictionary of Django database connection settings.
Return type:: dict

Example:

settings = sql_connection.django_db_connection
# returns:
# {
#     "ENGINE": "django.db.backends.mysql",
#     "NAME": "mydb",
#     "USER": "myuser",
#     "PASSWORD": "mypassword",
#     "HOST": "localhost",
#     "PORT": "3306",
#     "OPTIONS": {...}
# }

property elapsed_updated: int | None

Calculate the absolute time difference in seconds between a given datetime and the model’s updated_at timestamp.

This property is useful for determining how much time has elapsed since the model instance was last updated, or for comparing the updated_at field to any arbitrary datetime.

Parameters:

dt (datetime, optional): The reference datetime to compare against updated_at. - If dt is not provided, the current time is used. - Both naive and timezone-aware datetime objects are supported; the method will handle conversions as needed.

Returns:

int or None: The absolute difference in seconds between updated_at and dt. Returns None if updated_at is not set.

Example Usage:

obj = MyModel.objects.get(pk=1)
# Time since last update
seconds = obj.elapsed_updated
print(f"Seconds since last update: {seconds}")

# Compare to a specific datetime
import datetime
dt = datetime.datetime(2025, 12, 1, 12, 0, 0)
diff = obj.elapsed_updated(dt)
print(f"Seconds between updated_at and 2025-12-01 12:00:00: {diff}")

Note

Handles both naive and aware datetime objects, converting as necessary to ensure accurate calculation.
If updated_at is not set (e.g., the object has not been saved), returns None.

Attention

If dt is provided and is not a datetime.datetime instance, a TypeError will be raised.
Always ensure that updated_at is set before relying on this property for calculations.

execute_query(sql, limit=None)[source]

Execute a SQL query and return the results as a JSON string.

Parameters:

sql (str) – The SQL query to execute.
limit (Optional[int]) – Optional limit on the number of rows to return.

Return type:

Union[str, bool]

Returns:

JSON string of query results if successful, otherwise False.

Warning

This method does not perform any SQL injection protection or parameterization. It is the caller’s responsibility to ensure that the SQL query is safe and properly formatted.

Warning

This method does not limit the execution time nor the number of rows returned by the query, unless the limit parameter is provided. It is the caller’s responsibility to ensure that the query is efficient and does not return excessive data.

classmethod find_hash(value)

Finds and returns the first substring in the given value that matches the hashed ID format.

Parameters:: value (str) – The string to search for a hashed ID.
Returns:: The first matching hashed ID if found, otherwise None.
Return type:: Optional[str]

property formatted_class_name: str

Returns the class name formatted for logging.

Returns:: The formatted class name as a string.
Return type:: str

property formatted_state_not_ready: str

Returns the not-ready state formatted for logging.

Returns:: The formatted not-ready state as a string.
Return type:: str

property formatted_state_ready: str

Returns the readiness state formatted for logging.

Returns:: The formatted readiness state as a string.
Return type:: str

classmethod from_db(db, field_names, values)

full_clean(exclude=None, validate_unique=True, validate_constraints=True): Call clean_fields(), clean(), validate_unique(), and validate_constraints() on the model. Raise a ValidationError for any errors that occur.

get_authentication_method_display(*, field=<django.db.models.CharField: authentication_method>): Shows the label of the authentication_method. See get_FOO_display() for more information.

classmethod get_cached_connection_by_name_and_kind(user, kind, name, invalidate=False)

Return a single instance of a concrete subclass of ConnectionBase by name and kind.

This method retrieves a connection object (such as SqlConnection or ApiConnection) for the given user, connection kind, and connection name. It searches across all concrete subclasses of ConnectionBase and returns the matching instance if found.

Parameters:

user (User) – The user whose connection should be retrieved.
kind (SAMKinds) – The kind of connection (e.g., SAMKinds.SQL_CONNECTION or SAMKinds.API_CONNECTION).
name (str) – The name of the connection to retrieve.

Returns:

The connection instance if found, otherwise None.

Return type:

Union[ConnectionBase, None]

Example:

sql_conn = ConnectionBase.get_cached_connection_by_name_and_kind(user, SAMKinds.SQL_CONNECTION, "hr_database")
api_conn = ConnectionBase.get_cached_connection_by_name_and_kind(user, SAMKinds.API_CONNECTION, "inventory_api")

See also:

SqlConnection
ApiConnection
smarter.lib.cache.cache_results()
smarter.apps.account.utils.get_cached_account_for_user()

classmethod get_cached_connections_for_user(cls, user, invalidate=False)

Return a list of all instances of all concrete subclasses of ConnectionBase.

This method retrieves all connection objects (such as SqlConnection and ApiConnection) associated with the user’s account, across all concrete subclasses of ConnectionBase. It is useful for enumerating all available connections for a given user, regardless of connection type.

Parameters:: user (User) – The user whose connections should be retrieved.
Returns:: A list of all connection instances for the user’s account.
Return type:: list[ConnectionBase]

Example:

connections = ConnectionBase.get_cached_connections_for_user(user)
# returns [<SqlConnection ...>, <ApiConnection ...>, ...]

See also:

SqlConnection
ApiConnection
smarter.apps.account.utils.get_cached_account_for_user()

classmethod get_cached_object(invalidate=False, pk=None, name=None, user=None, user_profile=None, username=None, account=None)

Retrieve a model instance using caching to optimize performance.

Examples of retrieval patterns:

# By primary key
instance = MyModel.get_cached_object(pk=123)

# By name and user profile
instance = MyModel.get_cached_object(name="Resource Name", user_profile=user_profile)

# By name and account
instance = MyModel.get_cached_object(name="Resource Name", account=account)

Parameters:

pk (Optional[int]) – The primary key of the model instance to retrieve.
name (Optional[str]) – The name of the model instance to retrieve.
user (Optional[User]) – The user associated with the model instance.
user_profile (Optional[UserProfile]) – The user profile associated with the model instance.
account (Optional[Account]) – The account associated with the model instance.
invalidate (Optional[bool]) – Whether to invalidate the cache for this retrieval.

Returns:

The model instance if found, otherwise None.

Return type:

Optional[models.Model]

classmethod get_cached_objects(invalidate=False, user_profile=None)

Retrieve a list of MetaDataWithOwnershipModel instances associated with a user profile using caching.

Example usage:

# Retrieve MetaDataWithOwnershipModel instances for a user profile with caching
models = MetaDataWithOwnershipModel.get_cached_objects(my_user_profile, invalidate=invalidate)

Parameters:

invalidate (bool, optional) – Whether to invalidate the cache for this retrieval.
user_profile (UserProfile, optional) – The user profile for which to retrieve MetaDataWithOwnershipModel instances.

Returns:

A queryset of MetaDataWithOwnershipModel instances associated with the user profile.

Return type:

models.QuerySet[“MetaDataWithOwnershipModel”]

get_connection()[source]

Establish a database connection based on the authentication method.

This method attempts to establish a database connection using the configured authentication method for this SQL connection instance. The authentication method can be standard TCP/IP, TCP/IP over SSH, LDAP user/password, or none. Returns the database connection object if successful, otherwise None.

Returns:: The database connection object if successful, otherwise None.
Return type:: Optional[BaseDatabaseWrapper]

get_connection_string(masked=True)[source]

Return the connection string.

This method constructs and returns a database connection string based on the current connection instance’s configuration. If masked is True, sensitive information such as the password or API key will be masked in the returned string.

Parameters:: masked (bool) – Whether to mask sensitive information in the connection string.
Returns:: The constructed connection string.
Return type:: str

Example:

conn_str = sql_connection.get_connection_string(masked=True)
# returns: 'mysql://user:******@host:3306/dbname'

Important

Unlike most of the Smarter codebase, this method does not use Pydantic SecretStr for masking to avoid adding Pydantic as a dependency for the entire smarter package.

get_constraints()

get_db_engine_display(*, field=<django.db.models.CharField: db_engine>): Shows the label of the db_engine. See get_FOO_display() for more information.

get_deferred_fields(): Return a set containing names of deferred fields for this instance.

get_kind_display(*, field=<django.db.models.CharField: kind>): Shows the label of the kind. See get_FOO_display() for more information.

classmethod get_object_by_locator(locator)

Retrieves an object based on its record locator.

Example:

obj = MyModel.objects.create()
print(obj.id)  # e.g., 123
locator = obj.record_locator # e.g., "mymodel-rc2x"

retrieved_obj = MyModel.get_object_by_locator(locator)
print(type(retrieved_obj))  # Should be <class 'MyModel'>
print(retrieved_obj)  # Should be the same as obj

Parameters:: locator (str) – The record locator string to decode and search for.
Returns:: The model instance if found, otherwise None.
Return type:: Optional[TimestampedModel]

get_proxy_protocol_display(*, field=<django.db.models.CharField: proxy_protocol>): Shows the label of the proxy_protocol. See get_FOO_display() for more information.

classmethod hash_regex()

Returns a regex pattern that matches the hashed ID format for this model anywhere in a string.

The hashed ID format is defined by the HASH_PREFIX and HASH_SUFFIX class attributes, with a base64-encoded string in between. This regex can be used to validate or extract hashed IDs from strings, including when embedded in URLs.

Returns:: A regex pattern for matching hashed IDs.
Return type:: re.Pattern

property hashed_id: str

Returns a URL-friendly hashed version of the object’s ID for use in URLs and other contexts where an obscured, non-identifying, non-sequential identifier is preferred.

Encoding scheme: 1. Take the object’s ID and add a large constant (HASH_FLOOR) to ensure it’s not easily guessable. 2. Convert the resulting number to a string and encode it using URL-safe base64 encoding. 3. Remove any padding characters from the encoded string. 4. Add a prefix and suffix to the encoded string to create a recognizable format.

Example:

obj = MyModel.objects.create()
print(obj.id)  # e.g., 123
print(obj.hashed_id)  # e.g., "rc2x"

Returns:: Hashed ID string (URL-safe, no padding)
Return type:: str

hostname

Hostname. The remote host of the SQL connection. Should be a valid internet domain name.

The remote host of the SQL connection. Should be a valid internet domain name.

Type:: Type

id

BigAutoField

Primary key: ID

Type:: Type

classmethod id_from_hashed_id(hashed_id)

Decodes a hashed ID back to the original object ID.

decoding scheme: 1. Validate that the hashed ID starts with the expected prefix and ends with the expected suffix. 2. Remove the prefix and suffix to isolate the base64-encoded string. 3. Add padding if necessary to make the length of the encoded string a multiple of 4. 4. Decode the base64 string to get the original number as a string. 5. Convert the decoded string to an integer and subtract the HASH_FLOOR to get the original ID.

Example:

my_record = MyModel.objects.create()
print(my_record.id)  # e.g., 123
hashed_id = my_record.hashed_id  # e.g., "rc2x"

original_id = MyModel.id_from_hashed_id(hashed_id)
print(original_id)  # Should print the original ID (e.g., 123)

Parameters:: hashed_id (str) – The hashed ID string to decode (URL-safe, no padding).
Returns:: The original object ID if decoding is successful, otherwise None.
Return type:: Optional[int]

kind

Kind. The kind of connection. Example: ‘SQL’, ‘API’.

Choices:

SqlConnection
ApiConnection

Type:: Type

mask_string(string='', mask_char='*', mask_length=4, string_length=8)

Masks a string for secure logging.

This utility function masks all but the last unmasked_chars characters of the input string, replacing them with asterisks. It is useful for logging sensitive information like API keys or passwords.

Parameters:

string (str) – The string to be masked.
mask_char (str) – The character used for masking.
mask_length (int) – The number of characters to mask.
string_length (int) – The length of the string to consider for masking.

Returns:

The masked string.

Return type:

str

max_overflow

Max overflow. The maximum number of connections to allow beyond the pool size.

The maximum number of connections to allow beyond the pool size.

Type:: Type

name

Name. Name in camelCase, e.g., ‘apiKey’, no special characters.

Type:: Type

objects = <django.db.models.Manager object>

password

ForeignKey to Secret

Password. The password for authentication, if required. (related name: sql_connections_password)

The password for authentication, if required.

See: smarter.apps.account.models.Secret

Type:: Type

password_id: Internal field, use password instead.

property pk

plugin_data_sql_connection

Reverse ForeignKey from PluginDataSql

All plugin data sql connection of this SQL Connection (related name of connection)

Type:: Type

pool_size

Pool size. The size of the connection pool.

The size of the connection pool.

Type:: Type

port

Port. The port of the SQL connection. example: 3306 for MySQL.

The port of the SQL connection. example: 3306 for MySQL. 5432 for PostgreSQL, 1521 for Oracle, 1433 for MS SQL Server. 5000 for Sybase. 1234 for SQLite (not commonly used). 3306 is a reasonable default as MySQL is widely used. 5432 could also be a reasonable default as PostgreSQL is also widely used.

Type:: Type

prepare_database_save(field)

proxy_host

Proxy host. The remote host of the SQL proxy connection. Should be a valid internet domain name.

The remote host of the SQL proxy connection. Should be a valid internet domain name.

Type:: Type

proxy_password

ForeignKey to Secret

Proxy password. The API key for authentication, if required. (related name: sql_connections_proxy_password)

The password for the proxy connection, if required.

See: smarter.apps.account.models.Secret

Type:: Type

proxy_password_id: Internal field, use proxy_password instead.

proxy_port

Proxy port. The port of the SQL proxy connection.

The port of the SQL proxy connection. 8080 is a common default for HTTP proxies. 3128 is another common default for HTTP proxies. 1080 is a common default for SOCKS proxies. 8080 is a reasonable default as it is widely used for HTTP proxies.

Type:: Type

proxy_protocol

Proxy protocol. The protocol to use for the proxy connection.

Choices:

http
https
socks

The protocol to use for the proxy connection.

Type:: Type

proxy_username

Proxy username. The username for the proxy connection.

The username for the proxy connection.

Type:: Type

property ready: bool

Indicates whether the object is ready for use. This is a placeholder that should be overridden in subclasses.

Returns:: True if ready, False otherwise.
Return type:: bool

property record_locator: str

Returns a short, URL-friendly record locator derived from the object’s ID.

Example:

obj = MyModel.objects.create(name="Example")
print(obj.id)  # e.g., 123
print(obj.record_locator)  # e.g., "chatbot-rc2x"

Returns:: Record locator string (URL-safe, no padding)
Return type:: str

refresh_from_db(using=None, fields=None, from_queryset=None)

Reload field values from the database.

By default, the reloading happens from the database this instance was loaded from, or by the read router if this instance wasn’t loaded from any database. The using parameter will override the default.

Fields can be used to specify which fields to reload. The fields should be an iterable of field attnames. If fields is None, then all non-deferred fields are reloaded.

When accessing deferred fields of an instance, the deferred loading of the field will call this method.

save(*args, **kwargs)[source]

Override the save method to validate the field dicts.

This method ensures that all relevant fields are validated before saving the model instance. For example, it checks that the name is in snake_case and converts it if necessary, logs a warning if conversion occurs, and calls the model’s validate() method to enforce any additional validation logic defined on the model. After validation, it proceeds with the standard Django save operation.

Parameters:

args – Positional arguments passed to the parent save method.
kwargs – Keyword arguments passed to the parent save method.

Returns:

None

save_base(raw=False, force_insert=False, force_update=False, using=None, update_fields=None)

Handle the parts of saving which should be done only once per save, yet need to be done in raw saves, too. This includes some sanity checks and signal sending.

The ‘raw’ argument is telling save_base not to save any parent models and not to do any changes to the values before save. This is used by fixture loading.

serializable_value(field_name)

Return the value of the field name for this instance. If the field is a foreign key, return the id value instead of the object. If there’s no Field object with this name on the model, return the model attribute’s value.

Used to serialize a field’s value (in the serializer, or form output, for example). Normally, you would just access the attribute directly and not use this method.

smarter_build_absolute_uri(request)

Attempts to get the absolute URI from a request object.

This utility function tries to retrieve the request URL from any valid child class of django.http.HttpRequest. It is especially useful in unit tests or scenarios where the request object may not implement build_absolute_uri().

Parameters:: request (Optional[HttpRequest]) – The request object.
Returns:: The absolute request URL.
Return type:: Optional[str]
Raises:: SmarterValueError – If the URI cannot be built from the request.

sorted_dict(data)

Returns a new dictionary with keys sorted.

Parameters:: data (dict) – The dictionary to sort.
Returns:: A new dictionary with sorted keys.
Return type:: dict

ssh_known_hosts

Ssh known hosts. The known_hosts file content for verifying SSH connections. Usually comes from ~/.ssh/known_hosts.

The known_hosts file content for verifying SSH connections. Usually comes from ~/.ssh/known_hosts.

Type:: Type

ssl_ca

Ssl ca. The Certificate Authority (CA) certificate for verifying the server.

The SSL certificate for the connection, if required. The SSL key for the connection, if required. The Certificate Authority (CA) certificate for verifying the server.

Type:: Type

ssl_cert

Ssl cert. The SSL certificate for the connection, if required.

Type:: Type

ssl_key

Ssl key. The SSL key for the connection, if required.

Type:: Type

tagged_items

Reverse GenericRelation from SqlConnection

All + of this tagged item (related name of tagged_items)

Type:: Type

tags = <taggit.managers._TaggableManager object>

property tags_list: list[str]

Return the tags as a list of strings. We assume that @cached_property is more efficient at fetch that @cache_results, all things considered equal, which provides a marginal boost to instances. Meanwhile, the @cache_results is persisted to the Django cache, and thus outlives this instance. Thus, best of both worlds.

Returns:: List of tag names.
Return type:: list[str]

test_connection()[source]

Establish a database connection based on the authentication method.

This method attempts to establish a database connection using the configured authentication method for this SQL connection instance. The authentication method can be standard TCP/IP, TCP/IP over SSH, LDAP user/password, or none. Returns True if the connection is successfully established, otherwise False.

Returns:: True if the connection is established, False otherwise.
Return type:: bool

Important

This method is called during the validation process to ensure that the connection parameters are correct and that a connection can be successfully made to the database. For example, it is invoked when saving a SqlConnection instance to verify the connection details.

See also:

get_connection()

test_proxy()[source]

Test the proxy connection by making a request to a known URL through the proxy.

Returns:: True if the proxy connection is successful, otherwise False.
Return type:: bool

timeout

Timeout. The timeout for the database connection in seconds. Default is 30 seconds.

The timeout for the database connection in seconds. Default is 30 seconds.

Type:: Type

to_json()

Serialize the model instance to a JSON-compatible dictionary.

This method uses the custom SmarterJSONEncoder to ensure that all fields, including timestamps and any complex data types, are properly serialized.

Returns:: A dictionary representation of the model instance suitable for JSON serialization.
Return type:: dict[str, Any]

transport_handler(channel, src_addr, dest_addr)[source]: (NOT IMPLEMENTED) Handler for Paramiko SSH transport channels.

Warning

This method is a placeholder and does not implement actual port forwarding logic.

property unformatted_class_name: str

Returns the raw class name without formatting.

Returns:: The unformatted class name as a string.
Return type:: str

This is useful for logging or serialization where the plain class name is needed.

unique_error_message(model_class, unique_check)

updated_at

DateTimeField

Updated at

Timestamp indicating when the model instance was last updated. This field is automatically updated to the current date and time whenever the instance is saved. It is indexed in the database for efficient querying.

Type:: Type

use_ssl

BooleanField

Use ssl. Whether to use SSL/TLS for the connection.

Whether to use SSL/TLS for the connection.

Type:: Type

user_profile

ForeignKey to UserProfile

User profile (related name: sqlconnections)

Type:: Type

user_profile_id: Internal field, use user_profile instead.

username

Username. The database username.

The database username.

Type:: Type

validate()[source]

Override the validate method to test the SQL connection.

Returns:: True if the connection test is successful, otherwise False.
Return type:: bool

validate_constraints(exclude=None)

validate_unique(exclude=None): Check unique constraints on the model and raise ValidationError if any failed.

version