SYMBOL INDEX (3071 symbols across 163 files) FILE: app/observers/UserObserver.py class UserObserver (line 6) | class UserObserver: method created (line 7) | def created(self, clients): method creating (line 15) | def creating(self, clients): method saving (line 23) | def saving(self, clients): method saved (line 31) | def saved(self, clients): method updating (line 39) | def updating(self, clients): method updated (line 47) | def updated(self, clients): method booted (line 55) | def booted(self, clients): method booting (line 63) | def booting(self, clients): method hydrating (line 71) | def hydrating(self, clients): method hydrated (line 79) | def hydrated(self, clients): method deleting (line 87) | def deleting(self, clients): method deleted (line 95) | def deleted(self, clients): FILE: cc.py class User (line 18) | class User(Model): method articles (line 24) | def articles(self): class Company (line 26) | class Company(Model): FILE: databases/migrations/2018_01_09_043202_create_users_table.py class CreateUsersTable (line 5) | class CreateUsersTable(Migration): method up (line 7) | def up(self): method down (line 26) | def down(self): FILE: databases/migrations/2020_04_17_000000_create_friends_table.py class CreateFriendsTable (line 3) | class CreateFriendsTable(Migration): method up (line 5) | def up(self): method down (line 15) | def down(self): FILE: databases/migrations/2020_04_17_00000_create_articles_table.py class CreateArticlesTable (line 3) | class CreateArticlesTable(Migration): method up (line 5) | def up(self): method down (line 14) | def down(self): FILE: databases/migrations/2020_10_20_152904_create_table_schema_migration.py class CreateTableSchemaMigration (line 6) | class CreateTableSchemaMigration(Migration): method up (line 8) | def up(self): method down (line 17) | def down(self): FILE: databases/seeds/database_seeder.py class DatabaseSeeder (line 6) | class DatabaseSeeder(Seeder): method run (line 8) | def run(self): FILE: databases/seeds/user_table_seeder.py class UserTableSeeder (line 9) | class UserTableSeeder(Seeder): method run (line 11) | def run(self): FILE: src/masoniteorm/collection/Collection.py class Collection (line 7) | class Collection: method __init__ (line 10) | def __init__(self, items=None): method take (line 14) | def take(self, number: int): method first (line 28) | def first(self, callback=None): method items (line 48) | def items(self): method last (line 51) | def last(self, callback=None): method all (line 67) | def all(self): method avg (line 75) | def avg(self, key=None): method max (line 94) | def max(self, key=None): method min (line 114) | def min(self, key=None): method chunk (line 134) | def chunk(self, size: int): method collapse (line 148) | def collapse(self): method contains (line 154) | def contains(self, key, value=None): method count (line 163) | def count(self): method diff (line 166) | def diff(self, items): method each (line 170) | def each(self, callback): method every (line 179) | def every(self, callback): method filter (line 183) | def filter(self, callback): method flatten (line 187) | def flatten(self): method forget (line 202) | def forget(self, *keys): method for_page (line 210) | def for_page(self, page, number): method get (line 213) | def get(self, key, default=None): method implode (line 221) | def implode(self, glue=",", key=None): method is_empty (line 227) | def is_empty(self): method map (line 230) | def map(self, callback): method map_into (line 235) | def map_into(self, cls, method=None, **kwargs): method merge (line 245) | def merge(self, items): method pluck (line 256) | def pluck(self, value, key=None, keep_nulls=True): method pop (line 287) | def pop(self): method prepend (line 291) | def prepend(self, value): method pull (line 295) | def pull(self, key): method push (line 300) | def push(self, value): method put (line 303) | def put(self, key, value): method random (line 307) | def random(self, count=None): method reduce (line 320) | def reduce(self, callback, initial=0): method reject (line 323) | def reject(self, callback): method reverse (line 329) | def reverse(self): method serialize (line 332) | def serialize(self, *args, **kwargs): method add_relation (line 345) | def add_relation(self, result=None): method shift (line 351) | def shift(self): method sort (line 354) | def sort(self, key=None): method sum (line 362) | def sum(self, key=None): method to_json (line 371) | def to_json(self, **kwargs): method group_by (line 374) | def group_by(self, key): method transform (line 386) | def transform(self, callback): method unique (line 390) | def unique(self, key=None): method where (line 413) | def where(self, key, *args): method where_in (line 432) | def where_in(self, key, args: list) -> "Collection": method where_not_in (line 457) | def where_not_in(self, key, args: list) -> "Collection": method zip (line 482) | def zip(self, items): method set_appends (line 492) | def set_appends(self, appends): method _get_value (line 501) | def _get_value(self, key): method _data_get (line 516) | def _data_get(self, item, key, default=None): method _value (line 527) | def _value(self, value): method _check_is_callable (line 532) | def _check_is_callable(self, callback, raise_exception=True): method _make_comparison (line 539) | def _make_comparison(self, a, b, op): method __iter__ (line 550) | def __iter__(self): method __eq__ (line 554) | def __eq__(self, other): method __getitem__ (line 558) | def __getitem__(self, item): method __setitem__ (line 569) | def __setitem__(self, key, value): method __delitem__ (line 572) | def __delitem__(self, key): method __ne__ (line 575) | def __ne__(self, other): method __len__ (line 579) | def __len__(self): method __le__ (line 582) | def __le__(self, other): method __lt__ (line 586) | def __lt__(self, other): method __ge__ (line 590) | def __ge__(self, other): method __gt__ (line 594) | def __gt__(self, other): method __get_items (line 599) | def __get_items(cls, items): FILE: src/masoniteorm/commands/CanOverrideConfig.py class CanOverrideConfig (line 4) | class CanOverrideConfig(Command): method __init__ (line 5) | def __init__(self): method add_option (line 9) | def add_option(self): FILE: src/masoniteorm/commands/CanOverrideOptionsDefault.py class CanOverrideOptionsDefault (line 4) | class CanOverrideOptionsDefault: method __init__ (line 13) | def __init__(self, **kwargs): FILE: src/masoniteorm/commands/Command.py class Command (line 5) | class Command(CanOverrideOptionsDefault, CanOverrideConfig): FILE: src/masoniteorm/commands/MakeMigrationCommand.py class MakeMigrationCommand (line 10) | class MakeMigrationCommand(Command): method handle (line 21) | def handle(self): FILE: src/masoniteorm/commands/MakeModelCommand.py class MakeModelCommand (line 9) | class MakeModelCommand(Command): method handle (line 25) | def handle(self): FILE: src/masoniteorm/commands/MakeModelDocstringCommand.py class MakeModelDocstringCommand (line 5) | class MakeModelDocstringCommand(Command): method handle (line 15) | def handle(self): FILE: src/masoniteorm/commands/MakeObserverCommand.py class MakeObserverCommand (line 9) | class MakeObserverCommand(Command): method handle (line 19) | def handle(self): FILE: src/masoniteorm/commands/MakeSeedCommand.py class MakeSeedCommand (line 9) | class MakeSeedCommand(Command): method handle (line 18) | def handle(self): FILE: src/masoniteorm/commands/MigrateCommand.py class MigrateCommand (line 7) | class MigrateCommand(Command): method handle (line 20) | def handle(self): FILE: src/masoniteorm/commands/MigrateFreshCommand.py class MigrateFreshCommand (line 6) | class MigrateFreshCommand(Command): method handle (line 19) | def handle(self): FILE: src/masoniteorm/commands/MigrateRefreshCommand.py class MigrateRefreshCommand (line 6) | class MigrateRefreshCommand(Command): method handle (line 19) | def handle(self): FILE: src/masoniteorm/commands/MigrateResetCommand.py class MigrateResetCommand (line 5) | class MigrateResetCommand(Command): method handle (line 16) | def handle(self): FILE: src/masoniteorm/commands/MigrateRollbackCommand.py class MigrateRollbackCommand (line 5) | class MigrateRollbackCommand(Command): method handle (line 17) | def handle(self): FILE: src/masoniteorm/commands/MigrateStatusCommand.py class MigrateStatusCommand (line 5) | class MigrateStatusCommand(Command): method handle (line 15) | def handle(self): FILE: src/masoniteorm/commands/SeedRunCommand.py class SeedRunCommand (line 7) | class SeedRunCommand(Command): method handle (line 18) | def handle(self): FILE: src/masoniteorm/commands/ShellCommand.py class ShellCommand (line 12) | class ShellCommand(Command): method handle (line 28) | def handle(self): method get_shell_program (line 60) | def get_shell_program(self, connection): method get_command (line 64) | def get_command(self, config): method get_mysql_args (line 101) | def get_mysql_args(self, config): method get_postgres_args (line 115) | def get_postgres_args(self, config): method get_postgres_env (line 127) | def get_postgres_env(self, config): method get_mssql_args (line 130) | def get_mssql_args(self, config): method get_sqlite_args (line 152) | def get_sqlite_args(self, config): method remove_empty_options (line 158) | def remove_empty_options(self, options): method get_sensitive_options (line 172) | def get_sensitive_options(self, config): method get_mysql_sensitive_options (line 180) | def get_mysql_sensitive_options(self): method get_mssql_sensitive_options (line 183) | def get_mssql_sensitive_options(self): method hide_sensitive_options (line 186) | def hide_sensitive_options(self, config, command): FILE: src/masoniteorm/config.py function load_config (line 9) | def load_config(config_path=None): function db_url (line 33) | def db_url(database_url=None, prefix="", options={}, log_queries=False): FILE: src/masoniteorm/connections/BaseConnection.py class BaseConnection (line 6) | class BaseConnection: method dry (line 11) | def dry(self): method set_schema (line 15) | def set_schema(self, schema): method log (line 19) | def log( method statement (line 30) | def statement(self, query, bindings=()): method has_global_connection (line 49) | def has_global_connection(self): method get_global_connection (line 52) | def get_global_connection(self): method enable_query_log (line 55) | def enable_query_log(self): method disable_query_log (line 58) | def disable_query_log(self): method format_cursor_results (line 61) | def format_cursor_results(self, cursor_result): method set_cursor (line 64) | def set_cursor(self): method select_many (line 68) | def select_many(self, query, bindings, amount): method enable_disable_foreign_keys (line 80) | def enable_disable_foreign_keys(self): FILE: src/masoniteorm/connections/ConnectionFactory.py class ConnectionFactory (line 4) | class ConnectionFactory: method __init__ (line 9) | def __init__(self, config_path=None): method register (line 13) | def register(cls, key, connection): method make (line 26) | def make(self, key): FILE: src/masoniteorm/connections/ConnectionResolver.py class ConnectionResolver (line 4) | class ConnectionResolver: method __init__ (line 9) | def __init__(self, config_path=None): method morph_map (line 26) | def morph_map(self, map): method set_connection_details (line 30) | def set_connection_details(self, connection_details): method get_connection_details (line 34) | def get_connection_details(self): method set_connection_option (line 37) | def set_connection_option(self, connection: str, options: dict): method get_global_connections (line 41) | def get_global_connections(self): method remove_global_connection (line 44) | def remove_global_connection(self, name=None): method register (line 47) | def register(self, connection): method begin_transaction (line 50) | def begin_transaction(self, name=None): method commit (line 67) | def commit(self, name=None): method rollback (line 74) | def rollback(self, name=None): method transaction (line 83) | def transaction(self, name=None): method get_connection_information (line 97) | def get_connection_information(self, name): method get_schema_builder (line 110) | def get_schema_builder(self, connection="default", schema=None): method get_query_builder (line 119) | def get_query_builder(self, connection="default"): method statement (line 126) | def statement(self, query, bindings=(), connection="default"): FILE: src/masoniteorm/connections/MSSQLConnection.py class MSSQLConnection (line 12) | class MSSQLConnection(BaseConnection): method __init__ (line 17) | def __init__( method make_connection (line 46) | def make_connection(self): method get_database_name (line 78) | def get_database_name(self): method get_default_query_grammar (line 82) | def get_default_query_grammar(cls): method get_default_platform (line 86) | def get_default_platform(cls): method get_default_post_processor (line 90) | def get_default_post_processor(cls): method reconnect (line 93) | def reconnect(self): method commit (line 96) | def commit(self): method begin (line 104) | def begin(self): method rollback (line 110) | def rollback(self): method get_transaction_level (line 118) | def get_transaction_level(self): method get_cursor (line 122) | def get_cursor(self): method query (line 125) | def query(self, query, bindings=(), results="*"): method format_cursor_results (line 169) | def format_cursor_results(self, cursor_result): FILE: src/masoniteorm/connections/MySQLConnection.py class MySQLConnection (line 11) | class MySQLConnection(BaseConnection): method __init__ (line 17) | def __init__( method make_connection (line 47) | def make_connection(self): method close_connection (line 62) | def close_connection(self): method create_connection (line 71) | def create_connection(self, autocommit=True): method reconnect (line 128) | def reconnect(self): method get_default_query_grammar (line 133) | def get_default_query_grammar(cls): method get_default_platform (line 137) | def get_default_platform(cls): method get_default_post_processor (line 141) | def get_default_post_processor(cls): method get_database_name (line 144) | def get_database_name(self): method commit (line 147) | def commit(self): method dry (line 155) | def dry(self): method begin (line 160) | def begin(self): method rollback (line 166) | def rollback(self): method get_transaction_level (line 174) | def get_transaction_level(self): method get_cursor (line 178) | def get_cursor(self): method query (line 181) | def query(self, query, bindings=(), results="*"): FILE: src/masoniteorm/connections/PostgresConnection.py class PostgresConnection (line 12) | class PostgresConnection(BaseConnection): method __init__ (line 17) | def __init__( method make_connection (line 49) | def make_connection(self): method create_connection (line 71) | def create_connection(self): method get_database_name (line 126) | def get_database_name(self): method get_default_query_grammar (line 130) | def get_default_query_grammar(cls): method get_default_platform (line 134) | def get_default_platform(cls): method get_default_post_processor (line 138) | def get_default_post_processor(cls): method reconnect (line 141) | def reconnect(self): method close_connection (line 144) | def close_connection(self): method commit (line 155) | def commit(self): method begin (line 163) | def begin(self): method rollback (line 169) | def rollback(self): method get_transaction_level (line 177) | def get_transaction_level(self): method set_cursor (line 181) | def set_cursor(self): method query (line 187) | def query(self, query, bindings=(), results="*"): FILE: src/masoniteorm/connections/SQLiteConnection.py function regexp (line 9) | def regexp(expr, item): class SQLiteConnection (line 14) | class SQLiteConnection(BaseConnection): method __init__ (line 21) | def __init__( method make_connection (line 50) | def make_connection(self): method get_default_query_grammar (line 74) | def get_default_query_grammar(cls): method get_default_platform (line 78) | def get_default_platform(cls): method get_default_post_processor (line 82) | def get_default_post_processor(cls): method get_database_name (line 85) | def get_database_name(self): method reconnect (line 88) | def reconnect(self): method commit (line 91) | def commit(self): method begin (line 104) | def begin(self): method rollback (line 110) | def rollback(self): method get_cursor (line 121) | def get_cursor(self): method get_transaction_level (line 124) | def get_transaction_level(self): method query (line 127) | def query(self, query, bindings=(), results="*"): method format_cursor_results (line 166) | def format_cursor_results(self, cursor_result): method select_many (line 169) | def select_many(self, query, bindings, amount): FILE: src/masoniteorm/exceptions.py class DriverNotFound (line 1) | class DriverNotFound(Exception): class ModelNotFound (line 5) | class ModelNotFound(Exception): class HTTP404 (line 9) | class HTTP404(Exception): class ConnectionNotRegistered (line 13) | class ConnectionNotRegistered(Exception): class QueryException (line 17) | class QueryException(Exception): class MigrationNotFound (line 21) | class MigrationNotFound(Exception): class ConfigurationNotFound (line 25) | class ConfigurationNotFound(Exception): class InvalidUrlConfiguration (line 29) | class InvalidUrlConfiguration(Exception): class MultipleRecordsFound (line 33) | class MultipleRecordsFound(Exception): class InvalidArgument (line 37) | class InvalidArgument(Exception): FILE: src/masoniteorm/expressions/expressions.py class QueryExpression (line 4) | class QueryExpression: method __init__ (line 7) | def __init__( class HavingExpression (line 26) | class HavingExpression: method __init__ (line 29) | def __init__(self, column, equality=None, value=None, raw=False): class FromTable (line 42) | class FromTable: method __init__ (line 45) | def __init__(self, name, raw=False): class UpdateQueryExpression (line 50) | class UpdateQueryExpression: method __init__ (line 53) | def __init__(self, column, value=None, update_type="keyvalue"): class BetweenExpression (line 59) | class BetweenExpression: method __init__ (line 62) | def __init__(self, column, low, high, equality="BETWEEN"): class SubSelectExpression (line 72) | class SubSelectExpression: method __init__ (line 75) | def __init__(self, builder): class SubGroupExpression (line 79) | class SubGroupExpression: method __init__ (line 82) | def __init__(self, builder, alias="group"): class SelectExpression (line 87) | class SelectExpression: method __init__ (line 90) | def __init__(self, column, raw=False): class OrderByExpression (line 100) | class OrderByExpression: method __init__ (line 103) | def __init__(self, column, direction="ASC", raw=False, bindings=()): class GroupByExpression (line 121) | class GroupByExpression: method __init__ (line 124) | def __init__(self, column=None, raw=False, bindings=()): class AggregateExpression (line 131) | class AggregateExpression: method __init__ (line 132) | def __init__(self, aggregate=None, column=None, alias=False): class Raw (line 140) | class Raw: method __init__ (line 141) | def __init__(self, expression): class JoinClause (line 145) | class JoinClause: method __init__ (line 146) | def __init__(self, table, clause="join"): method on (line 156) | def on(self, column1, equality, column2): method or_on (line 160) | def or_on(self, column1, equality, column2): method on_value (line 164) | def on_value(self, column, *args): method or_on_value (line 169) | def or_on_value(self, column, *args): method on_null (line 176) | def on_null(self, column): method on_not_null (line 188) | def on_not_null(self, column: str): method or_on_null (line 200) | def or_on_null(self, column): method or_on_not_null (line 212) | def or_on_not_null(self, column: str): method where (line 227) | def where(self, column, *args): method _extract_operator_value (line 230) | def _extract_operator_value(self, *args): method get_on_clauses (line 251) | def get_on_clauses(self): class OnClause (line 255) | class OnClause: method __init__ (line 256) | def __init__(self, column1, equality, column2, operator="and"): class OnValueClause (line 263) | class OnValueClause: method __init__ (line 266) | def __init__( FILE: src/masoniteorm/factories/Factory.py class Factory (line 5) | class Factory: method faker (line 11) | def faker(self): method __init__ (line 19) | def __init__(self, model, number=1): method make (line 23) | def make(self, dictionary=None, name="default"): method create (line 55) | def create(self, dictionary=None, name="default"): method register (line 88) | def register(cls, model, call, name="default"): method after_creating (line 95) | def after_creating(cls, model, call, name="default"): method run_after_creates (line 101) | def run_after_creates(self, model): FILE: src/masoniteorm/helpers/misc.py function deprecated (line 6) | def deprecated(message): FILE: src/masoniteorm/migrations/Migration.py class Migration (line 15) | class Migration: method __init__ (line 16) | def __init__( method create_table_if_not_exists (line 47) | def create_table_if_not_exists(self): method get_unran_migrations (line 58) | def get_unran_migrations(self): method get_rollback_migrations (line 75) | def get_rollback_migrations(self): method get_all_migrations (line 83) | def get_all_migrations(self, reverse=False): method get_last_batch_number (line 93) | def get_last_batch_number(self): method delete_migration (line 96) | def delete_migration(self, file_path): method locate (line 99) | def locate(self, file_name): method get_ran_migrations (line 107) | def get_ran_migrations(self): method migrate (line 133) | def migrate(self, migration="all", output=False): method rollback (line 185) | def rollback(self, migration="all", output=False): method delete_migrations (line 242) | def delete_migrations(self, migrations=None): method delete_last_batch (line 245) | def delete_last_batch(self): method reset (line 250) | def reset(self, migration="all"): method refresh (line 288) | def refresh(self, migration="all"): method drop_all_tables (line 292) | def drop_all_tables(self, ignore_fk=False): method fresh (line 308) | def fresh(self, ignore_fk=False, migration="all"): FILE: src/masoniteorm/models/MigrationModel.py class MigrationModel (line 4) | class MigrationModel(Model): FILE: src/masoniteorm/models/Model.py class ModelMeta (line 25) | class ModelMeta(type): method __getattr__ (line 26) | def __getattr__(self, attribute, *args, **kwargs): class BoolCast (line 49) | class BoolCast: method get (line 52) | def get(self, value): method set (line 55) | def set(self, value): class JsonCast (line 59) | class JsonCast: method get (line 62) | def get(self, value): method set (line 71) | def set(self, value): class IntCast (line 80) | class IntCast: method get (line 83) | def get(self, value): method set (line 86) | def set(self, value): class FloatCast (line 90) | class FloatCast: method get (line 93) | def get(self, value): method set (line 96) | def set(self, value): class DateCast (line 100) | class DateCast: method get (line 103) | def get(self, value): method set (line 106) | def set(self, value): class DecimalCast (line 110) | class DecimalCast: method get (line 113) | def get(self, value): method set (line 122) | def set(self, value): class Model (line 129) | class Model(TimeStampsMixin, ObservesEvents, metaclass=ModelMeta): method __init__ (line 284) | def __init__(self): method get_primary_key (line 296) | def get_primary_key(self): method get_primary_key_type (line 304) | def get_primary_key_type(self): method get_primary_key_value (line 312) | def get_primary_key_value(self): method get_foreign_key (line 330) | def get_foreign_key(self): method query (line 341) | def query(self): method get_builder (line 344) | def get_builder(self): method get_selects (line 359) | def get_selects(self): method get_columns (line 363) | def get_columns(cls): method get_connection_details (line 366) | def get_connection_details(self): method boot (line 370) | def boot(self): method append_passthrough (line 393) | def append_passthrough(self, passthrough): method get_table_name (line 398) | def get_table_name(cls): method table (line 407) | def table(cls, table): method find (line 417) | def find(cls, record_id, query=False): method find_or_fail (line 440) | def find_or_fail(cls, record_id, query=False): method is_loaded (line 456) | def is_loaded(self): method is_created (line 459) | def is_created(self): method add_relation (line 462) | def add_relation(self, relations): method hydrate (line 467) | def hydrate(cls, result, relations=None): method fill (line 525) | def fill(self, attributes): method fill_original (line 529) | def fill_original(self, attributes): method new_collection (line 534) | def new_collection(cls, data): method create (line 547) | def create( method cast_value (line 571) | def cast_value(cls, attribute: str, value: Any): method cast_values (line 590) | def cast_values(cls, dictionary: Dict[str, Any]) -> Dict[str, Any]: method fresh (line 598) | def fresh(self): method serialize (line 605) | def serialize(self, exclude=None, include=None): method to_json (line 680) | def to_json(self): method first_or_create (line 689) | def first_or_create(cls, wheres, creates: dict = None): method update_or_create (line 707) | def update_or_create(cls, wheres, updates): method relations_to_dict (line 718) | def relations_to_dict(self): method touch (line 743) | def touch(self, date=None, query=True): method _update_timestamps (line 753) | def _update_timestamps(self, date=None): method _current_timestamp (line 761) | def _current_timestamp(self): method __getattr__ (line 764) | def __getattr__(self, attribute): method only (line 814) | def only(self, attributes: list) -> dict: method __setattr__ (line 831) | def __setattr__(self, attribute, value): method get_raw_attribute (line 850) | def get_raw_attribute(self, attribute): method is_dirty (line 861) | def is_dirty(self): method get_original (line 864) | def get_original(self, key): method get_dirty (line 867) | def get_dirty(self, key): method get_dirty_keys (line 870) | def get_dirty_keys(self): method save (line 873) | def save(self, query=False): method get_value (line 907) | def get_value(self, attribute): method get_dirty_value (line 914) | def get_dirty_value(self, attribute): method all_attributes (line 921) | def all_attributes(self): method delete_attribute (line 930) | def delete_attribute(self, key): method get_dirty_attributes (line 937) | def get_dirty_attributes(self): method get_cast_map (line 942) | def get_cast_map(self): method _cast_attribute (line 947) | def _cast_attribute(self, attribute, value): method _set_cast_attribute (line 959) | def _set_cast_attribute(self, attribute, value): method load (line 969) | def load(cls, *loads): method __getitem__ (line 974) | def __getitem__(self, attribute): method get_dates (line 977) | def get_dates(self): method get_new_date (line 987) | def get_new_date(self, _datetime=None): method get_new_datetime_string (line 1013) | def get_new_datetime_string(self, _datetime=None): method get_new_serialized_date (line 1022) | def get_new_serialized_date(self, _datetime): method set_appends (line 1030) | def set_appends(self, appends): method save_many (line 1039) | def save_many(self, relation, relating_records): method detach_many (line 1048) | def detach_many(self, relation, relating_records): method related (line 1063) | def related(self, relation): method get_related (line 1067) | def get_related(self, relation): method attach (line 1071) | def attach(self, relation, related_record): method detach (line 1075) | def detach(self, relation, related_record): method save_quietly (line 1085) | def save_quietly(self): method delete_quietly (line 1102) | def delete_quietly(self): method attach_related (line 1123) | def attach_related(self, relation, related_record): method filter_fillable (line 1127) | def filter_fillable(cls, dictionary: Dict[str, Any]) -> Dict[str, Any]: method filter_mass_assignment (line 1138) | def filter_mass_assignment(cls, dictionary: Dict[str, Any]) -> Dict[st... method filter_guarded (line 1147) | def filter_guarded(cls, dictionary: Dict[str, Any]) -> Dict[str, Any]: FILE: src/masoniteorm/models/Model.pyi class Model (line 7) | class Model: method add_select (line 8) | def add_select(alias: str, callable: Any): method aggregate (line 12) | def aggregate(aggregate: str, column: str, alias: str): method all (line 20) | def all(selects: list = [], query: bool = False): method get (line 28) | def get(selects: list = []): method avg (line 36) | def avg(column: str): method between (line 47) | def between(column: str, low: str | int, high: str | int): method bulk_create (line 60) | def bulk_create(creates: dict, query: bool = False): method cast_value (line 63) | def cast_value(attribute: str, value: Any): method cast_values (line 70) | def cast_values(dictionary: Dict[str, Any]) -> Dict[str, Any]: method chunk (line 78) | def chunk(chunk_amount: str | int): method count (line 81) | def count(column: str = None): method create (line 92) | def create( method decrement (line 111) | def decrement(column: str, value: int = 1): method delete (line 124) | def delete(column: str = None, value: str = None, query: bool = False): method distinct (line 137) | def distinct(boolean: bool = True): method doesnt_exist (line 141) | def doesnt_exist() -> bool: method doesnt_have (line 149) | def doesnt_have() -> bool: method exists (line 157) | def exists() -> bool: method filter_fillable (line 165) | def filter_fillable(dictionary: Dict[str, Any]) -> Dict[str, Any]: method filter_mass_assignment (line 173) | def filter_mass_assignment(dictionary: Dict[str, Any]) -> Dict[str, Any]: method filter_guarded (line 181) | def filter_guarded(dictionary: Dict[str, Any]) -> Dict[str, Any]: method find_or_404 (line 189) | def find_or_404(record_id: str | int): method find (line 200) | def find(record_id: str | list) -> Self: method find_or_fail (line 211) | def find_or_fail(record_id: str | int): method first_or_fail (line 222) | def first_or_fail(query: bool = False): method first (line 229) | def first(fields: list = None, query: bool = False): method first_where (line 237) | def first_where(column: str, *args): method first_or_create (line 241) | def first_or_create(wheres: dict, creates: dict = None): method force_update (line 249) | def force_update(updates: dict, dry: bool = False): method from_ (line 252) | def from_(table: str): method from_raw (line 263) | def from_raw(table: str): method last (line 274) | def last(column: str = None, query: bool = False): method group_by_raw (line 283) | def group_by_raw(query: str, bindings: list = []): method group_by (line 294) | def group_by(column: str): method has (line 305) | def has(*relationships: str): method having_raw (line 308) | def having_raw(string: str): method increment (line 319) | def increment(column: str, value: int = 1): method in_random_order (line 333) | def in_random_order(): method join_on (line 337) | def join_on(relationship: str, callback: callable = None, clause: str ... method join (line 340) | def join( method joins (line 364) | def joins(*relationships: list[str], clause: str = "inner"): method left_join (line 367) | def left_join( method limit (line 383) | def limit(amount: int): method lock_for_update (line 394) | def lock_for_update(): method make_lock (line 397) | def make_lock(lock: bool): method max (line 400) | def max(column: str): method min (line 411) | def min(column: str): method new_from_builder (line 422) | def new_from_builder(from_builder: QueryBuilder = None): method new (line 430) | def new(): method not_between (line 438) | def not_between(column: str, low: str | int, high: str | int): method offset (line 451) | def offset(amount: int): method on (line 462) | def on(connection: str): method or_where (line 465) | def or_where(column: str | int, *args) -> QueryBuilder: method or_where_null (line 477) | def or_where_null(column: str): method order_by_raw (line 488) | def order_by_raw(query: str, bindings: list = []): method order_by (line 502) | def order_by(column: str, direction: str = "ASC|DESC"): method paginate (line 516) | def paginate(per_page: int, page: int = 1): method right_join (line 519) | def right_join( method select_raw (line 535) | def select_raw(query: str): method select (line 543) | def select(*args: str): method set_global_scope (line 551) | def set_global_scope( method shared_lock (line 568) | def shared_lock(): method simple_paginate (line 571) | def simple_paginate(per_page: int, page: int = 1): method skip (line 574) | def skip(*args, **kwargs): method statement (line 578) | def statement(query: str, bindings: list = ()): method sum (line 581) | def sum(column: str): method table_raw (line 592) | def table_raw(query: str): method take (line 603) | def take(*args, **kwargs): method to_qmark (line 607) | def to_qmark() -> str: method to_sql (line 615) | def to_sql() -> str: method truncate (line 623) | def truncate(foreign_keys: bool = False): method update (line 626) | def update( method when (line 642) | def when(conditional: bool, callback: callable): method where_between (line 645) | def where_between(*args, **kwargs): method where_column (line 649) | def where_column(column1: str, column2: str): method take (line 661) | def take(*args: Any, **kwargs: Any): method where_column (line 665) | def where_column(column1: str, column2: str): method where_date (line 677) | def where_date(column: str, date: Any): method or_where_date (line 688) | def or_where_date(column: str, date: Any): method where_exists (line 700) | def where_exists(value: Any): method where_from_builder (line 711) | def where_from_builder(builder: QueryBuilder): method where_has (line 725) | def where_has(relationship: str, callback: Any): method where_in (line 728) | def where_in(column: str, wheres: list = []): method where_like (line 742) | def where_like(column: str, value: str): method where_not_between (line 754) | def where_not_between(*args: Any, **kwargs: Any): method where_not_in (line 758) | def where_not_in(column: str, wheres: list = []): method where_not_like (line 772) | def where_not_like(column: str, value: str): method where_not_null (line 784) | def where_not_null(column: str): method where_null (line 795) | def where_null(column: str): method where_raw (line 806) | def where_raw(query: str, bindings: list = []): method without_global_scopes (line 820) | def without_global_scopes(): method where (line 823) | def where(column: str, *args: Any): method with_ (line 837) | def with_(*eagers: str): method with_count (line 840) | def with_count(relationship: str, callback: Any = None): FILE: src/masoniteorm/models/Pivot.py class Pivot (line 4) | class Pivot(Model): FILE: src/masoniteorm/observers/ObservesEvents.py class ObservesEvents (line 1) | class ObservesEvents: method observe_events (line 2) | def observe_events(self, model, event): method observe (line 11) | def observe(cls, observer): method without_events (line 18) | def without_events(cls): method with_events (line 24) | def with_events(cls): FILE: src/masoniteorm/pagination/BasePaginator.py class BasePaginator (line 4) | class BasePaginator: method __iter__ (line 5) | def __iter__(self): method to_json (line 9) | def to_json(self): FILE: src/masoniteorm/pagination/LengthAwarePaginator.py class LengthAwarePaginator (line 5) | class LengthAwarePaginator(BasePaginator): method __init__ (line 6) | def __init__(self, result, per_page, current_page, total, url=None): method serialize (line 17) | def serialize(self, *args, **kwargs): method has_more_pages (line 30) | def has_more_pages(self): FILE: src/masoniteorm/pagination/SimplePaginator.py class SimplePaginator (line 4) | class SimplePaginator(BasePaginator): method __init__ (line 5) | def __init__(self, result, per_page, current_page, url=None): method serialize (line 14) | def serialize(self, *args, **kwargs): method has_more_pages (line 25) | def has_more_pages(self): FILE: src/masoniteorm/providers/ORMProvider.py class ORMProvider (line 17) | class ORMProvider(Provider): method __init__ (line 21) | def __init__(self, application): method register (line 24) | def register(self): method boot (line 38) | def boot(self): FILE: src/masoniteorm/query/EagerRelation.py class EagerRelations (line 1) | class EagerRelations: method __init__ (line 2) | def __init__(self, relation=None): method register (line 9) | def register(self, *relations, callback=None): method get_eagers (line 29) | def get_eagers(self): FILE: src/masoniteorm/query/QueryBuilder.py class QueryBuilder (line 36) | class QueryBuilder(ObservesEvents): method __init__ (line 39) | def __init__( method _set_creates_related (line 120) | def _set_creates_related(self, fields: dict): method set_schema (line 124) | def set_schema(self, schema): method shared_lock (line 128) | def shared_lock(self): method lock_for_update (line 131) | def lock_for_update(self): method make_lock (line 134) | def make_lock(self, lock): method reset (line 138) | def reset(self): method get_connection_information (line 153) | def get_connection_information(self): method table (line 171) | def table(self, table, raw=False): method from_ (line 186) | def from_(self, table): method from_raw (line 197) | def from_raw(self, table): method table_raw (line 208) | def table_raw(self, query): method get_table_name (line 219) | def get_table_name(self): method get_connection (line 230) | def get_connection(self): method begin (line 241) | def begin(self): method begin_transaction (line 252) | def begin_transaction(self, *args, **kwargs): method get_schema_builder (line 255) | def get_schema_builder(self): method commit (line 258) | def commit(self): method rollback (line 269) | def rollback(self): method get_relation (line 281) | def get_relation(self, key): method set_scope (line 292) | def set_scope(self, name, callable): method set_global_scope (line 307) | def set_global_scope(self, name="", callable=None, action="select"): method without_global_scopes (line 328) | def without_global_scopes(self): method remove_global_scope (line 332) | def remove_global_scope(self, scope, action=None): method __getattr__ (line 350) | def __getattr__(self, attribute): method on (line 387) | def on(self, connection): method select (line 409) | def select(self, *args): method distinct (line 425) | def distinct(self, boolean=True): method add_select (line 434) | def add_select(self, alias, callable): method statement (line 445) | def statement(self, query, bindings=None): method select_raw (line 451) | def select_raw(self, query): method get_processor (line 460) | def get_processor(self): method bulk_create (line 463) | def bulk_create( method create (line 499) | def create( method hydrate (line 562) | def hydrate(self, result, relations=None): method delete (line 565) | def delete(self, column=None, value=None, query=False): method where (line 602) | def where(self, column, *args): method where_from_builder (line 632) | def where_from_builder(self, builder): method where_like (line 649) | def where_like(self, column, value): method where_not_like (line 663) | def where_not_like(self, column, value): method where_raw (line 677) | def where_raw(self, query: str, bindings=()): method or_where (line 694) | def or_where(self, column, *args): method where_exists (line 724) | def where_exists(self, value: "str|int|QueryBuilder"): method or_where_exists (line 750) | def or_where_exists(self, value: "str|int|QueryBuilder"): method where_not_exists (line 785) | def where_not_exists(self, value: "str|int|QueryBuilder"): method or_where_not_exists (line 812) | def or_where_not_exists(self, value: "str|int|QueryBuilder"): method having (line 848) | def having(self, column, equality="", value=""): method having_raw (line 864) | def having_raw(self, string): method where_null (line 876) | def where_null(self, column): method or_where_null (line 888) | def or_where_null(self, column): method chunk (line 900) | def chunk(self, chunk_amount): method where_not_null (line 905) | def where_not_null(self, column: str): method _get_date_string (line 917) | def _get_date_string(self, date): method where_date (line 925) | def where_date(self, column: str, date: "str|datetime"): method or_where_date (line 939) | def or_where_date(self, column: str, date: "str|datetime"): method between (line 958) | def between(self, column: str, low: int, high: int): method where_between (line 972) | def where_between(self, *args, **kwargs): method where_not_between (line 975) | def where_not_between(self, *args, **kwargs): method not_between (line 978) | def not_between(self, column: str, low: str, high: str): method where_in (line 992) | def where_in(self, column, wheres=None): method get_relation (line 1026) | def get_relation(self, relationship, builder=None): method has (line 1037) | def has(self, *relationships): method or_has (line 1054) | def or_has(self, *relationships): method doesnt_have (line 1081) | def doesnt_have(self, *relationships): method or_doesnt_have (line 1107) | def or_doesnt_have(self, *relationships): method where_has (line 1133) | def where_has(self, relationship, callback): method or_where_has (line 1157) | def or_where_has(self, relationship, callback): method where_doesnt_have (line 1181) | def where_doesnt_have(self, relationship, callback): method or_where_doesnt_have (line 1206) | def or_where_doesnt_have(self, relationship, callback): method with_count (line 1231) | def with_count(self, relationship, callback=None): method where_not_in (line 1237) | def where_not_in(self, column, wheres=None): method join (line 1260) | def join( method left_join (line 1287) | def left_join(self, table, column1=None, equality=None, column2=None): method right_join (line 1307) | def right_join(self, table, column1=None, equality=None, column2=None): method joins (line 1327) | def joins(self, *relationships, clause="inner"): method join_on (line 1333) | def join_on(self, relationship, callback=None, clause="inner"): method where_column (line 1344) | def where_column(self, column1, column2): method take (line 1357) | def take(self, *args, **kwargs): method limit (line 1361) | def limit(self, amount): method offset (line 1373) | def offset(self, amount): method skip (line 1385) | def skip(self, *args, **kwargs): method update (line 1389) | def update( method force_update (line 1474) | def force_update(self, updates: dict, dry=False): method set_updates (line 1477) | def set_updates(self, updates: dict, dry=False): method increment (line 1492) | def increment(self, column, value=1, dry=False): method decrement (line 1534) | def decrement(self, column, value=1, dry=False): method sum (line 1576) | def sum(self, column): method count (line 1588) | def count(self, column=None, dry=False): method max (line 1623) | def max(self, column): method order_by (line 1635) | def order_by(self, column, direction="ASC"): method order_by_raw (line 1651) | def order_by_raw(self, query, bindings=None): method group_by (line 1668) | def group_by(self, column): method group_by_raw (line 1682) | def group_by_raw(self, query, bindings=None): method aggregate (line 1699) | def aggregate(self, aggregate, column, alias=None): method first (line 1710) | def first(self, fields=None, query=False): method first_or_create (line 1729) | def first_or_create(self, wheres, creates: dict = None): method sole (line 1755) | def sole(self, query=False): method sole_value (line 1768) | def sole_value(self, column: str, query=False): method first_where (line 1771) | def first_where(self, column, *args): method last (line 1777) | def last(self, column=None, query=False): method _get_eager_load_result (line 1798) | def _get_eager_load_result(self, related, collection): method find (line 1801) | def find(self, record_id, column=None, query=False): method find_or (line 1826) | def find_or(self, record_id: int, callback: Callable, args=None, colum... method find_or_fail (line 1850) | def find_or_fail(self, record_id, column=None): method find_or_404 (line 1867) | def find_or_404(self, record_id, column=None): method first_or_fail (line 1882) | def first_or_fail(self, query=False): method get_primary_key (line 1899) | def get_primary_key(self): method prepare_result (line 1902) | def prepare_result(self, result, collection=False): method _register_relationships_to_model (line 1958) | def _register_relationships_to_model( method _map_related (line 1984) | def _map_related(self, related_result, related): method all (line 1987) | def all(self, selects=[], query=False): method get (line 2003) | def get(self, selects=[]): method new_connection (line 2014) | def new_connection(self): method get_connection (line 2027) | def get_connection(self): method without_eager (line 2030) | def without_eager(self): method with_ (line 2034) | def with_(self, *eagers): method paginate (line 2038) | def paginate(self, per_page, page=1): method simple_paginate (line 2054) | def simple_paginate(self, per_page, page=1): method set_action (line 2065) | def set_action(self, action): method get_grammar (line 2077) | def get_grammar(self): method to_sql (line 2106) | def to_sql(self): method explain (line 2118) | def explain(self): method run_scopes (line 2128) | def run_scopes(self): method to_qmark (line 2134) | def to_qmark(self): method new (line 2151) | def new(self): method avg (line 2170) | def avg(self, column): method min (line 2182) | def min(self, column): method _extract_operator_value (line 2194) | def _extract_operator_value(self, *args): method __call__ (line 2227) | def __call__(self): method macro (line 2235) | def macro(self, name, callable): method when (line 2239) | def when(self, conditional, callback): method truncate (line 2244) | def truncate(self, foreign_keys=False, dry=False): method exists (line 2252) | def exists(self): method doesnt_exist (line 2263) | def doesnt_exist(self): method in_random_order (line 2274) | def in_random_order(self): method new_from_builder (line 2278) | def new_from_builder(self, from_builder=None): method get_table_columns (line 2313) | def get_table_columns(self): method get_schema (line 2316) | def get_schema(self): method latest (line 2321) | def latest(self, *fields): method oldest (line 2333) | def oldest(self, *fields): method value (line 2345) | def value(self, column: str): FILE: src/masoniteorm/query/grammars/BaseGrammar.py class BaseGrammar (line 12) | class BaseGrammar: method __init__ (line 23) | def __init__( method compile (line 66) | def compile(self, action, qmark=False): method _compile_select (line 70) | def _compile_select(self, qmark=False): method _compile_update (line 119) | def _compile_update(self, qmark=False): method _compile_insert (line 136) | def _compile_insert(self, qmark=False): method _compile_bulk_create (line 151) | def _compile_bulk_create(self, qmark=False): method columnize_bulk_columns (line 167) | def columnize_bulk_columns(self, columns=[]): method columnize_bulk_values (line 172) | def columnize_bulk_values(self, columns=[], qmark=False): method process_value_string (line 201) | def process_value_string(self): method _compile_delete (line 204) | def _compile_delete(self, qmark=False): method _get_multiple_columns (line 219) | def _get_multiple_columns(self, columns): method process_joins (line 236) | def process_joins(self, qmark=False): method _compile_key_value_equals (line 283) | def _compile_key_value_equals(self, qmark=False): method process_aggregates (line 332) | def process_aggregates(self): method process_order_by (line 359) | def process_order_by(self): method process_group_by (line 398) | def process_group_by(self): method process_alias (line 422) | def process_alias(self, column): method process_table (line 433) | def process_table(self, table): method process_limit (line 467) | def process_limit(self): method process_offset (line 478) | def process_offset(self): method process_locks (line 489) | def process_locks(self): method process_having (line 492) | def process_having(self, qmark=False): method process_wheres (line 521) | def process_wheres(self, qmark=False, strip_first_where=False): method get_true_column_string (line 705) | def get_true_column_string(self): method get_false_column_string (line 708) | def get_false_column_string(self): method add_binding (line 711) | def add_binding(self, *bindings): method column_exists (line 719) | def column_exists(self, column): method table_exists (line 732) | def table_exists(self): method wrap_table (line 745) | def wrap_table(self, table_name): method process_exists (line 748) | def process_exists(self): method to_sql (line 760) | def to_sql(self): method to_qmark (line 768) | def to_qmark(self): method process_columns (line 777) | def process_columns(self, separator="", action="select", qmark=False): method process_values (line 818) | def process_values(self, separator="", qmark=False): method process_column (line 851) | def process_column(self, column, separator=""): method _table_column_string (line 870) | def _table_column_string(self, column, alias=None, separator=""): method _compile_value (line 902) | def _compile_value(self, value, separator=""): method drop_table (line 916) | def drop_table(self, table): method drop_table_if_exists (line 928) | def drop_table_if_exists(self, table): method rename_table (line 942) | def rename_table(self, current_table_name, new_table_name): method truncate_table (line 958) | def truncate_table(self, table, foreign_keys=False): method where_regexp_string (line 971) | def where_regexp_string(self): method where_not_regexp_string (line 974) | def where_not_regexp_string(self): FILE: src/masoniteorm/query/grammars/MSSQLGrammar.py class MSSQLGrammar (line 4) | class MSSQLGrammar(BaseGrammar): method select_no_table (line 35) | def select_no_table(self): method select_format (line 38) | def select_format(self): method update_format (line 41) | def update_format(self): method insert_format (line 44) | def insert_format(self): method bulk_insert_format (line 47) | def bulk_insert_format(self): method delete_format (line 50) | def delete_format(self): method create_column_string (line 53) | def create_column_string(self): method create_start (line 56) | def create_start(self): method having_string (line 59) | def having_string(self): method where_exists_string (line 62) | def where_exists_string(self): method where_not_exists_string (line 65) | def where_not_exists_string(self): method where_like_string (line 68) | def where_like_string(self): method where_not_like_string (line 71) | def where_not_like_string(self): method where_date_string (line 74) | def where_date_string(self): method where_regexp_string (line 77) | def where_regexp_string(self): method where_not_regexp_string (line 80) | def where_not_regexp_string(self): method having_equality_string (line 83) | def having_equality_string(self): method aggregate_string_without_alias (line 86) | def aggregate_string_without_alias(self): method create_column_length (line 89) | def create_column_length(self): method limit_string (line 92) | def limit_string(self, offset=False): method first_where_string (line 97) | def first_where_string(self): method additional_where_string (line 100) | def additional_where_string(self): method join_string (line 103) | def join_string(self): method aggregate_string (line 106) | def aggregate_string(self): method subquery_string (line 109) | def subquery_string(self): method subquery_alias_string (line 112) | def subquery_alias_string(self): method where_group_string (line 115) | def where_group_string(self): method or_where_string (line 118) | def or_where_string(self): method raw_query_string (line 121) | def raw_query_string(self): method where_in_string (line 124) | def where_in_string(self): method value_equal_string (line 127) | def value_equal_string(self): method where_null_string (line 130) | def where_null_string(self): method between_string (line 133) | def between_string(self): method not_between_string (line 136) | def not_between_string(self): method where_not_null_string (line 139) | def where_not_null_string(self): method where_string (line 142) | def where_string(self): method offset_string (line 145) | def offset_string(self): method increment_string (line 148) | def increment_string(self): method decrement_string (line 151) | def decrement_string(self): method aggregate_string_with_alias (line 154) | def aggregate_string_with_alias(self): method key_value_string (line 157) | def key_value_string(self): method column_value_string (line 160) | def column_value_string(self): method table_string (line 163) | def table_string(self): method order_by_format (line 166) | def order_by_format(self): method order_by_string (line 169) | def order_by_string(self): method column_string (line 172) | def column_string(self): method table_column_string (line 175) | def table_column_string(self): method table_update_column_string (line 178) | def table_update_column_string(self): method table_insert_column_string (line 181) | def table_insert_column_string(self): method value_string (line 184) | def value_string(self): method wrap_table (line 187) | def wrap_table(self, table_name): method truncate_table (line 190) | def truncate_table(self, table, foreign_keys=False): method compile_random (line 193) | def compile_random(self, seed): FILE: src/masoniteorm/query/grammars/MySQLGrammar.py class MySQLGrammar (line 4) | class MySQLGrammar(BaseGrammar): method select_format (line 51) | def select_format(self): method select_no_table (line 54) | def select_no_table(self): method update_format (line 57) | def update_format(self): method insert_format (line 60) | def insert_format(self): method bulk_insert_format (line 63) | def bulk_insert_format(self): method delete_format (line 66) | def delete_format(self): method aggregate_string_with_alias (line 69) | def aggregate_string_with_alias(self): method aggregate_string_without_alias (line 72) | def aggregate_string_without_alias(self): method subquery_string (line 75) | def subquery_string(self): method raw_query_string (line 78) | def raw_query_string(self): method where_group_string (line 81) | def where_group_string(self): method between_string (line 84) | def between_string(self): method not_between_string (line 87) | def not_between_string(self): method where_exists_string (line 90) | def where_exists_string(self): method where_date_string (line 93) | def where_date_string(self): method where_not_exists_string (line 96) | def where_not_exists_string(self): method where_like_string (line 99) | def where_like_string(self): method where_not_like_string (line 102) | def where_not_like_string(self): method get_true_column_string (line 105) | def get_true_column_string(self): method get_false_column_string (line 108) | def get_false_column_string(self): method process_table (line 111) | def process_table(self, table): method subquery_alias_string (line 132) | def subquery_alias_string(self): method key_value_string (line 135) | def key_value_string(self): method column_value_string (line 138) | def column_value_string(self): method increment_string (line 141) | def increment_string(self): method decrement_string (line 144) | def decrement_string(self): method create_column_string (line 147) | def create_column_string(self): method column_exists_string (line 150) | def column_exists_string(self): method table_exists_string (line 153) | def table_exists_string(self): method create_column_length (line 156) | def create_column_length(self, column_type): method table_string (line 159) | def table_string(self): method order_by_format (line 162) | def order_by_format(self): method order_by_string (line 165) | def order_by_string(self): method column_string (line 168) | def column_string(self): method value_string (line 171) | def value_string(self): method join_string (line 174) | def join_string(self): method limit_string (line 177) | def limit_string(self, offset=False): method offset_string (line 180) | def offset_string(self): method first_where_string (line 183) | def first_where_string(self): method additional_where_string (line 186) | def additional_where_string(self): method or_where_string (line 189) | def or_where_string(self): method where_in_string (line 192) | def where_in_string(self): method value_equal_string (line 195) | def value_equal_string(self): method where_string (line 198) | def where_string(self): method having_string (line 201) | def having_string(self): method having_equality_string (line 204) | def having_equality_string(self): method where_null_string (line 207) | def where_null_string(self): method where_not_null_string (line 210) | def where_not_null_string(self): method enable_foreign_key_constraints (line 213) | def enable_foreign_key_constraints(self): method disable_foreign_key_constraints (line 216) | def disable_foreign_key_constraints(self): method truncate_table (line 219) | def truncate_table(self, table, foreign_keys=False): method compile_random (line 237) | def compile_random(self): FILE: src/masoniteorm/query/grammars/PostgresGrammar.py class PostgresGrammar (line 6) | class PostgresGrammar(BaseGrammar): method select_no_table (line 37) | def select_no_table(self): method select_format (line 40) | def select_format(self): method update_format (line 43) | def update_format(self): method insert_format (line 46) | def insert_format(self): method bulk_insert_format (line 49) | def bulk_insert_format(self): method delete_format (line 52) | def delete_format(self): method aggregate_string_with_alias (line 55) | def aggregate_string_with_alias(self): method aggregate_string_without_alias (line 58) | def aggregate_string_without_alias(self): method get_true_column_string (line 61) | def get_true_column_string(self): method get_false_column_string (line 64) | def get_false_column_string(self): method subquery_string (line 67) | def subquery_string(self): method raw_query_string (line 70) | def raw_query_string(self): method where_group_string (line 73) | def where_group_string(self): method between_string (line 76) | def between_string(self): method not_between_string (line 79) | def not_between_string(self): method where_exists_string (line 82) | def where_exists_string(self): method where_not_exists_string (line 85) | def where_not_exists_string(self): method where_like_string (line 88) | def where_like_string(self): method where_not_like_string (line 91) | def where_not_like_string(self): method subquery_alias_string (line 94) | def subquery_alias_string(self): method key_value_string (line 97) | def key_value_string(self): method column_value_string (line 100) | def column_value_string(self): method increment_string (line 103) | def increment_string(self): method decrement_string (line 106) | def decrement_string(self): method create_column_string (line 109) | def create_column_string(self): method column_exists_string (line 112) | def column_exists_string(self): method table_exists_string (line 115) | def table_exists_string(self): method create_column_length (line 120) | def create_column_length(self, column_type): method to_sql (line 125) | def to_sql(self): method table_string (line 146) | def table_string(self): method order_by_format (line 149) | def order_by_format(self): method order_by_string (line 152) | def order_by_string(self): method column_string (line 155) | def column_string(self): method value_string (line 158) | def value_string(self): method join_string (line 161) | def join_string(self): method limit_string (line 164) | def limit_string(self, offset=False): method offset_string (line 167) | def offset_string(self): method first_where_string (line 170) | def first_where_string(self): method additional_where_string (line 173) | def additional_where_string(self): method or_where_string (line 176) | def or_where_string(self): method where_in_string (line 179) | def where_in_string(self): method where_date_string (line 182) | def where_date_string(self): method value_equal_string (line 185) | def value_equal_string(self): method where_string (line 188) | def where_string(self): method having_string (line 191) | def having_string(self): method having_equality_string (line 194) | def having_equality_string(self): method where_null_string (line 197) | def where_null_string(self): method where_not_null_string (line 200) | def where_not_null_string(self): method truncate_table (line 203) | def truncate_table(self, table, foreign_keys=False): method compile_random (line 214) | def compile_random(self): FILE: src/masoniteorm/query/grammars/SQLiteGrammar.py class SQLiteGrammar (line 6) | class SQLiteGrammar(BaseGrammar): method select_format (line 37) | def select_format(self): method select_no_table (line 40) | def select_no_table(self): method update_format (line 43) | def update_format(self): method insert_format (line 46) | def insert_format(self): method bulk_insert_format (line 49) | def bulk_insert_format(self): method delete_format (line 52) | def delete_format(self): method aggregate_string_with_alias (line 55) | def aggregate_string_with_alias(self): method aggregate_string_without_alias (line 58) | def aggregate_string_without_alias(self): method subquery_string (line 61) | def subquery_string(self): method default_string (line 64) | def default_string(self): method raw_query_string (line 67) | def raw_query_string(self): method where_group_string (line 70) | def where_group_string(self): method between_string (line 73) | def between_string(self): method not_between_string (line 76) | def not_between_string(self): method where_exists_string (line 79) | def where_exists_string(self): method where_not_exists_string (line 82) | def where_not_exists_string(self): method where_like_string (line 85) | def where_like_string(self): method where_not_like_string (line 88) | def where_not_like_string(self): method subquery_alias_string (line 91) | def subquery_alias_string(self): method key_value_string (line 94) | def key_value_string(self): method column_value_string (line 97) | def column_value_string(self): method increment_string (line 100) | def increment_string(self): method decrement_string (line 103) | def decrement_string(self): method column_exists_string (line 106) | def column_exists_string(self): method table_exists_string (line 109) | def table_exists_string(self): method to_sql (line 114) | def to_sql(self): method table_string (line 135) | def table_string(self): method order_by_format (line 138) | def order_by_format(self): method order_by_string (line 141) | def order_by_string(self): method column_string (line 144) | def column_string(self): method value_string (line 147) | def value_string(self): method join_string (line 150) | def join_string(self): method limit_string (line 153) | def limit_string(self, offset=False): method offset_string (line 158) | def offset_string(self): method first_where_string (line 161) | def first_where_string(self): method additional_where_string (line 164) | def additional_where_string(self): method or_where_string (line 167) | def or_where_string(self): method where_in_string (line 170) | def where_in_string(self): method where_string (line 173) | def where_string(self): method having_string (line 176) | def having_string(self): method having_equality_string (line 179) | def having_equality_string(self): method where_null_string (line 182) | def where_null_string(self): method where_date_string (line 185) | def where_date_string(self): method value_equal_string (line 188) | def value_equal_string(self): method where_not_null_string (line 191) | def where_not_null_string(self): method enable_foreign_key_constraints (line 194) | def enable_foreign_key_constraints(self): method disable_foreign_key_constraints (line 197) | def disable_foreign_key_constraints(self): method get_true_column_string (line 200) | def get_true_column_string(self): method get_false_column_string (line 203) | def get_false_column_string(self): method truncate_table (line 206) | def truncate_table(self, table, foreign_keys=False): method compile_random (line 218) | def compile_random(self): method process_offset (line 221) | def process_offset(self): FILE: src/masoniteorm/query/processors/MSSQLPostProcessor.py class MSSQLPostProcessor (line 1) | class MSSQLPostProcessor: method process_insert_get_id (line 14) | def process_insert_get_id(self, builder, results, id_key): method get_column_value (line 41) | def get_column_value(self, builder, column, results, id_key, id_value): FILE: src/masoniteorm/query/processors/MySQLPostProcessor.py class MySQLPostProcessor (line 1) | class MySQLPostProcessor: method process_insert_get_id (line 12) | def process_insert_get_id(self, builder, results, id_key): method get_column_value (line 29) | def get_column_value(self, builder, column, results, id_key, id_value): FILE: src/masoniteorm/query/processors/PostgresPostProcessor.py class PostgresPostProcessor (line 1) | class PostgresPostProcessor: method process_insert_get_id (line 14) | def process_insert_get_id(self, builder, results, id_key): method get_column_value (line 29) | def get_column_value(self, builder, column, results, id_key, id_value): FILE: src/masoniteorm/query/processors/SQLitePostProcessor.py class SQLitePostProcessor (line 1) | class SQLitePostProcessor: method process_insert_get_id (line 12) | def process_insert_get_id(self, builder, results, id_key="id"): method get_column_value (line 30) | def get_column_value(self, builder, column, results, id_key, id_value): FILE: src/masoniteorm/relationships/BaseRelationship.py class BaseRelationship (line 1) | class BaseRelationship: method __init__ (line 2) | def __init__(self, fn, local_key=None, foreign_key=None): method __set_name__ (line 12) | def __set_name__(self, cls, name): method __call__ (line 22) | def __call__(self, fn=None, *args, **kwargs): method get_builder (line 36) | def get_builder(self): method __get__ (line 39) | def __get__(self, instance, owner): method __getattr__ (line 65) | def __getattr__(self, attribute): method apply_query (line 69) | def apply_query(self, foreign, owner): method query_where_exists (line 84) | def query_where_exists(self, builder, callback, method="where_exists"): method joins (line 91) | def joins(self, builder, clause=None): method get_with_count_query (line 103) | def get_with_count_query(self, builder, callback): method attach (line 110) | def attach(self, current_model, related_record): method get_related (line 117) | def get_related(self, query, relation, eagers=None, callback=None): method relate (line 123) | def relate(self, related_record): method detach (line 129) | def detach(self, current_model, related_record): method attach_related (line 136) | def attach_related(self, current_model, related_record): method detach_related (line 143) | def detach_related(self, current_model, related_record): method query_has (line 150) | def query_has(self, current_query_builder, method="where_exists"): method map_related (line 157) | def map_related(self, related_result): FILE: src/masoniteorm/relationships/BelongsTo.py class BelongsTo (line 5) | class BelongsTo(BaseRelationship): method __init__ (line 8) | def __init__(self, fn, local_key=None, foreign_key=None): method set_keys (line 18) | def set_keys(self, owner, attribute): method apply_query (line 23) | def apply_query(self, foreign, owner): method query_has (line 37) | def query_has(self, current_query_builder, method="where_exists"): method query_where_exists (line 49) | def query_where_exists(self, builder, callback, method="where_exists"): method get_related (line 61) | def get_related(self, query, relation, eagers=(), callback=None): method register_related (line 89) | def register_related(self, key, model, collection): method map_related (line 94) | def map_related(self, related_result): method attach (line 97) | def attach(self, current_model, related_record): method detach (line 105) | def detach(self, current_model, related_record): method relate (line 108) | def relate(self, related_record): FILE: src/masoniteorm/relationships/BelongsToMany.py class BelongsToMany (line 9) | class BelongsToMany(BaseRelationship): method __init__ (line 12) | def __init__( method set_keys (line 44) | def set_keys(self, owner, attribute): method apply_query (line 49) | def apply_query(self, query, owner): method table (line 156) | def table(self, table): method make_builder (line 160) | def make_builder(self, eagers=None): method make_query (line 165) | def make_query(self, query, relation, eagers=None, callback=None): method get_related (line 248) | def get_related(self, query, relation, eagers=None, callback=None): method relate (line 292) | def relate(self, related_record): method register_related (line 352) | def register_related(self, key, model, collection): method joins (line 361) | def joins(self, builder, clause=None): method query_where_exists (line 423) | def query_where_exists(self, builder, callback, method="where_exists"): method query_has (line 446) | def query_has(self, builder, method="where_exists"): method get_pivot_table_name (line 465) | def get_pivot_table_name(self, query, builder): method get_with_count_query (line 473) | def get_with_count_query(self, builder, callback): method attach (line 505) | def attach(self, current_model, related_record): method detach (line 530) | def detach(self, current_model, related_record): method attach_related (line 548) | def attach_related(self, current_model, related_record): method detach_related (line 573) | def detach_related(self, current_model, related_record): FILE: src/masoniteorm/relationships/HasMany.py class HasMany (line 5) | class HasMany(BaseRelationship): method apply_query (line 8) | def apply_query(self, foreign, owner): method set_keys (line 24) | def set_keys(self, owner, attribute): method register_related (line 29) | def register_related(self, key, model, collection): method map_related (line 34) | def map_related(self, related_result): method attach (line 37) | def attach(self, current_model, related_record): method get_related (line 45) | def get_related(self, query, relation, eagers=None, callback=None): FILE: src/masoniteorm/relationships/HasManyThrough.py class HasManyThrough (line 5) | class HasManyThrough(BaseRelationship): method __init__ (line 8) | def __init__( method set_keys (line 29) | def set_keys(self, distant_builder, intermediary_builder, attribute): method __get__ (line 36) | def __get__(self, instance, owner): method apply_related_query (line 66) | def apply_related_query(self, distant_builder, intermediary_builder, o... method relate (line 102) | def relate(self, related_model): method get_builder (line 113) | def get_builder(self): method make_builder (line 116) | def make_builder(self, eagers=None): method register_related (line 121) | def register_related(self, key, model, collection): method get_related (line 139) | def get_related(self, current_builder, relation, eagers=None, callback... method query_has (line 182) | def query_has(self, current_builder, method="where_exists"): method query_where_exists (line 200) | def query_where_exists(self, current_builder, callback, method="where_... method get_with_count_query (line 218) | def get_with_count_query(self, current_builder, callback): method map_related (line 258) | def map_related(self, related_result): FILE: src/masoniteorm/relationships/HasOne.py class HasOne (line 5) | class HasOne(BaseRelationship): method __init__ (line 8) | def __init__(self, fn, foreign_key=None, local_key=None): method set_keys (line 17) | def set_keys(self, owner, attribute): method apply_query (line 22) | def apply_query(self, foreign, owner): method get_related (line 37) | def get_related(self, query, relation, eagers=(), callback=None): method query_has (line 65) | def query_has(self, current_query_builder, method="where_exists"): method query_where_exists (line 77) | def query_where_exists(self, builder, callback, method="where_exists"): method register_related (line 89) | def register_related(self, key, model, collection): method map_related (line 96) | def map_related(self, related_result): method attach (line 99) | def attach(self, current_model, related_record): method detach (line 107) | def detach(self, current_model, related_record): FILE: src/masoniteorm/relationships/HasOneThrough.py class HasOneThrough (line 5) | class HasOneThrough(BaseRelationship): method __init__ (line 8) | def __init__( method __getattr__ (line 29) | def __getattr__(self, attribute): method set_keys (line 33) | def set_keys(self, distant_builder, intermediary_builder, attribute): method __get__ (line 40) | def __get__(self, instance, owner): method apply_relation_query (line 71) | def apply_relation_query(self, distant_builder, intermediary_builder, ... method relate (line 107) | def relate(self, related_model): method get_builder (line 121) | def get_builder(self): method make_builder (line 124) | def make_builder(self, eagers=None): method register_related (line 129) | def register_related(self, key, model, collection): method get_related (line 145) | def get_related(self, current_builder, relation, eagers=None, callback... method query_has (line 188) | def query_has(self, current_builder, method="where_exists"): method query_where_exists (line 206) | def query_where_exists(self, current_builder, callback, method="where_... method get_with_count_query (line 224) | def get_with_count_query(self, current_builder, callback): method map_related (line 264) | def map_related(self, related_result): FILE: src/masoniteorm/relationships/MorphMany.py class MorphMany (line 6) | class MorphMany(BaseRelationship): method __init__ (line 7) | def __init__(self, fn, morph_key="record_type", morph_id="record_id"): method get_builder (line 17) | def get_builder(self): method set_keys (line 20) | def set_keys(self, owner, attribute): method __get__ (line 25) | def __get__(self, instance, owner): method __getattr__ (line 50) | def __getattr__(self, attribute): method apply_query (line 54) | def apply_query(self, builder, instance): method get_related (line 72) | def get_related(self, query, relation, eagers=None, callback=None): method register_related (line 128) | def register_related(self, key, model, collection): method morph_map (line 136) | def morph_map(self): method get_record_key_lookup (line 139) | def get_record_key_lookup(self, relation): FILE: src/masoniteorm/relationships/MorphOne.py class MorphOne (line 6) | class MorphOne(BaseRelationship): method __init__ (line 7) | def __init__(self, fn, morph_key="record_type", morph_id="record_id"): method get_builder (line 17) | def get_builder(self): method set_keys (line 20) | def set_keys(self, owner, attribute): method __get__ (line 25) | def __get__(self, instance, owner): method __getattr__ (line 50) | def __getattr__(self, attribute): method apply_query (line 54) | def apply_query(self, builder, instance): method get_related (line 73) | def get_related(self, query, relation, eagers=None, callback=None): method register_related (line 130) | def register_related(self, key, model, collection): method morph_map (line 140) | def morph_map(self): method get_record_key_lookup (line 143) | def get_record_key_lookup(self, relation): FILE: src/masoniteorm/relationships/MorphTo.py class MorphTo (line 6) | class MorphTo(BaseRelationship): method __init__ (line 7) | def __init__(self, fn, morph_key="record_type", morph_id="record_id"): method get_builder (line 17) | def get_builder(self): method set_keys (line 20) | def set_keys(self, owner, attribute): method __get__ (line 25) | def __get__(self, instance, owner): method __getattr__ (line 49) | def __getattr__(self, attribute): method apply_query (line 53) | def apply_query(self, builder, instance): method get_related (line 68) | def get_related(self, query, relation, eagers=None, callback=None): method register_related (line 98) | def register_related(self, key, model, collection): method morph_map (line 107) | def morph_map(self): method map_related (line 110) | def map_related(self, related_result): FILE: src/masoniteorm/relationships/MorphToMany.py class MorphToMany (line 6) | class MorphToMany(BaseRelationship): method __init__ (line 7) | def __init__(self, fn, morph_key="record_type", morph_id="record_id"): method get_builder (line 17) | def get_builder(self): method set_keys (line 20) | def set_keys(self, owner, attribute): method __get__ (line 25) | def __get__(self, instance, owner): method __getattr__ (line 49) | def __getattr__(self, attribute): method apply_query (line 53) | def apply_query(self, builder, instance): method get_related (line 68) | def get_related(self, query, relation, eagers=None, callback=None): method register_related (line 98) | def register_related(self, key, model, collection): method morph_map (line 107) | def morph_map(self): FILE: src/masoniteorm/schema/Blueprint.py class Blueprint (line 1) | class Blueprint: method __init__ (line 4) | def __init__( method string (line 27) | def string(self, column, length=255, nullable=False): method tiny_integer (line 46) | def tiny_integer(self, column, length=1, nullable=False): method small_integer (line 64) | def small_integer(self, column, length=5, nullable=False): method medium_integer (line 82) | def medium_integer(self, column, length=7, nullable=False): method integer (line 100) | def integer(self, column, length=11, nullable=False): method big_integer (line 118) | def big_integer(self, column, length=32, nullable=False): method unsigned_big_integer (line 136) | def unsigned_big_integer(self, column, length=32, nullable=False): method _compile_create (line 151) | def _compile_create(self): method _compile_alter (line 154) | def _compile_alter(self): method increments (line 157) | def increments(self, column, nullable=False): method tiny_increments (line 176) | def tiny_increments(self, column, nullable=False): method id (line 195) | def id(self, column="id"): method uuid (line 206) | def uuid(self, column, nullable=False, length=36): method big_increments (line 223) | def big_increments(self, column, nullable=False): method binary (line 242) | def binary(self, column, nullable=False): method boolean (line 257) | def boolean(self, column, nullable=False): method default (line 272) | def default(self, value, raw=False): method default_raw (line 277) | def default_raw(self, value): method char (line 281) | def char(self, column, length=1, nullable=False): method date (line 299) | def date(self, column, nullable=False): method time (line 314) | def time(self, column, nullable=False): method datetime (line 329) | def datetime(self, column, nullable=False, now=False): method timestamp (line 350) | def timestamp(self, column, nullable=False, now=False): method timestamps (line 373) | def timestamps(self): method decimal (line 385) | def decimal(self, column, length=17, precision=6, nullable=False): method float (line 408) | def float(self, column, length=19, precision=4, nullable=False): method double (line 430) | def double(self, column, nullable=False): method enum (line 445) | def enum(self, column, options=None, nullable=False): method text (line 469) | def text(self, column, length=None, nullable=False): method tiny_text (line 487) | def tiny_text(self, column, length=None, nullable=False): method unsigned_decimal (line 505) | def unsigned_decimal(self, column, length=17, precision=6, nullable=Fa... method long_text (line 527) | def long_text(self, column, length=None, nullable=False): method json (line 545) | def json(self, column, nullable=False): method jsonb (line 560) | def jsonb(self, column, nullable=False): method inet (line 575) | def inet(self, column, length=255, nullable=False): method cidr (line 592) | def cidr(self, column, length=255, nullable=False): method macaddr (line 609) | def macaddr(self, column, length=255, nullable=False): method point (line 626) | def point(self, column, nullable=False): method geometry (line 641) | def geometry(self, column, nullable=False): method year (line 656) | def year(self, column, length=4, default=None, nullable=False): method unsigned (line 673) | def unsigned(self, column=None, length=None, nullable=False): method unsigned_integer (line 695) | def unsigned_integer(self, column, nullable=False): method morphs (line 712) | def morphs(self, column, nullable=False, indexes=True): method to_sql (line 746) | def to_sql(self): method __enter__ (line 766) | def __enter__(self): method __exit__ (line 769) | def __exit__(self, exc_type, exc_value, exc_traceback): method nullable (line 774) | def nullable(self): method soft_deletes (line 788) | def soft_deletes(self, name="deleted_at"): method unique (line 791) | def unique(self, column=None, name=None): method index (line 816) | def index(self, column=None, name=None): method fulltext (line 837) | def fulltext(self, column=None, name=None): method primary (line 858) | def primary(self, column=None, name=None): method add_foreign (line 882) | def add_foreign(self, columns, name=None): method foreign (line 896) | def foreign(self, column, name=None): method foreign_id (line 910) | def foreign_id(self, column): method foreign_uuid (line 921) | def foreign_uuid(self, column): method foreign_id_for (line 932) | def foreign_id_for(self, model, column=None): method references (line 949) | def references(self, column): method on (line 961) | def on(self, table): method on_delete (line 973) | def on_delete(self, action): method on_update (line 985) | def on_update(self, action): method comment (line 997) | def comment(self, comment): method table_comment (line 1001) | def table_comment(self, comment): method rename (line 1005) | def rename(self, old_column, new_column, data_type, length=None): method after (line 1018) | def after(self, old_column): method drop_column (line 1032) | def drop_column(self, *columns): method drop_index (line 1043) | def drop_index(self, index): method change (line 1062) | def change(self): method drop_unique (line 1066) | def drop_unique(self, index): method drop_primary (line 1083) | def drop_primary(self, index): method drop_foreign (line 1100) | def drop_foreign(self, index): FILE: src/masoniteorm/schema/Column.py class Column (line 1) | class Column: method __init__ (line 4) | def __init__( method nullable (line 30) | def nullable(self): method signed (line 39) | def signed(self): method unsigned (line 48) | def unsigned(self): method not_nullable (line 57) | def not_nullable(self): method set_as_primary (line 66) | def set_as_primary(self): method rename (line 69) | def rename(self, column): method after (line 81) | def after(self, after): method get_after_column (line 95) | def get_after_column(self): method default (line 108) | def default(self, value, raw=False): method change (line 122) | def change(self): method use_current (line 131) | def use_current(self): method add_comment (line 142) | def add_comment(self, comment): FILE: src/masoniteorm/schema/Constraint.py class Constraint (line 1) | class Constraint: method __init__ (line 2) | def __init__(self, name, constraint_type, columns=None): FILE: src/masoniteorm/schema/ForeignKeyConstraint.py class ForeignKeyConstraint (line 1) | class ForeignKeyConstraint: method __init__ (line 2) | def __init__(self, column, foreign_table, foreign_column, name=None): method references (line 10) | def references(self, foreign_column): method on (line 14) | def on(self, foreign_table): method on_delete (line 18) | def on_delete(self, action): method on_update (line 22) | def on_update(self, action): method name (line 26) | def name(self, name): FILE: src/masoniteorm/schema/Index.py class Index (line 1) | class Index: method __init__ (line 2) | def __init__(self, column, name, index_type): FILE: src/masoniteorm/schema/Schema.py class Schema (line 8) | class Schema: method __init__ (line 51) | def __init__( method on (line 80) | def on(self, connection_key): method dry (line 110) | def dry(self): method create (line 119) | def create(self, table): method create_table_if_not_exists (line 145) | def create_table_if_not_exists(self, table): method table (line 161) | def table(self, table): method get_connection_information (line 187) | def get_connection_information(self): method new_connection (line 205) | def new_connection(self): method has_column (line 217) | def has_column(self, table, column, query_only=False): method get_columns (line 234) | def get_columns(self, table, dict=True): method set_default_string_length (line 247) | def set_default_string_length(cls, length): method drop_table (line 251) | def drop_table(self, table, query_only=False): method drop (line 260) | def drop(self, *args, **kwargs): method drop_table_if_exists (line 263) | def drop_table_if_exists(self, table, exists=False, query_only=False): method rename (line 272) | def rename(self, table, new_name): method truncate (line 281) | def truncate(self, table, foreign_keys=False): method get_schema (line 290) | def get_schema(self): method get_all_tables (line 296) | def get_all_tables(self): method has_table (line 311) | def has_table(self, table, query_only=False): method enable_foreign_key_constraints (line 330) | def enable_foreign_key_constraints(self): method disable_foreign_key_constraints (line 339) | def disable_foreign_key_constraints(self): FILE: src/masoniteorm/schema/Table.py class Table (line 7) | class Table: method __init__ (line 8) | def __init__(self, table): method add_column (line 20) | def add_column( method add_constraint (line 49) | def add_constraint(self, name, constraint_type, columns=None): method add_foreign_key (line 54) | def add_foreign_key(self, column, table=None, foreign_column=None, nam... method get_added_foreign_keys (line 62) | def get_added_foreign_keys(self): method get_constraint (line 65) | def get_constraint(self, name): method get_added_constraints (line 68) | def get_added_constraints(self): method get_added_columns (line 71) | def get_added_columns(self): method get_renamed_columns (line 74) | def get_renamed_columns(self): method set_primary_key (line 77) | def set_primary_key(self, columns): method add_index (line 81) | def add_index(self, column, name, index_type): method get_index (line 84) | def get_index(self, name): method add_comment (line 87) | def add_comment(self, comment): FILE: src/masoniteorm/schema/TableDiff.py class TableDiff (line 5) | class TableDiff(Table): method __init__ (line 6) | def __init__(self, name): method remove_constraint (line 24) | def remove_constraint(self, name): method get_removed_constraints (line 27) | def get_removed_constraints(self): method get_renamed_columns (line 30) | def get_renamed_columns(self): method rename_column (line 33) | def rename_column( method remove_index (line 54) | def remove_index(self, name): method remove_unique_index (line 57) | def remove_unique_index(self, name): method drop_column (line 60) | def drop_column(self, name): method get_dropped_columns (line 63) | def get_dropped_columns(self): method get_dropped_foreign_keys (line 66) | def get_dropped_foreign_keys(self): method drop_foreign (line 69) | def drop_foreign(self, name): method drop_primary (line 73) | def drop_primary(self, name): method change_column (line 77) | def change_column(self, added_column): method add_comment (line 82) | def add_comment(self, comment): FILE: src/masoniteorm/schema/platforms/MSSQLPlatform.py class MSSQLPlatform (line 5) | class MSSQLPlatform(Platform): method compile_create_sql (line 64) | def compile_create_sql(self, table, if_not_exists=False): method compile_alter_sql (line 108) | def compile_alter_sql(self, table): method add_column_string (line 218) | def add_column_string(self): method drop_column_string (line 221) | def drop_column_string(self): method rename_column_string (line 224) | def rename_column_string(self, table, old, new): method columnize (line 227) | def columnize(self, columns): method columnize_string (line 276) | def columnize_string(self): method constraintize (line 279) | def constraintize(self, constraints, table): method get_table_string (line 295) | def get_table_string(self): method get_column_string (line 298) | def get_column_string(self): method create_format (line 301) | def create_format(self): method create_if_not_exists_format (line 304) | def create_if_not_exists_format(self): method alter_format (line 309) | def alter_format(self): method get_foreign_key_constraint_string (line 312) | def get_foreign_key_constraint_string(self): method get_primary_key_constraint_string (line 315) | def get_primary_key_constraint_string(self): method get_unique_constraint_string (line 318) | def get_unique_constraint_string(self): method compile_table_exists (line 321) | def compile_table_exists(self, table, database=None, schema=None): method compile_truncate (line 324) | def compile_truncate(self, table, foreign_keys=False): method compile_rename_table (line 334) | def compile_rename_table(self, current_name, new_name): method compile_drop_table_if_exists (line 337) | def compile_drop_table_if_exists(self, table): method compile_drop_table (line 340) | def compile_drop_table(self, table): method compile_column_exists (line 343) | def compile_column_exists(self, table, column): method compile_get_all_tables (line 346) | def compile_get_all_tables(self, database, schema=None): method get_current_schema (line 349) | def get_current_schema(self, connection, table_name, schema=None): method enable_foreign_key_constraints (line 352) | def enable_foreign_key_constraints(self): method disable_foreign_key_constraints (line 356) | def disable_foreign_key_constraints(self): FILE: src/masoniteorm/schema/platforms/MySQLPlatform.py class MySQLPlatform (line 7) | class MySQLPlatform(Platform): method columnize (line 61) | def columnize(self, columns): method compile_create_sql (line 115) | def compile_create_sql(self, table, if_not_exists=False): method compile_alter_sql (line 160) | def compile_alter_sql(self, table): method add_column_string (line 353) | def add_column_string(self): method drop_column_string (line 356) | def drop_column_string(self): method change_column_string (line 359) | def change_column_string(self): method rename_column_string (line 362) | def rename_column_string(self): method columnize_string (line 365) | def columnize_string(self): method constraintize (line 368) | def constraintize(self, constraints, table): method get_table_string (line 384) | def get_table_string(self): method get_column_string (line 387) | def get_column_string(self): method create_format (line 390) | def create_format(self): method create_if_not_exists_format (line 393) | def create_if_not_exists_format(self): method alter_format (line 396) | def alter_format(self): method get_foreign_key_constraint_string (line 399) | def get_foreign_key_constraint_string(self): method get_primary_key_constraint_string (line 402) | def get_primary_key_constraint_string(self): method get_unique_constraint_string (line 405) | def get_unique_constraint_string(self): method compile_table_exists (line 408) | def compile_table_exists(self, table, database=None, schema=None): method compile_truncate (line 411) | def compile_truncate(self, table, foreign_keys=False): method compile_rename_table (line 421) | def compile_rename_table(self, current_name, new_name): method compile_drop_table_if_exists (line 424) | def compile_drop_table_if_exists(self, table): method compile_drop_table (line 427) | def compile_drop_table(self, table): method compile_column_exists (line 430) | def compile_column_exists(self, table, column): method compile_get_all_tables (line 433) | def compile_get_all_tables(self, database, schema=None): method get_current_schema (line 436) | def get_current_schema(self, connection, table_name, schema=None): method get_column_type (line 458) | def get_column_type(self, reversed_type_map, column_type): method get_column_length (line 477) | def get_column_length(self, raw_column_type): method enable_foreign_key_constraints (line 489) | def enable_foreign_key_constraints(self): method disable_foreign_key_constraints (line 492) | def disable_foreign_key_constraints(self): FILE: src/masoniteorm/schema/platforms/Platform.py class Platform (line 1) | class Platform: method columnize (line 13) | def columnize(self, columns): method columnize_string (line 50) | def columnize_string(self): method create_column_length (line 53) | def create_column_length(self, column_type): method foreign_key_constraintize (line 58) | def foreign_key_constraintize(self, table, foreign_keys): method constraintize (line 78) | def constraintize(self, constraints): method wrap_table (line 88) | def wrap_table(self, table_name): method wrap_column (line 91) | def wrap_column(self, column_name): FILE: src/masoniteorm/schema/platforms/PostgresPlatform.py class PostgresPlatform (line 6) | class PostgresPlatform(Platform): method compile_create_sql (line 76) | def compile_create_sql(self, table, if_not_exists=False): method columnize (line 129) | def columnize(self, columns): method compile_alter_sql (line 178) | def compile_alter_sql(self, table): method alter_format (line 400) | def alter_format(self): method alter_format_add_foreign_key (line 403) | def alter_format_add_foreign_key(self): method add_column_string (line 406) | def add_column_string(self): method drop_column_string (line 409) | def drop_column_string(self): method modify_column_string (line 412) | def modify_column_string(self): method rename_column_string (line 415) | def rename_column_string(self): method columnize_string (line 418) | def columnize_string(self): method constraintize (line 421) | def constraintize(self, constraints, table): method create_format (line 436) | def create_format(self): method create_if_not_exists_format (line 439) | def create_if_not_exists_format(self): method get_foreign_key_constraint_string (line 444) | def get_foreign_key_constraint_string(self): method get_primary_key_constraint_string (line 447) | def get_primary_key_constraint_string(self): method get_unique_constraint_string (line 450) | def get_unique_constraint_string(self): method get_table_string (line 453) | def get_table_string(self): method get_column_string (line 456) | def get_column_string(self): method table_information_string (line 459) | def table_information_string(self): method compile_table_exists (line 462) | def compile_table_exists(self, table, database=None, schema=None): method compile_truncate (line 465) | def compile_truncate(self, table, foreign_keys=False): method compile_rename_table (line 475) | def compile_rename_table(self, current_name, new_name): method compile_drop_table_if_exists (line 478) | def compile_drop_table_if_exists(self, table): method compile_drop_table (line 481) | def compile_drop_table(self, table): method compile_column_exists (line 484) | def compile_column_exists(self, table, column): method compile_get_all_tables (line 487) | def compile_get_all_tables(self, database=None, schema=None): method get_current_schema (line 490) | def get_current_schema(self, connection, table_name, schema=None): method enable_foreign_key_constraints (line 529) | def enable_foreign_key_constraints(self): method disable_foreign_key_constraints (line 533) | def disable_foreign_key_constraints(self): FILE: src/masoniteorm/schema/platforms/SQLitePlatform.py class SQLitePlatform (line 6) | class SQLitePlatform(Platform): method compile_create_sql (line 66) | def compile_create_sql(self, table, if_not_exists=False): method columnize (line 103) | def columnize(self, columns): method compile_alter_sql (line 158) | def compile_alter_sql(self, diff): method create_format (line 300) | def create_format(self): method create_if_not_exists_format (line 303) | def create_if_not_exists_format(self): method get_table_string (line 308) | def get_table_string(self): method get_column_string (line 311) | def get_column_string(self): method add_column_string (line 314) | def add_column_string(self): method create_column_length (line 317) | def create_column_length(self, column_type): method columnize_string (line 322) | def columnize_string(self): method get_unique_constraint_string (line 325) | def get_unique_constraint_string(self): method get_foreign_key_constraint_string (line 328) | def get_foreign_key_constraint_string(self): method get_primary_key_constraint_string (line 331) | def get_primary_key_constraint_string(self): method constraintize (line 334) | def constraintize(self, constraints): method foreign_key_constraintize (line 347) | def foreign_key_constraintize(self, table, foreign_keys): method columnize_names (line 367) | def columnize_names(self, columns): method get_current_schema (line 374) | def get_current_schema(self, connection, table_name, schema=None): method get_column_length (line 405) | def get_column_length(self, column_type): method get_column_type (line 412) | def get_column_type(self, reversed_type_map, column_type): method compile_table_exists (line 432) | def compile_table_exists(self, table, database=None, schema=None): method compile_column_exists (line 435) | def compile_column_exists(self, table, column): method compile_get_all_tables (line 438) | def compile_get_all_tables(self, database, schema=None): method compile_truncate (line 441) | def compile_truncate(self, table, foreign_keys=False): method compile_rename_table (line 451) | def compile_rename_table(self, current_table, new_name): method compile_drop_table_if_exists (line 454) | def compile_drop_table_if_exists(self, current_table): method compile_drop_table (line 457) | def compile_drop_table(self, current_table): method enable_foreign_key_constraints (line 460) | def enable_foreign_key_constraints(self): method disable_foreign_key_constraints (line 463) | def disable_foreign_key_constraints(self): FILE: src/masoniteorm/scopes/BaseScope.py class BaseScope (line 1) | class BaseScope: method on_boot (line 2) | def on_boot(self, builder): method on_remove (line 5) | def on_remove(self, builder): FILE: src/masoniteorm/scopes/SoftDeleteScope.py class SoftDeleteScope (line 4) | class SoftDeleteScope(BaseScope): method __init__ (line 7) | def __init__(self, deleted_at_column="deleted_at"): method on_boot (line 10) | def on_boot(self, builder): method on_remove (line 20) | def on_remove(self, builder): method _where_null (line 24) | def _where_null(self, builder): method _with_trashed (line 29) | def _with_trashed(self, model, builder): method _only_trashed (line 33) | def _only_trashed(self, model, builder): method _force_delete (line 37) | def _force_delete(self, model, builder, query=False): method _restore (line 42) | def _restore(self, model, builder): method _query_set_null_on_delete (line 45) | def _query_set_null_on_delete(self, builder): FILE: src/masoniteorm/scopes/SoftDeletesMixin.py class SoftDeletesMixin (line 4) | class SoftDeletesMixin: method boot_SoftDeletesMixin (line 9) | def boot_SoftDeletesMixin(self, builder): method get_deleted_at_column (line 12) | def get_deleted_at_column(self): FILE: src/masoniteorm/scopes/TimeStampsMixin.py class TimeStampsMixin (line 4) | class TimeStampsMixin: method boot_TimeStampsMixin (line 7) | def boot_TimeStampsMixin(self, builder): method activate_timestamps (line 10) | def activate_timestamps(self, boolean=True): FILE: src/masoniteorm/scopes/TimeStampsScope.py class TimeStampsScope (line 5) | class TimeStampsScope(BaseScope): method on_boot (line 8) | def on_boot(self, builder): method on_remove (line 17) | def on_remove(self, builder): method set_timestamp (line 20) | def set_timestamp(owner_cls, query): method set_timestamp_create (line 23) | def set_timestamp_create(self, builder): method set_timestamp_update (line 34) | def set_timestamp_update(self, builder): FILE: src/masoniteorm/scopes/UUIDPrimaryKeyMixin.py class UUIDPrimaryKeyMixin (line 4) | class UUIDPrimaryKeyMixin: method boot_UUIDPrimaryKeyMixin (line 7) | def boot_UUIDPrimaryKeyMixin(self, builder): FILE: src/masoniteorm/scopes/UUIDPrimaryKeyScope.py class UUIDPrimaryKeyScope (line 6) | class UUIDPrimaryKeyScope(BaseScope): method on_boot (line 9) | def on_boot(self, builder): method on_remove (line 17) | def on_remove(self, builder): method generate_uuid (line 20) | def generate_uuid(self, builder, uuid_version, bytes=False): method build_uuid_pk (line 29) | def build_uuid_pk(self, builder): method set_uuid_create (line 38) | def set_uuid_create(self, builder): method set_bulk_uuid_create (line 43) | def set_bulk_uuid_create(self, builder): FILE: src/masoniteorm/scopes/scope.py class scope (line 1) | class scope: method __init__ (line 2) | def __init__(self, callback, *params, **kwargs): method __set_name__ (line 5) | def __set_name__(self, cls, name): method __call__ (line 12) | def __call__(self, *args, **kwargs): FILE: src/masoniteorm/seeds/Seeder.py class Seeder (line 4) | class Seeder: method __init__ (line 5) | def __init__(self, dry=False, seed_path="databases/seeds", connection=... method call (line 12) | def call(self, *seeder_classes): method run_database_seed (line 18) | def run_database_seed(self): method run_specific_seed (line 28) | def run_specific_seed(self, seed): FILE: src/masoniteorm/testing/BaseTestCaseSelectGrammar.py class MockConnection (line 8) | class MockConnection: method make_connection (line 11) | def make_connection(self): class BaseTestCaseSelectGrammar (line 15) | class BaseTestCaseSelectGrammar: method setUp (line 16) | def setUp(self): method test_can_compile_select (line 25) | def test_can_compile_select(self): method test_can_compile_order_by_and_first (line 33) | def test_can_compile_order_by_and_first(self): method test_can_compile_with_columns (line 41) | def test_can_compile_with_columns(self): method test_can_compile_with_where (line 48) | def test_can_compile_with_where(self): method test_can_compile_or_where (line 55) | def test_can_compile_or_where(self): method test_can_grouped_where (line 62) | def test_can_grouped_where(self): method test_can_compile_with_several_where (line 71) | def test_can_compile_with_several_where(self): method test_can_compile_with_several_where_and_limit (line 83) | def test_can_compile_with_several_where_and_limit(self): method test_can_compile_with_sum (line 96) | def test_can_compile_with_sum(self): method test_can_compile_with_max (line 103) | def test_can_compile_with_max(self): method test_can_compile_with_max_and_columns (line 110) | def test_can_compile_with_max_and_columns(self): method test_can_compile_with_max_and_columns_different_order (line 117) | def test_can_compile_with_max_and_columns_different_order(self): method test_can_compile_with_order_by (line 124) | def test_can_compile_with_order_by(self): method test_can_compile_with_multiple_order_by (line 131) | def test_can_compile_with_multiple_order_by(self): method test_can_compile_with_group_by (line 143) | def test_can_compile_with_group_by(self): method test_can_compile_where_in (line 150) | def test_can_compile_where_in(self): method test_can_compile_where_in_empty (line 157) | def test_can_compile_where_in_empty(self): method test_can_compile_where_not_in (line 164) | def test_can_compile_where_not_in(self): method test_can_compile_where_null (line 171) | def test_can_compile_where_null(self): method test_can_compile_where_not_null (line 178) | def test_can_compile_where_not_null(self): method test_can_compile_count (line 185) | def test_can_compile_count(self): method test_can_compile_count_column (line 192) | def test_can_compile_count_column(self): method test_can_compile_where_column (line 199) | def test_can_compile_where_column(self): method test_can_compile_sub_select (line 206) | def test_can_compile_sub_select(self): method test_can_compile_complex_sub_select (line 215) | def test_can_compile_complex_sub_select(self): method test_can_compile_sub_select_where (line 229) | def test_can_compile_sub_select_where(self): method test_can_compile_sub_select_from_lambda (line 238) | def test_can_compile_sub_select_from_lambda(self): method test_can_compile_sub_select_value (line 249) | def test_can_compile_sub_select_value(self): method test_can_compile_exists (line 256) | def test_can_compile_exists(self): method test_can_compile_not_exists (line 267) | def test_can_compile_not_exists(self): method test_can_compile_having (line 278) | def test_can_compile_having(self): method test_can_compile_having_with_expression (line 285) | def test_can_compile_having_with_expression(self): method test_can_compile_having_with_greater_than_expression (line 292) | def test_can_compile_having_with_greater_than_expression(self): method test_can_compile_join (line 299) | def test_can_compile_join(self): method test_can_compile_join_clause (line 308) | def test_can_compile_join_clause(self): method test_can_compile_join_clause_with_value (line 323) | def test_can_compile_join_clause_with_value(self): method test_can_compile_join_clause_with_null (line 336) | def test_can_compile_join_clause_with_null(self): method test_can_compile_join_clause_with_not_null (line 350) | def test_can_compile_join_clause_with_not_null(self): method test_can_compile_join_clause_with_lambda (line 364) | def test_can_compile_join_clause_with_lambda(self): method test_can_compile_left_join_clause_with_lambda (line 375) | def test_can_compile_left_join_clause_with_lambda(self): method test_can_compile_right_join_clause_with_lambda (line 386) | def test_can_compile_right_join_clause_with_lambda(self): method test_can_compile_left_join (line 397) | def test_can_compile_left_join(self): method test_can_compile_multiple_join (line 406) | def test_can_compile_multiple_join(self): method test_can_compile_limit_and_offset (line 417) | def test_can_compile_limit_and_offset(self): method test_can_compile_between (line 424) | def test_can_compile_between(self): method test_can_compile_not_between (line 431) | def test_can_compile_not_between(self): method test_can_user_where_raw_and_where (line 438) | def test_can_user_where_raw_and_where(self): method test_can_compile_where_raw_and_where_with_multiple_bindings (line 447) | def test_can_compile_where_raw_and_where_with_multiple_bindings(self): method test_can_compile_first_or_fail (line 457) | def test_can_compile_first_or_fail(self): method test_where_like (line 466) | def test_where_like(self): method test_where_regexp (line 473) | def test_where_regexp(self): method test_where_exists_with_lambda (line 480) | def test_where_exists_with_lambda(self): method test_where_not_exists_with_lambda (line 488) | def test_where_not_exists_with_lambda(self): method test_where_not_regexp (line 496) | def test_where_not_regexp(self): method test_where_not_like (line 503) | def test_where_not_like(self): method test_shared_lock (line 510) | def test_shared_lock(self): method test_update_lock (line 517) | def test_update_lock(self): method test_where_date (line 524) | def test_where_date(self): method test_or_where_null (line 531) | def test_or_where_null(self): method test_select_distinct (line 538) | def test_select_distinct(self): FILE: tests/User.py class User (line 6) | class User(Model): method meta (line 16) | def meta(self): FILE: tests/collection/test_collection.py class TestCollection (line 9) | class TestCollection(unittest.TestCase): method test_take (line 10) | def test_take(self): method test_first (line 14) | def test_first(self): method test_last (line 20) | def test_last(self): method test_pluck (line 25) | def test_pluck(self): method test_pluck_with_models (line 31) | def test_pluck_with_models(self): method test_where (line 36) | def test_where(self): method test_where_in (line 51) | def test_where_in(self): method test_where_not_in (line 69) | def test_where_not_in(self): method test_where_in_bool (line 87) | def test_where_in_bool(self): method test_where_in_bytes (line 112) | def test_where_in_bytes(self): method test_pop (line 129) | def test_pop(self): method test_is_empty (line 134) | def test_is_empty(self): method test_sum (line 140) | def test_sum(self): method test_avg (line 165) | def test_avg(self): method test_max (line 190) | def test_max(self): method test_min (line 208) | def test_min(self): method test_count (line 226) | def test_count(self): method test_chunk (line 235) | def test_chunk(self): method test_collapse (line 265) | def test_collapse(self): method test_get (line 272) | def test_get(self): method test_merge (line 280) | def test_merge(self): method test_reduce (line 285) | def test_reduce(self): method test_forget (line 297) | def test_forget(self): method test_prepend (line 307) | def test_prepend(self): method test_pull (line 314) | def test_pull(self): method test_push (line 321) | def test_push(self): method test_put (line 328) | def test_put(self): method test_reject (line 335) | def test_reject(self): method test_for_page (line 362) | def test_for_page(self): method test_unique (line 368) | def test_unique(self): method test_transform (line 398) | def test_transform(self): method test_shift (line 404) | def test_shift(self): method test_sort (line 431) | def test_sort(self): method test_reverse (line 437) | def test_reverse(self): method test_zip (line 461) | def test_zip(self): method test_diff (line 467) | def test_diff(self): method test_each (line 473) | def test_each(self): method test_every (line 478) | def test_every(self): method test_filter (line 485) | def test_filter(self): method test_implode (line 490) | def test_implode(self): method test_map_into (line 501) | def test_map_into(self): method test_map (line 516) | def test_map(self): method test_serialize (line 542) | def test_serialize(self): method test_json (line 573) | def test_json(self): method test_contains (line 590) | def test_contains(self): method test_all (line 609) | def test_all(self): method test_flatten (line 629) | def test_flatten(self): method test_group_by (line 635) | def test_group_by(self): method test_serialize_with_model_appends (line 655) | def test_serialize_with_model_appends(self): method test_serialize_with_on_the_fly_appends (line 660) | def test_serialize_with_on_the_fly_appends(self): method test_random (line 664) | def test_random(self): method test_random_with_count (line 677) | def test_random_with_count(self): method test_make_comparison (line 690) | def test_make_comparison(self): method test_eq (line 695) | def test_eq(self): FILE: tests/commands/test_shell.py class TestShellCommand (line 7) | class TestShellCommand(unittest.TestCase): method setUp (line 8) | def setUp(self): method test_for_mysql (line 12) | def test_for_mysql(self): method test_for_postgres (line 29) | def test_for_postgres(self): method test_for_sqlite (line 44) | def test_for_sqlite(self): method test_for_mssql (line 53) | def test_for_mssql(self): method test_running_command_with_sqlite (line 70) | def test_running_command_with_sqlite(self): method test_hiding_sensitive_options (line 76) | def test_hiding_sensitive_options(self): FILE: tests/config/test_db_url.py class TestDbUrlHelper (line 10) | class TestDbUrlHelper(unittest.TestCase): method setUp (line 11) | def setUp(self): method test_parse_env_by_default (line 17) | def test_parse_env_by_default(self): method test_parse_sqlite (line 27) | def test_parse_sqlite(self): method test_parse_mysql (line 42) | def test_parse_mysql(self): method test_parse_postgres (line 56) | def test_parse_postgres(self): method test_parse_mssql (line 72) | def test_parse_mssql(self): method test_parse_with_params (line 86) | def test_parse_with_params(self): method test_using_it_with_connection_resolver (line 105) | def test_using_it_with_connection_resolver(self): FILE: tests/connections/test_base_connections.py class TestDefaultBehaviorConnections (line 7) | class TestDefaultBehaviorConnections(unittest.TestCase): method test_should_return_connection_with_enabled_logs (line 8) | def test_should_return_connection_with_enabled_logs(self): method test_should_disable_log_queries_in_connection (line 15) | def test_should_disable_log_queries_in_connection(self): FILE: tests/eagers/test_eager.py class TestEagerRelation (line 7) | class TestEagerRelation(unittest.TestCase): method test_can_register_string_eager_load (line 8) | def test_can_register_string_eager_load(self): method test_can_register_tuple_eager_load (line 32) | def test_can_register_tuple_eager_load(self): method test_can_register_list_eager_load (line 45) | def test_can_register_list_eager_load(self): FILE: tests/factories/test_factories.py class User (line 9) | class User(Model): class AfterCreatedModel (line 13) | class AfterCreatedModel(Model): class TestFactories (line 18) | class TestFactories(unittest.TestCase): method setUp (line 19) | def setUp(self): method user_factory (line 25) | def user_factory(self, faker): method named_user_factory (line 28) | def named_user_factory(self, faker): method after_creating (line 31) | def after_creating(self, model, faker): method test_can_make_single (line 34) | def test_can_make_single(self): method test_can_make_several (line 40) | def test_can_make_several(self): method test_can_make_any_number (line 45) | def test_can_make_any_number(self): method test_can_make_named_factory (line 50) | def test_can_make_named_factory(self): method test_after_creates (line 54) | def test_after_creates(self): FILE: tests/models/test_models.py class ModelTest (line 10) | class ModelTest(Model): class FillableModelTest (line 21) | class FillableModelTest(Model): class InvalidFillableGuardedModelTest (line 25) | class InvalidFillableGuardedModelTest(Model): class InvalidFillableGuardedChildModelTest (line 30) | class InvalidFillableGuardedChildModelTest(ModelTest): class ModelTestForced (line 35) | class ModelTestForced(Model): class BaseModel (line 39) | class BaseModel(Model): method get_selects (line 41) | def get_selects(self): class ModelWithBaseModel (line 44) | class ModelWithBaseModel(BaseModel): class TestModels (line 47) | class TestModels(unittest.TestCase): method test_model_can_access_str_dates_as_pendulum (line 48) | def test_model_can_access_str_dates_as_pendulum(self): method test_model_can_access_str_dates_as_pendulum_from_correct_datetimes (line 55) | def test_model_can_access_str_dates_as_pendulum_from_correct_datetimes... method test_model_can_access_str_dates_on_relationships (line 65) | def test_model_can_access_str_dates_on_relationships(self): method test_model_original_and_dirty_attributes (line 78) | def test_model_original_and_dirty_attributes(self): method test_model_creates_when_new (line 98) | def test_model_creates_when_new(self): method test_model_can_cast_attributes (line 111) | def test_model_can_cast_attributes(self): method test_model_can_cast_dict_attributes (line 128) | def test_model_can_cast_dict_attributes(self): method test_valid_json_cast (line 142) | def test_valid_json_cast(self): method test_model_update_without_changes (line 173) | def test_model_update_without_changes(self): method test_force_update_on_model_class (line 184) | def test_force_update_on_model_class(self): method test_only_method (line 196) | def test_only_method(self): method test_model_update_without_changes_at_all (line 204) | def test_model_update_without_changes_at_all(self): method test_model_using_or_where (line 214) | def test_model_using_or_where(self): method test_model_using_or_where_and_chaining_wheres (line 223) | def test_model_using_or_where_and_chaining_wheres(self): method test_both_fillable_and_guarded_attributes_raise (line 241) | def test_both_fillable_and_guarded_attributes_raise(self): method test_model_can_provide_default_select (line 264) | def test_model_can_provide_default_select(self): method test_model_can_override_to_default_select (line 271) | def test_model_can_override_to_default_select(self): method test_model_can_use_aggregate_funcs_with_default_selects (line 278) | def test_model_can_use_aggregate_funcs_with_default_selects(self): FILE: tests/mssql/builder/test_mssql_query_builder.py class MockConnection (line 11) | class MockConnection: method make_connection (line 14) | def make_connection(self): method get_default_query_grammar (line 18) | def get_default_query_grammar(cls): class ModelTest (line 22) | class ModelTest(Model): class TestMSSQLQueryBuilder (line 26) | class TestMSSQLQueryBuilder(unittest.TestCase): method get_builder (line 29) | def get_builder(self, table="users", dry=True): method test_sum (line 40) | def test_sum(self): method test_where_like (line 48) | def test_where_like(self): method test_where_not_like (line 56) | def test_where_not_like(self): method test_max (line 65) | def test_max(self): method test_min (line 73) | def test_min(self): method test_avg (line 81) | def test_avg(self): method test_all (line 89) | def test_all(self): method test_get (line 95) | def test_get(self): method test_first (line 101) | def test_first(self): method test_select (line 106) | def test_select(self): method test_add_select_no_table (line 114) | def test_add_select_no_table(self): method test_select_raw (line 129) | def test_select_raw(self): method test_create (line 137) | def test_create(self): method test_delete (line 148) | def test_delete(self): method test_where (line 155) | def test_where(self): method test_where_exists (line 163) | def test_where_exists(self): method test_limit (line 168) | def test_limit(self): method test_offset (line 174) | def test_offset(self): method test_join (line 183) | def test_join(self): method test_left_join (line 192) | def test_left_join(self): method test_right_join (line 200) | def test_right_join(self): method test_update (line 208) | def test_update(self): method test_count (line 231) | def test_count(self): method test_order_by_asc (line 238) | def test_order_by_asc(self): method test_order_by_desc (line 243) | def test_order_by_desc(self): method test_where_column (line 250) | def test_where_column(self): method test_where_not_in (line 258) | def test_where_not_in(self): method test_between (line 266) | def test_between(self): method test_not_between (line 274) | def test_not_between(self): method test_where_in (line 282) | def test_where_in(self): method test_where_null (line 291) | def test_where_null(self): method test_where_not_null (line 299) | def test_where_not_null(self): method test_having (line 307) | def test_having(self): method test_group_by (line 318) | def test_group_by(self): method test_builder_alone (line 327) | def test_builder_alone(self): method test_where_lt (line 348) | def test_where_lt(self): method test_where_lte (line 355) | def test_where_lte(self): method test_where_gt (line 362) | def test_where_gt(self): method test_where_gte (line 369) | def test_where_gte(self): method test_where_ne (line 376) | def test_where_ne(self): method test_or_where (line 383) | def test_or_where(self): method test_can_call_with_schema (line 391) | def test_can_call_with_schema(self): method test_truncate (line 404) | def test_truncate(self): method test_truncate_without_foreign_keys (line 409) | def test_truncate_without_foreign_keys(self): method test_latest (line 414) | def test_latest(self): method test_latest_multiple (line 421) | def test_latest_multiple(self): method test_oldest (line 429) | def test_oldest(self): method test_oldest_multiple (line 434) | def test_oldest_multiple(self): FILE: tests/mssql/builder/test_mssql_query_builder_relationships.py class Logo (line 16) | class Logo(Model): class Article (line 20) | class Article(Model): method logo (line 24) | def logo(self): class Profile (line 28) | class Profile(Model): class User (line 32) | class User(Model): method articles (line 36) | def articles(self): method profile (line 40) | def profile(self): method parent_dynamic (line 44) | def parent_dynamic(self): method parent_specified (line 48) | def parent_specified(self): class BaseTestQueryRelationships (line 52) | class BaseTestQueryRelationships(unittest.TestCase): method get_builder (line 55) | def get_builder(self, table="users"): method test_has (line 65) | def test_has(self): method test_has_reference_to_self (line 75) | def test_has_reference_to_self(self): method test_has_reference_to_self_using_class (line 85) | def test_has_reference_to_self_using_class(self): method test_where_has_query (line 95) | def test_where_has_query(self): method test_relationship_multiple_has (line 105) | def test_relationship_multiple_has(self): method test_relationship_multiple_has_calls (line 116) | def test_relationship_multiple_has_calls(self): method test_nested_has (line 127) | def test_nested_has(self): FILE: tests/mssql/grammar/test_mssql_delete_grammar.py class TestMySQLDeleteGrammar (line 7) | class TestMySQLDeleteGrammar(unittest.TestCase): method setUp (line 8) | def setUp(self): method test_can_compile_delete (line 11) | def test_can_compile_delete(self): method test_can_compile_delete_with_where (line 17) | def test_can_compile_delete_with_where(self): FILE: tests/mssql/grammar/test_mssql_insert_grammar.py class TestMySQLInsertGrammar (line 7) | class TestMySQLInsertGrammar(unittest.TestCase): method setUp (line 8) | def setUp(self): method test_can_compile_insert (line 11) | def test_can_compile_insert(self): method test_can_compile_bulk_create (line 17) | def test_can_compile_bulk_create(self): method test_can_compile_bulk_create_qmark (line 31) | def test_can_compile_bulk_create_qmark(self): FILE: tests/mssql/grammar/test_mssql_qmark.py class TestMSSQLQmark (line 7) | class TestMSSQLQmark(unittest.TestCase): method setUp (line 8) | def setUp(self): method test_can_compile_select (line 11) | def test_can_compile_select(self): method test_can_compile_update (line 18) | def test_can_compile_update(self): method test_can_compile_insert (line 25) | def test_can_compile_insert(self): method test_can_compile_where_in (line 32) | def test_can_compile_where_in(self): FILE: tests/mssql/grammar/test_mssql_select_grammar.py class TestMSSQLGrammar (line 8) | class TestMSSQLGrammar(BaseTestCaseSelectGrammar, unittest.TestCase): method can_compile_select (line 11) | def can_compile_select(self): method can_compile_with_columns (line 17) | def can_compile_with_columns(self): method can_compile_with_where (line 23) | def can_compile_with_where(self): method can_compile_with_several_where (line 29) | def can_compile_with_several_where(self): method can_compile_with_several_where_and_limit (line 35) | def can_compile_with_several_where_and_limit(self): method can_compile_with_sum (line 41) | def can_compile_with_sum(self): method can_compile_order_by_and_first (line 47) | def can_compile_order_by_and_first(self): method can_compile_with_max (line 53) | def can_compile_with_max(self): method can_compile_with_max_and_columns (line 59) | def can_compile_with_max_and_columns(self): method can_compile_with_max_and_columns_different_order (line 65) | def can_compile_with_max_and_columns_different_order(self): method can_compile_with_order_by (line 71) | def can_compile_with_order_by(self): method can_compile_with_multiple_order_by (line 77) | def can_compile_with_multiple_order_by(self): method can_compile_with_group_by (line 83) | def can_compile_with_group_by(self): method can_compile_where_in (line 89) | def can_compile_where_in(self): method can_compile_where_in_empty (line 95) | def can_compile_where_in_empty(self): method can_compile_where_null (line 101) | def can_compile_where_null(self): method can_compile_where_not_null (line 107) | def can_compile_where_not_null(self): method can_compile_where_raw (line 113) | def can_compile_where_raw(self): method test_can_compile_where_raw_and_where_with_multiple_bindings (line 119) | def test_can_compile_where_raw_and_where_with_multiple_bindings(self): method can_compile_select_raw (line 129) | def can_compile_select_raw(self): method can_compile_limit_and_offset (line 135) | def can_compile_limit_and_offset(self): method can_compile_select_raw_with_select (line 141) | def can_compile_select_raw_with_select(self): method can_compile_having_raw (line 147) | def can_compile_having_raw(self): method can_compile_count (line 153) | def can_compile_count(self): method can_compile_count_column (line 160) | def can_compile_count_column(self): method can_compile_where_column (line 167) | def can_compile_where_column(self): method can_compile_or_where (line 174) | def can_compile_or_where(self): method can_grouped_where (line 182) | def can_grouped_where(self): method can_compile_sub_select (line 188) | def can_compile_sub_select(self): method can_compile_sub_select_where (line 197) | def can_compile_sub_select_where(self): method can_compile_sub_select_value (line 206) | def can_compile_sub_select_value(self): method can_compile_complex_sub_select (line 215) | def can_compile_complex_sub_select(self): method can_compile_exists (line 226) | def can_compile_exists(self): method can_compile_not_exists (line 234) | def can_compile_not_exists(self): method can_compile_having (line 242) | def can_compile_having(self): method can_compile_having_order (line 248) | def can_compile_having_order(self): method can_compile_between (line 254) | def can_compile_between(self): method can_compile_not_between (line 260) | def can_compile_not_between(self): method can_compile_where_not_in (line 266) | def can_compile_where_not_in(self): method can_compile_having_with_expression (line 272) | def can_compile_having_with_expression(self): method can_compile_having_with_greater_than_expression (line 278) | def can_compile_having_with_greater_than_expression(self): method can_compile_join (line 284) | def can_compile_join(self): method can_compile_left_join (line 290) | def can_compile_left_join(self): method can_compile_multiple_join (line 296) | def can_compile_multiple_join(self): method test_can_compile_where_raw (line 302) | def test_can_compile_where_raw(self): method test_can_compile_having_raw (line 306) | def test_can_compile_having_raw(self): method test_can_compile_having_raw_order (line 316) | def test_can_compile_having_raw_order(self): method test_can_compile_select_raw (line 328) | def test_can_compile_select_raw(self): method test_can_compile_select_raw_with_select (line 335) | def test_can_compile_select_raw_with_select(self): method can_compile_first_or_fail (line 342) | def can_compile_first_or_fail(self): method where_like (line 349) | def where_like(self): method where_not_like (line 356) | def where_not_like(self): method where_regexp (line 363) | def where_regexp(self): method where_not_regexp (line 370) | def where_not_regexp(self): method can_compile_join_clause (line 377) | def can_compile_join_clause(self): method can_compile_join_clause_with_value (line 390) | def can_compile_join_clause_with_value(self): method can_compile_join_clause_with_null (line 402) | def can_compile_join_clause_with_null(self): method can_compile_join_clause_with_not_null (line 415) | def can_compile_join_clause_with_not_null(self): method can_compile_join_clause_with_lambda (line 428) | def can_compile_join_clause_with_lambda(self): method can_compile_left_join_clause_with_lambda (line 441) | def can_compile_left_join_clause_with_lambda(self): method can_compile_right_join_clause_with_lambda (line 454) | def can_compile_right_join_clause_with_lambda(self): method shared_lock (line 467) | def shared_lock(self): method update_lock (line 474) | def update_lock(self): method can_user_where_raw_and_where (line 481) | def can_user_where_raw_and_where(self): method where_exists_with_lambda (line 487) | def where_exists_with_lambda(self): method where_not_exists_with_lambda (line 490) | def where_not_exists_with_lambda(self): method where_date (line 493) | def where_date(self): method or_where_null (line 498) | def or_where_null(self): method select_distinct (line 501) | def select_distinct(self): FILE: tests/mssql/grammar/test_mssql_update_grammar.py class TestMSSQLUpdateGrammar (line 8) | class TestMSSQLUpdateGrammar(unittest.TestCase): method setUp (line 9) | def setUp(self): method test_can_compile_update (line 12) | def test_can_compile_update(self): method test_can_compile_update_with_multiple_where (line 20) | def test_can_compile_update_with_multiple_where(self): method test_raw_expression (line 31) | def test_raw_expression(self): FILE: tests/mssql/schema/test_mssql_schema_builder.py class TestMSSQLSchemaBuilder (line 9) | class TestMSSQLSchemaBuilder(unittest.TestCase): method setUp (line 12) | def setUp(self): method test_can_add_columns (line 21) | def test_can_add_columns(self): method test_can_add_tiny_text (line 32) | def test_can_add_tiny_text(self): method test_can_add_unsigned_decimal (line 42) | def test_can_add_unsigned_decimal(self): method test_can_add_columns_with_constaint (line 52) | def test_can_add_columns_with_constaint(self): method test_can_have_float_type (line 66) | def test_can_have_float_type(self): method test_can_have_unsigned_columns (line 75) | def test_can_have_unsigned_columns(self): method test_can_add_columns_with_foreign_key_constaint (line 95) | def test_can_add_columns_with_foreign_key_constaint(self): method test_can_add_columns_with_add_foreign_constaint (line 115) | def test_can_add_columns_with_add_foreign_constaint(self): method test_can_advanced_table_creation (line 135) | def test_can_advanced_table_creation(self): method test_can_advanced_table_creation2 (line 158) | def test_can_advanced_table_creation2(self): method test_can_add_columns_with_foreign_key_constraint_name (line 192) | def test_can_add_columns_with_foreign_key_constraint_name(self): method test_can_have_composite_keys (line 209) | def test_can_have_composite_keys(self): method test_can_have_column_primary_key (line 229) | def test_can_have_column_primary_key(self): method test_has_table (line 247) | def test_has_table(self): method test_can_truncate (line 254) | def test_can_truncate(self): method test_can_rename_table (line 259) | def test_can_rename_table(self): method test_can_drop_table_if_exists (line 264) | def test_can_drop_table_if_exists(self): method test_can_drop_table (line 269) | def test_can_drop_table(self): method test_has_column (line 274) | def test_has_column(self): method test_can_enable_foreign_keys (line 282) | def test_can_enable_foreign_keys(self): method test_can_disable_foreign_keys (line 287) | def test_can_disable_foreign_keys(self): method test_can_truncate_without_foreign_keys (line 292) | def test_can_truncate_without_foreign_keys(self): method test_can_add_enum (line 304) | def test_can_add_enum(self): method test_can_change_column_enum (line 316) | def test_can_change_column_enum(self): FILE: tests/mssql/schema/test_mssql_schema_builder_alter.py class TestMySQLSchemaBuilderAlter (line 10) | class TestMySQLSchemaBuilderAlter(unittest.TestCase): method setUp (line 13) | def setUp(self): method test_can_add_columns (line 22) | def test_can_add_columns(self): method test_can_adds_column_with_default (line 35) | def test_can_adds_column_with_default(self): method test_alter_rename (line 45) | def test_alter_rename(self): method test_alter_add_and_rename (line 57) | def test_alter_add_and_rename(self): method test_alter_drop1 (line 73) | def test_alter_drop1(self): method test_alter_add_column_and_foreign_key (line 81) | def test_alter_add_column_and_foreign_key(self): method test_alter_add_column_and_add_foreign (line 95) | def test_alter_add_column_and_add_foreign(self): method test_alter_drop_foreign_key (line 107) | def test_alter_drop_foreign_key(self): method test_alter_drop_foreign_key_shortcut (line 115) | def test_alter_drop_foreign_key_shortcut(self): method test_alter_drop_unique_constraint (line 123) | def test_alter_drop_unique_constraint(self): method test_alter_add_primary (line 131) | def test_alter_add_primary(self): method test_alter_add_index (line 141) | def test_alter_add_index(self): method test_alter_drop_index (line 149) | def test_alter_drop_index(self): method test_alter_drop_index_shortcut (line 157) | def test_alter_drop_index_shortcut(self): method test_alter_drop_unique_constraint_shortcut (line 165) | def test_alter_drop_unique_constraint_shortcut(self): method test_alter_drop_primary (line 173) | def test_alter_drop_primary(self): method test_has_table (line 181) | def test_has_table(self): method test_drop_table (line 188) | def test_drop_table(self): method test_change (line 195) | def test_change(self): method test_drop_add_and_change (line 215) | def test_drop_add_and_change(self): method test_can_create_indexes (line 237) | def test_can_create_indexes(self): method test_timestamp_alter_add_nullable_column (line 257) | def test_timestamp_alter_add_nullable_column(self): method test_can_add_column_enum (line 272) | def test_can_add_column_enum(self): FILE: tests/mysql/builder/test_mysql_builder_transaction.py class User (line 15) | class User(Model): class BaseTestQueryRelationships (line 19) | class BaseTestQueryRelationships(unittest.TestCase): method get_builder (line 22) | def get_builder(self, table="users"): method test_transaction (line 28) | def test_transaction(self): method test_transaction_default_globally (line 39) | def test_transaction_default_globally(self): FILE: tests/mysql/builder/test_query_builder.py class Articles (line 15) | class Articles(Model): class User (line 19) | class User(Model): method articles (line 23) | def articles(self): class BaseTestQueryBuilder (line 27) | class BaseTestQueryBuilder: method get_builder (line 30) | def get_builder(self, table="users", dry=True): method test_sum (line 42) | def test_sum(self): method test_sum_chained (line 51) | def test_sum_chained(self): method test_with_ (line 60) | def test_with_(self): method test_where_like (line 69) | def test_where_like(self): method test_where_not_like (line 78) | def test_where_not_like(self): method test_max (line 87) | def test_max(self): method test_min (line 96) | def test_min(self): method test_avg (line 105) | def test_avg(self): method test_all (line 113) | def test_all(self): method test_get (line 121) | def test_get(self): method test_first (line 129) | def test_first(self): method test_find_with_model (line 136) | def test_find_with_model(self): method test_find_with_model_and_list (line 142) | def test_find_with_model_and_list(self): method test_find_with_model_custom_column (line 148) | def test_find_with_model_custom_column(self): method test_find_with_builder (line 154) | def test_find_with_builder(self): method test_find_with_builder_and_list (line 161) | def test_find_with_builder_and_list(self): method test_find_with_builder_without_column (line 168) | def test_find_with_builder_without_column(self): method test_select (line 174) | def test_select(self): method test_select_with_table (line 182) | def test_select_with_table(self): method test_select_with_table_raw (line 190) | def test_select_with_table_raw(self): method test_select_with_alias (line 198) | def test_select_with_alias(self): method test_select_raw (line 206) | def test_select_raw(self): method test_add_select (line 214) | def test_add_select(self): method test_add_select_no_table (line 227) | def test_add_select_no_table(self): method test_create (line 243) | def test_create(self): method test_delete (line 253) | def test_delete(self): method test_where (line 261) | def test_where(self): method test_where_exists (line 269) | def test_where_exists(self): method test_limit (line 277) | def test_limit(self): method test_offset (line 285) | def test_offset(self): method test_join (line 293) | def test_join(self): method test_left_join (line 301) | def test_left_join(self): method test_right_join (line 309) | def test_right_join(self): method test_update (line 317) | def test_update(self): method test_count (line 342) | def test_count(self): method test_order_by_asc (line 350) | def test_order_by_asc(self): method test_order_by_desc (line 358) | def test_order_by_desc(self): method test_where_column (line 366) | def test_where_column(self): method test_where_not_in (line 374) | def test_where_not_in(self): method test_between (line 382) | def test_between(self): method test_not_between (line 390) | def test_not_between(self): method test_where_in (line 398) | def test_where_in(self): method test_where_null (line 407) | def test_where_null(self): method test_where_not_null (line 416) | def test_where_not_null(self): method test_having (line 425) | def test_having(self): method test_group_by (line 436) | def test_group_by(self): method test_builder_alone (line 445) | def test_builder_alone(self): method test_where_lt (line 466) | def test_where_lt(self): method test_where_lte (line 474) | def test_where_lte(self): method test_where_gt (line 482) | def test_where_gt(self): method test_where_gte (line 490) | def test_where_gte(self): method test_where_ne (line 498) | def test_where_ne(self): method test_or_where (line 506) | def test_or_where(self): method test_or_where (line 514) | def test_or_where(self): method test_where_like_as_operator (line 522) | def test_where_like_as_operator(self): method test_where_like (line 528) | def test_where_like(self): method test_where_not_like_as_operator (line 534) | def test_where_not_like_as_operator(self): method test_where_not_like (line 540) | def test_where_not_like(self): method test_can_call_with_multi_tables (line 546) | def test_can_call_with_multi_tables(self): method test_truncate (line 559) | def test_truncate(self): method test_truncate_without_foreign_keys (line 567) | def test_truncate_without_foreign_keys(self): method test_shared_lock (line 575) | def test_shared_lock(self): method test_update_lock (line 583) | def test_update_lock(self): class MySQLQueryBuilderTest (line 592) | class MySQLQueryBuilderTest(BaseTestQueryBuilder, unittest.TestCase): method sum (line 595) | def sum(self): method sum_chained (line 602) | def sum_chained(self): method with_ (line 609) | def with_(self): method max (line 616) | def max(self): method min (line 623) | def min(self): method avg (line 630) | def avg(self): method first (line 637) | def first(self): method all (line 644) | def all(self): method get (line 651) | def get(self): method select (line 658) | def select(self): method select_with_table (line 665) | def select_with_table(self): method select_with_table_raw (line 672) | def select_with_table_raw(self): method select_with_alias (line 679) | def select_with_alias(self): method select_raw (line 686) | def select_raw(self): method add_select (line 693) | def add_select(self): method add_select_no_table (line 700) | def add_select_no_table(self): method create (line 711) | def create(self): method delete (line 718) | def delete(self): method where (line 725) | def where(self): method where_exists (line 732) | def where_exists(self): method limit (line 739) | def limit(self): method offset (line 746) | def offset(self): method join (line 753) | def join(self): method left_join (line 759) | def left_join(self): method right_join (line 765) | def right_join(self): method update (line 771) | def update(self): method increment (line 777) | def increment(self): method decrement (line 783) | def decrement(self): method count (line 789) | def count(self): method order_by_asc (line 795) | def order_by_asc(self): method order_by_desc (line 801) | def order_by_desc(self): method where_column (line 807) | def where_column(self): method where_null (line 813) | def where_null(self): method where_not_null (line 819) | def where_not_null(self): method where_not_in (line 825) | def where_not_in(self): method where_in (line 831) | def where_in(self): method between (line 837) | def between(self): method not_between (line 843) | def not_between(self): method having (line 849) | def having(self): method group_by (line 855) | def group_by(self): method where_lt (line 861) | def where_lt(self): method where_lte (line 868) | def where_lte(self): method where_gt (line 875) | def where_gt(self): method where_gte (line 882) | def where_gte(self): method where_ne (line 889) | def where_ne(self): method or_where (line 896) | def or_where(self): method where_like (line 905) | def where_like(self): method where_not_like (line 912) | def where_not_like(self): method truncate (line 919) | def truncate(self): method truncate_without_foreign_keys (line 926) | def truncate_without_foreign_keys(self): method shared_lock (line 937) | def shared_lock(self): method update_lock (line 944) | def update_lock(self): method test_latest (line 951) | def test_latest(self): method test_oldest (line 959) | def test_oldest(self): method latest (line 967) | def latest(self): method oldest (line 973) | def oldest(self): FILE: tests/mysql/builder/test_query_builder_scopes.py class BaseTestQueryBuilderScopes (line 13) | class BaseTestQueryBuilderScopes(unittest.TestCase): method get_builder (line 16) | def get_builder(self, table="users"): method test_scopes (line 26) | def test_scopes(self): method test_global_scopes (line 36) | def test_global_scopes(self): method test_global_scope_from_class (line 46) | def test_global_scope_from_class(self): method test_global_scope_remove_from_class (line 54) | def test_global_scope_remove_from_class(self): method test_global_scope_adds_method (line 66) | def test_global_scope_adds_method(self): FILE: tests/mysql/builder/test_transactions.py class Articles (line 13) | class Articles(Model): class User (line 17) | class User(Model): method articles (line 19) | def articles(self): class TestTransactions (line 25) | class TestTransactions(unittest.TestCase): FILE: tests/mysql/connections/test_mysql_connection_selects.py class MockUser (line 9) | class MockUser(Model): class TestMySQLSelectConnection (line 15) | class TestMySQLSelectConnection(unittest.TestCase): method setUp (line 16) | def setUp(self): method test_can_compile_select (line 19) | def test_can_compile_select(self): method test_can_get_first_record (line 25) | def test_can_get_first_record(self): method test_can_find_first_record (line 29) | def test_can_find_first_record(self): method test_can_get_all_records (line 33) | def test_can_get_all_records(self): method test_can_get_5_records (line 37) | def test_can_get_5_records(self): method test_can_get_1_record_with_get (line 41) | def test_can_get_1_record_with_get(self): FILE: tests/mysql/grammar/test_mysql_delete_grammar.py class BaseDeleteGrammarTest (line 8) | class BaseDeleteGrammarTest: method setUp (line 9) | def setUp(self): method test_can_compile_delete (line 12) | def test_can_compile_delete(self): method test_can_compile_delete_in (line 20) | def test_can_compile_delete_in(self): method test_can_compile_delete_with_where (line 28) | def test_can_compile_delete_with_where(self): class TestMySQLDeleteGrammar (line 43) | class TestMySQLDeleteGrammar(BaseDeleteGrammarTest, unittest.TestCase): method can_compile_delete (line 46) | def can_compile_delete(self): method can_compile_delete_in (line 56) | def can_compile_delete_in(self): method can_compile_delete_with_where (line 66) | def can_compile_delete_with_where(self): FILE: tests/mysql/grammar/test_mysql_insert_grammar.py class BaseInsertGrammarTest (line 8) | class BaseInsertGrammarTest: method setUp (line 9) | def setUp(self): method test_can_compile_insert (line 12) | def test_can_compile_insert(self): method test_can_compile_insert_with_keywords (line 20) | def test_can_compile_insert_with_keywords(self): method test_can_compile_bulk_create (line 28) | def test_can_compile_bulk_create(self): method test_can_compile_bulk_create_qmark (line 44) | def test_can_compile_bulk_create_qmark(self): method test_can_compile_bulk_create_multiple (line 54) | def test_can_compile_bulk_create_multiple(self): class TestMySQLUpdateGrammar (line 70) | class TestMySQLUpdateGrammar(BaseInsertGrammarTest, unittest.TestCase): method can_compile_insert (line 73) | def can_compile_insert(self): method can_compile_insert_with_keywords (line 81) | def can_compile_insert_with_keywords(self): method can_compile_bulk_create (line 87) | def can_compile_bulk_create(self): method can_compile_bulk_create_multiple (line 93) | def can_compile_bulk_create_multiple(self): method can_compile_bulk_create_qmark (line 99) | def can_compile_bulk_create_qmark(self): FILE: tests/mysql/grammar/test_mysql_qmark.py class BaseQMarkTest (line 8) | class BaseQMarkTest: method setUp (line 9) | def setUp(self): method test_can_compile_select (line 12) | def test_can_compile_select(self): method test_can_compile_delete (line 21) | def test_can_compile_delete(self): method test_can_compile_update (line 30) | def test_can_compile_update(self): method test_can_compile_where_in (line 39) | def test_can_compile_where_in(self): method test_can_compile_where_not_null (line 48) | def test_can_compile_where_not_null(self): method test_can_compile_where_with_falsy_values (line 57) | def test_can_compile_where_with_falsy_values(self): method test_can_compile_where_with_true_value (line 66) | def test_can_compile_where_with_true_value(self): method test_can_compile_where_with_false_value (line 75) | def test_can_compile_where_with_false_value(self): method test_can_compile_sub_group_bindings (line 84) | def test_can_compile_sub_group_bindings(self): class TestMySQLQmark (line 100) | class TestMySQLQmark(BaseQMarkTest, unittest.TestCase): method can_compile_select (line 101) | def can_compile_select(self): method can_compile_delete (line 110) | def can_compile_delete(self): method can_compile_update (line 116) | def can_compile_update(self): method can_compile_where_in (line 127) | def can_compile_where_in(self): method can_compile_where_not_null (line 136) | def can_compile_where_not_null(self): method can_compile_where_with_falsy_values (line 142) | def can_compile_where_with_falsy_values(self): method can_compile_where_with_true_value (line 148) | def can_compile_where_with_true_value(self): method can_compile_where_with_false_value (line 154) | def can_compile_where_with_false_value(self): method can_compile_sub_group_bindings (line 160) | def can_compile_sub_group_bindings(self): FILE: tests/mysql/grammar/test_mysql_select_grammar.py class TestMySQLGrammar (line 8) | class TestMySQLGrammar(BaseTestCaseSelectGrammar, unittest.TestCase): method can_compile_select (line 11) | def can_compile_select(self): method can_compile_with_columns (line 17) | def can_compile_with_columns(self): method can_compile_order_by_and_first (line 23) | def can_compile_order_by_and_first(self): method can_compile_with_where (line 29) | def can_compile_with_where(self): method can_compile_with_several_where (line 35) | def can_compile_with_several_where(self): method can_compile_with_several_where_and_limit (line 41) | def can_compile_with_several_where_and_limit(self): method can_compile_with_sum (line 47) | def can_compile_with_sum(self): method can_compile_with_max (line 53) | def can_compile_with_max(self): method can_compile_with_max_and_columns (line 59) | def can_compile_with_max_and_columns(self): method can_compile_with_max_and_columns_different_order (line 65) | def can_compile_with_max_and_columns_different_order(self): method can_compile_with_order_by (line 71) | def can_compile_with_order_by(self): method can_compile_with_multiple_order_by (line 77) | def can_compile_with_multiple_order_by(self): method can_compile_with_group_by (line 83) | def can_compile_with_group_by(self): method can_compile_where_in (line 89) | def can_compile_where_in(self): method can_compile_where_in_empty (line 95) | def can_compile_where_in_empty(self): method can_compile_where_not_in (line 101) | def can_compile_where_not_in(self): method can_compile_where_null (line 107) | def can_compile_where_null(self): method can_compile_where_not_null (line 113) | def can_compile_where_not_null(self): method can_compile_where_raw (line 119) | def can_compile_where_raw(self): method can_compile_where_raw_and_where_with_multiple_bindings (line 125) | def can_compile_where_raw_and_where_with_multiple_bindings(self): method can_compile_having_raw (line 131) | def can_compile_having_raw(self): method can_compile_select_raw (line 137) | def can_compile_select_raw(self): method can_compile_limit_and_offset (line 143) | def can_compile_limit_and_offset(self): method can_compile_select_raw_with_select (line 149) | def can_compile_select_raw_with_select(self): method can_compile_count (line 155) | def can_compile_count(self): method can_compile_count_column (line 162) | def can_compile_count_column(self): method can_compile_where_column (line 169) | def can_compile_where_column(self): method can_compile_or_where (line 176) | def can_compile_or_where(self): method can_grouped_where (line 184) | def can_grouped_where(self): method can_compile_sub_select (line 190) | def can_compile_sub_select(self): method can_compile_sub_select_where (line 199) | def can_compile_sub_select_where(self): method can_compile_sub_select_value (line 208) | def can_compile_sub_select_value(self): method can_compile_complex_sub_select (line 217) | def can_compile_complex_sub_select(self): method can_compile_exists (line 228) | def can_compile_exists(self): method can_compile_not_exists (line 236) | def can_compile_not_exists(self): method can_compile_having (line 244) | def can_compile_having(self): method can_compile_having_order (line 250) | def can_compile_having_order(self): method can_compile_having_with_expression (line 256) | def can_compile_having_with_expression(self): method can_compile_having_with_greater_than_expression (line 262) | def can_compile_having_with_greater_than_expression(self): method can_compile_join (line 268) | def can_compile_join(self): method can_compile_left_join (line 274) | def can_compile_left_join(self): method can_compile_multiple_join (line 280) | def can_compile_multiple_join(self): method can_compile_between (line 286) | def can_compile_between(self): method can_compile_not_between (line 292) | def can_compile_not_between(self): method test_can_compile_where_raw (line 298) | def test_can_compile_where_raw(self): method test_can_compile_having_raw (line 302) | def test_can_compile_having_raw(self): method test_can_compile_having_raw_order (line 312) | def test_can_compile_having_raw_order(self): method test_can_compile_select_raw (line 324) | def test_can_compile_select_raw(self): method test_can_compile_select_raw_with_select (line 328) | def test_can_compile_select_raw_with_select(self): method can_compile_first_or_fail (line 332) | def can_compile_first_or_fail(self): method where_not_like (line 339) | def where_not_like(self): method where_regexp (line 346) | def where_regexp(self): method where_not_regexp (line 353) | def where_not_regexp(self): method where_like (line 360) | def where_like(self): method can_compile_join_clause (line 367) | def can_compile_join_clause(self): method can_compile_join_clause_with_value (line 380) | def can_compile_join_clause_with_value(self): method can_compile_join_clause_with_null (line 392) | def can_compile_join_clause_with_null(self): method can_compile_join_clause_with_not_null (line 405) | def can_compile_join_clause_with_not_null(self): method can_compile_join_clause_with_lambda (line 418) | def can_compile_join_clause_with_lambda(self): method can_compile_left_join_clause_with_lambda (line 431) | def can_compile_left_join_clause_with_lambda(self): method can_compile_right_join_clause_with_lambda (line 444) | def can_compile_right_join_clause_with_lambda(self): method shared_lock (line 457) | def shared_lock(self): method update_lock (line 464) | def update_lock(self): method can_user_where_raw_and_where (line 471) | def can_user_where_raw_and_where(self): method where_exists_with_lambda (line 477) | def where_exists_with_lambda(self): method where_not_exists_with_lambda (line 480) | def where_not_exists_with_lambda(self): method where_date (line 483) | def where_date(self): method or_where_null (line 488) | def or_where_null(self): method select_distinct (line 491) | def select_distinct(self): FILE: tests/mysql/grammar/test_mysql_update_grammar.py class BaseTestCaseUpdateGrammar (line 9) | class BaseTestCaseUpdateGrammar: method setUp (line 10) | def setUp(self): method test_can_compile_update (line 13) | def test_can_compile_update(self): method test_can_compile_multiple_update (line 23) | def test_can_compile_multiple_update(self): method test_can_compile_update_with_multiple_where (line 33) | def test_can_compile_update_with_multiple_where(self): method test_raw_expression (line 62) | def test_raw_expression(self): class TestMySQLUpdateGrammar (line 72) | class TestMySQLUpdateGrammar(BaseTestCaseUpdateGrammar, unittest.TestCase): method can_compile_update (line 75) | def can_compile_update(self): method raw_expression (line 83) | def raw_expression(self): method can_compile_multiple_update (line 91) | def can_compile_multiple_update(self): method can_compile_update_with_multiple_where (line 97) | def can_compile_update_with_multiple_where(self): method can_compile_increment (line 105) | def can_compile_increment(self): method can_compile_decrement (line 111) | def can_compile_decrement(self): FILE: tests/mysql/model/test_accessors_and_mutators.py class User (line 14) | class User(Model): method get_name_attribute (line 17) | def get_name_attribute(self): method set_name_attribute (line 20) | def set_name_attribute(self, attribute): class SetUser (line 24) | class SetUser(Model): method set_name_attribute (line 27) | def set_name_attribute(self, attribute): class TestAccessor (line 31) | class TestAccessor(unittest.TestCase): method test_can_get_accessor (line 32) | def test_can_get_accessor(self): method test_mutator (line 40) | def test_mutator(self): FILE: tests/mysql/model/test_model.py class ProfileFillable (line 14) | class ProfileFillable(Model): class ProfileFillTimeStamped (line 20) | class ProfileFillTimeStamped(Model): class ProfileFillAsterisk (line 25) | class ProfileFillAsterisk(Model): class ProfileGuarded (line 31) | class ProfileGuarded(Model): class ProfileGuardedAsterisk (line 37) | class ProfileGuardedAsterisk(Model): class ProfileSerialize (line 43) | class ProfileSerialize(Model): class ProfileSerializeWithVisible (line 49) | class ProfileSerializeWithVisible(Model): class ProfileSerializeWithVisibleAndHidden (line 55) | class ProfileSerializeWithVisibleAndHidden(Model): class Profile (line 62) | class Profile(Model): class Company (line 66) | class Company(Model): class User (line 70) | class User(Model): method meta (line 72) | def meta(self): class ProductNames (line 76) | class ProductNames(Model): class TestModel (line 80) | class TestModel(unittest.TestCase): method test_create_can_use_fillable (line 81) | def test_create_can_use_fillable(self): method test_create_can_use_fillable_asterisk (line 90) | def test_create_can_use_fillable_asterisk(self): method test_create_can_use_guarded (line 100) | def test_create_can_use_guarded(self): method test_create_can_use_guarded_asterisk (line 109) | def test_create_can_use_guarded_asterisk(self): method test_bulk_create_can_use_fillable (line 118) | def test_bulk_create_can_use_fillable(self): method test_bulk_create_can_use_fillable_asterisk (line 132) | def test_bulk_create_can_use_fillable_asterisk(self): method test_bulk_create_can_use_guarded (line 146) | def test_bulk_create_can_use_guarded(self): method test_bulk_create_can_use_guarded_asterisk (line 160) | def test_bulk_create_can_use_guarded_asterisk(self): method test_update_can_use_fillable (line 176) | def test_update_can_use_fillable(self): method test_update_can_use_fillable_asterisk (line 185) | def test_update_can_use_fillable_asterisk(self): method test_update_can_use_guarded (line 195) | def test_update_can_use_guarded(self): method test_update_can_use_guarded_asterisk (line 204) | def test_update_can_use_guarded_asterisk(self): method test_table_name (line 215) | def test_table_name(self): method test_serialize (line 225) | def test_serialize(self): method test_json (line 230) | def test_json(self): method test_serialize_with_hidden (line 235) | def test_serialize_with_hidden(self): method test_serialize_with_visible (line 244) | def test_serialize_with_visible(self): method test_serialize_with_visible_and_hidden_raise_error (line 252) | def test_serialize_with_visible_and_hidden_raise_error(self): method test_serialize_with_on_the_fly_appends (line 259) | def test_serialize_with_on_the_fly_appends(self): method test_serialize_with_model_appends (line 269) | def test_serialize_with_model_appends(self): method test_serialize_with_date (line 277) | def test_serialize_with_date(self): method test_set_as_date (line 282) | def test_set_as_date(self): method test_access_as_date (line 293) | def test_access_as_date(self): method test_hydrate_with_none (line 304) | def test_hydrate_with_none(self): method test_serialize_with_dirty_attribute (line 309) | def test_serialize_with_dirty_attribute(self): method test_attribute_check_with_hasattr (line 315) | def test_attribute_check_with_hasattr(self): class MysqlTestModel (line 321) | class MysqlTestModel(unittest.TestCase): method test_can_find_first (line 323) | def test_can_find_first(self): method test_can_touch (line 326) | def test_can_touch(self): method test_find_or_fail_raise_an_exception_if_not_exists (line 336) | def test_find_or_fail_raise_an_exception_if_not_exists(self): method test_returns_correct_data_type (line 340) | def test_returns_correct_data_type(self): FILE: tests/mysql/relationships/test_belongs_to_many.py class User (line 16) | class User(Model): method profile (line 18) | def profile(self): class Profile (line 22) | class Profile(Model): class Permission (line 26) | class Permission(Model): method role (line 28) | def role(self): class PermissionSelect (line 32) | class PermissionSelect(Model): method role (line 38) | def role(self): class Role (line 42) | class Role(Model): method permissions (line 44) | def permissions(self): class MySQLRelationships (line 48) | class MySQLRelationships(unittest.TestCase): method test_belongs_to_many (line 51) | def test_belongs_to_many(self): method test_belongs_to_many_has (line 61) | def test_belongs_to_many_has(self): method test_belongs_to_many_or_has (line 69) | def test_belongs_to_many_or_has(self): method test_belongs_to_many_or_where_has (line 77) | def test_belongs_to_many_or_where_has(self): method test_belongs_to_many_or_doesnt_have (line 89) | def test_belongs_to_many_or_doesnt_have(self): method test_where_doesnt_have (line 97) | def test_where_doesnt_have(self): method test_or_where_doesnt_have (line 111) | def test_or_where_doesnt_have(self): method test_belongs_to_many_where_has (line 125) | def test_belongs_to_many_where_has(self): method test_belongs_to_many_relate_method (line 135) | def test_belongs_to_many_relate_method(self): method test_belongs_to_many_relate_method_reversed (line 144) | def test_belongs_to_many_relate_method_reversed(self): method test_belongs_to_many_joins (line 153) | def test_belongs_to_many_joins(self): method test_with_count (line 160) | def test_with_count(self): method test_with_count_with_selects (line 168) | def test_with_count_with_selects(self): FILE: tests/mysql/relationships/test_has_many_through.py class InboundShipment (line 12) | class InboundShipment(Model): method from_country (line 14) | def from_country(self): class Country (line 18) | class Country(Model): class Port (line 22) | class Port(Model): class MySQLRelationships (line 26) | class MySQLRelationships(unittest.TestCase): method test_has_query (line 29) | def test_has_query(self): method test_or_has (line 37) | def test_or_has(self): method test_where_has_query (line 45) | def test_where_has_query(self): method test_or_where_has (line 55) | def test_or_where_has(self): method test_doesnt_have (line 67) | def test_doesnt_have(self): method test_or_where_doesnt_have (line 75) | def test_or_where_doesnt_have(self): FILE: tests/mysql/relationships/test_has_one_through.py class InboundShipment (line 12) | class InboundShipment(Model): method from_country (line 14) | def from_country(self): class Country (line 18) | class Country(Model): class Port (line 22) | class Port(Model): class MySQLHasOneThroughRelationship (line 26) | class MySQLHasOneThroughRelationship(unittest.TestCase): method test_has_query (line 29) | def test_has_query(self): method test_or_has (line 37) | def test_or_has(self): method test_where_has_query (line 45) | def test_where_has_query(self): method test_or_where_has (line 55) | def test_or_where_has(self): method test_doesnt_have (line 67) | def test_doesnt_have(self): method test_or_where_doesnt_have (line 75) | def test_or_where_doesnt_have(self): method test_has_one_through_with_count (line 89) | def test_has_one_through_with_count(self): FILE: tests/mysql/relationships/test_relationships.py class User (line 15) | class User(Model): method profile (line 17) | def profile(self): class Profile (line 21) | class Profile(Model): method identification (line 23) | def identification(self): class Identification (line 27) | class Identification(Model): class MySQLRelationships (line 31) | class MySQLRelationships(unittest.TestCase): method test_has (line 34) | def test_has(self): method test_has_nested (line 41) | def test_has_nested(self): method test_or_has (line 48) | def test_or_has(self): method test_or_has_nested (line 56) | def test_or_has_nested(self): method test_relationship_where_has (line 64) | def test_relationship_where_has(self): method test_relationship_where_has_nested (line 76) | def test_relationship_where_has_nested(self): method test_relationship_or_where_has (line 90) | def test_relationship_or_where_has(self): method test_relationship_or_where_has_nested (line 102) | def test_relationship_or_where_has_nested(self): method test_relationship_doesnt_have (line 116) | def test_relationship_doesnt_have(self): method test_relationship_doesnt_have_nested (line 124) | def test_relationship_doesnt_have_nested(self): method test_relationship_where_doesnt_have (line 132) | def test_relationship_where_doesnt_have(self): method test_relationship_where_doesnt_have_nested (line 142) | def test_relationship_where_doesnt_have_nested(self): method test_relationship_or_where_doesnt_have (line 152) | def test_relationship_or_where_doesnt_have(self): method test_relationship_or_where_doesnt_have_nested (line 162) | def test_relationship_or_where_doesnt_have_nested(self): method test_joins (line 172) | def test_joins(self): method test_join_on (line 179) | def test_join_on(self): FILE: tests/mysql/schema/test_mysql_schema_builder.py class Discussion (line 13) | class Discussion(Model): class TestMySQLSchemaBuilder (line 17) | class TestMySQLSchemaBuilder(unittest.TestCase): method setUp (line 20) | def setUp(self): method test_can_add_columns1 (line 29) | def test_can_add_columns1(self): method test_can_add_tiny_text (line 42) | def test_can_add_tiny_text(self): method test_can_add_unsigned_decimal (line 52) | def test_can_add_unsigned_decimal(self): method test_can_create_table_if_not_exists (line 62) | def test_can_create_table_if_not_exists(self): method test_can_add_columns_with_constaint (line 75) | def test_can_add_columns_with_constaint(self): method test_add_column_comment (line 90) | def test_add_column_comment(self): method test_can_add_table_comment (line 102) | def test_can_add_table_comment(self): method test_can_add_columns_with_foreign_key_constaint (line 115) | def test_can_add_columns_with_foreign_key_constaint(self): method test_can_add_columns_with_foreign_key_constaint (line 139) | def test_can_add_columns_with_foreign_key_constaint(self): method test_can_advanced_table_creation (line 158) | def test_can_advanced_table_creation(self): method test_can_add_primary_constraint_without_column_name (line 187) | def test_can_add_primary_constraint_without_column_name(self): method test_can_advanced_table_creation2 (line 202) | def test_can_advanced_table_creation2(self): method test_can_add_columns_with_foreign_key_constraint_name (line 233) | def test_can_add_columns_with_foreign_key_constraint_name(self): method test_can_have_composite_keys (line 250) | def test_can_have_composite_keys(self): method test_can_have_column_primary_key (line 271) | def test_can_have_column_primary_key(self): method test_can_have_unsigned_columns (line 289) | def test_can_have_unsigned_columns(self): method test_can_have_default_blank_string (line 313) | def test_can_have_default_blank_string(self): method test_can_have_float_type (line 322) | def test_can_have_float_type(self): method test_has_table (line 331) | def test_has_table(self): method test_can_truncate (line 338) | def test_can_truncate(self): method test_can_rename_table (line 343) | def test_can_rename_table(self): method test_can_drop_table_if_exists (line 348) | def test_can_drop_table_if_exists(self): method test_can_drop_table (line 353) | def test_can_drop_table(self): method test_has_column (line 358) | def test_has_column(self): method test_can_enable_foreign_keys (line 366) | def test_can_enable_foreign_keys(self): method test_can_disable_foreign_keys (line 371) | def test_can_disable_foreign_keys(self): method test_can_truncate_without_foreign_keys (line 376) | def test_can_truncate_without_foreign_keys(self): method test_can_add_enum (line 388) | def test_can_add_enum(self): FILE: tests/mysql/schema/test_mysql_schema_builder_alter.py class TestMySQLSchemaBuilderAlter (line 11) | class TestMySQLSchemaBuilderAlter(unittest.TestCase): method setUp (line 14) | def setUp(self): method test_can_add_columns (line 23) | def test_can_add_columns(self): method test_can_add_column_comments (line 36) | def test_can_add_column_comments(self): method test_can_add_table_comment (line 46) | def test_can_add_table_comment(self): method test_can_add_table_comment_with_no_columns (line 57) | def test_can_add_table_comment_with_no_columns(self): method test_can_add_column_after (line 67) | def test_can_add_column_after(self): method test_alter_rename (line 77) | def test_alter_rename(self): method test_alter_add_and_rename (line 89) | def test_alter_add_and_rename(self): method test_alter_add_and_rename_to_string (line 105) | def test_alter_add_and_rename_to_string(self): method test_alter_drop1 (line 121) | def test_alter_drop1(self): method test_alter_add_column_and_foreign_key (line 129) | def test_alter_add_column_and_foreign_key(self): method test_alter_drop_foreign_key (line 143) | def test_alter_drop_foreign_key(self): method test_alter_drop_foreign_key_shortcut (line 151) | def test_alter_drop_foreign_key_shortcut(self): method test_alter_drop_unique_constraint (line 159) | def test_alter_drop_unique_constraint(self): method test_alter_add_index (line 167) | def test_alter_add_index(self): method test_alter_drop_index (line 175) | def test_alter_drop_index(self): method test_alter_add_primary (line 183) | def test_alter_add_primary(self): method test_alter_drop_index_shortcut (line 193) | def test_alter_drop_index_shortcut(self): method test_alter_drop_unique_constraint_shortcut (line 201) | def test_alter_drop_unique_constraint_shortcut(self): method test_alter_drop_primary (line 209) | def test_alter_drop_primary(self): method test_change (line 217) | def test_change(self): method test_timestamp_alter_add_nullable_column (line 238) | def test_timestamp_alter_add_nullable_column(self): method test_drop_add_and_change (line 253) | def test_drop_add_and_change(self): method test_can_create_indexes (line 275) | def test_can_create_indexes(self): method test_can_add_column_enum (line 298) | def test_can_add_column_enum(self): method test_can_change_column_enum (line 310) | def test_can_change_column_enum(self): FILE: tests/mysql/scopes/test_can_use_global_scopes.py class UserSoft (line 13) | class UserSoft(Model, SoftDeletesMixin): class User (line 17) | class User(Model): class TestMySQLGlobalScopes (line 21) | class TestMySQLGlobalScopes(unittest.TestCase): method test_can_use_global_scopes_on_select (line 22) | def test_can_use_global_scopes_on_select(self): method test_can_use_global_scopes_on_time (line 36) | def test_can_use_global_scopes_on_time(self): FILE: tests/mysql/scopes/test_can_use_scopes.py class User (line 9) | class User(Model): method active (line 13) | def active(self, query, status): method gender (line 17) | def gender(self, query, status): class UserSoft (line 21) | class UserSoft(Model, SoftDeletesMixin): class TestMySQLScopes (line 25) | class TestMySQLScopes(unittest.TestCase): method test_can_get_sql (line 26) | def test_can_get_sql(self): method test_active_scope (line 30) | def test_active_scope(self): method test_active_scope_with_params (line 34) | def test_active_scope_with_params(self): method test_can_chain_scopes (line 38) | def test_can_chain_scopes(self): FILE: tests/mysql/scopes/test_soft_delete.py class UserSoft (line 15) | class UserSoft(Model, SoftDeletesMixin): class UserSoftArchived (line 19) | class UserSoftArchived(Model, SoftDeletesMixin): class TestSoftDeleteScope (line 25) | class TestSoftDeleteScope(unittest.TestCase): method get_builder (line 26) | def get_builder(self, table="users"): method test_with_trashed (line 37) | def test_with_trashed(self): method test_force_delete (line 42) | def test_force_delete(self): method test_restore (line 47) | def test_restore(self): method test_force_delete_with_wheres (line 52) | def test_force_delete_with_wheres(self): method test_that_trashed_users_are_not_returned_by_default (line 59) | def test_that_trashed_users_are_not_returned_by_default(self): method test_only_trashed (line 64) | def test_only_trashed(self): method test_only_trashed_on_model (line 69) | def test_only_trashed_on_model(self): method test_can_change_column (line 73) | def test_can_change_column(self): method test_find_with_global_scope (line 77) | def test_find_with_global_scope(self): method test_find_with_trashed_scope (line 82) | def test_find_with_trashed_scope(self): method test_find_with_only_trashed_scope (line 87) | def test_find_with_only_trashed_scope(self): FILE: tests/postgres/builder/test_postgres_query_builder.py class MockConnection (line 11) | class MockConnection: method make_connection (line 14) | def make_connection(self): method get_default_query_grammar (line 18) | def get_default_query_grammar(cls): class ModelTest (line 22) | class ModelTest(Model): class BaseTestQueryBuilder (line 26) | class BaseTestQueryBuilder: method get_builder (line 27) | def get_builder(self, table="users", dry=True): method test_sum (line 38) | def test_sum(self): method test_where_like (line 47) | def test_where_like(self): method test_where_not_like (line 56) | def test_where_not_like(self): method test_max (line 65) | def test_max(self): method test_min (line 74) | def test_min(self): method test_avg (line 83) | def test_avg(self): method test_all (line 91) | def test_all(self): method test_get (line 99) | def test_get(self): method test_first (line 107) | def test_first(self): method test_select (line 114) | def test_select(self): method test_add_select_no_table (line 122) | def test_add_select_no_table(self): method test_select_raw (line 138) | def test_select_raw(self): method test_create (line 146) | def test_create(self): method test_delete (line 156) | def test_delete(self): method test_where (line 164) | def test_where(self): method test_where_exists (line 172) | def test_where_exists(self): method test_limit (line 180) | def test_limit(self): method test_offset (line 188) | def test_offset(self): method test_join (line 196) | def test_join(self): method test_left_join (line 204) | def test_left_join(self): method test_right_join (line 212) | def test_right_join(self): method test_update (line 220) | def test_update(self): method test_count (line 245) | def test_count(self): method test_order_by_asc (line 253) | def test_order_by_asc(self): method test_order_by_desc (line 261) | def test_order_by_desc(self): method test_where_column (line 269) | def test_where_column(self): method test_where_not_in (line 277) | def test_where_not_in(self): method test_between (line 285) | def test_between(self): method test_not_between (line 293) | def test_not_between(self): method test_where_in (line 301) | def test_where_in(self): method test_where_null (line 310) | def test_where_null(self): method test_where_not_null (line 319) | def test_where_not_null(self): method test_having (line 328) | def test_having(self): method test_group_by (line 339) | def test_group_by(self): method test_builder_alone (line 348) | def test_builder_alone(self): method test_where_lt (line 369) | def test_where_lt(self): method test_where_lte (line 377) | def test_where_lte(self): method test_where_gt (line 385) | def test_where_gt(self): method test_where_gte (line 393) | def test_where_gte(self): method test_where_ne (line 401) | def test_where_ne(self): method test_or_where (line 409) | def test_or_where(self): method test_can_call_with_schema (line 417) | def test_can_call_with_schema(self): method test_truncate (line 430) | def test_truncate(self): method test_truncate_without_foreign_keys (line 438) | def test_truncate_without_foreign_keys(self): method test_shared_lock (line 446) | def test_shared_lock(self): method test_update_lock (line 454) | def test_update_lock(self): class PostgresQueryBuilderTest (line 463) | class PostgresQueryBuilderTest(BaseTestQueryBuilder, unittest.TestCase): method sum (line 466) | def sum(self): method max (line 473) | def max(self): method min (line 480) | def min(self): method avg (line 487) | def avg(self): method first (line 494) | def first(self): method all (line 501) | def all(self): method get (line 508) | def get(self): method select (line 515) | def select(self): method add_select_no_table (line 522) | def add_select_no_table(self): method select_raw (line 533) | def select_raw(self): method create (line 540) | def create(self): method delete (line 547) | def delete(self): method where (line 554) | def where(self): method where_exists (line 561) | def where_exists(self): method limit (line 568) | def limit(self): method offset (line 575) | def offset(self): method join (line 582) | def join(self): method left_join (line 588) | def left_join(self): method right_join (line 594) | def right_join(self): method update (line 600) | def update(self): method increment (line 606) | def increment(self): method decrement (line 612) | def decrement(self): method count (line 618) | def count(self): method order_by_asc (line 624) | def order_by_asc(self): method order_by_desc (line 630) | def order_by_desc(self): method where_column (line 636) | def where_column(self): method where_null (line 642) | def where_null(self): method where_not_null (line 648) | def where_not_null(self): method where_not_in (line 654) | def where_not_in(self): method where_in (line 660) | def where_in(self): method between (line 666) | def between(self): method not_between (line 672) | def not_between(self): method having (line 678) | def having(self): method group_by (line 684) | def group_by(self): method where_lt (line 690) | def where_lt(self): method where_lte (line 697) | def where_lte(self): method where_gt (line 704) | def where_gt(self): method where_gte (line 711) | def where_gte(self): method where_ne (line 718) | def where_ne(self): method or_where (line 725) | def or_where(self): method where_like (line 732) | def where_like(self): method where_not_like (line 739) | def where_not_like(self): method truncate (line 746) | def truncate(self): method truncate_without_foreign_keys (line 753) | def truncate_without_foreign_keys(self): method update_lock (line 760) | def update_lock(self): method shared_lock (line 767) | def shared_lock(self): method test_latest (line 774) | def test_latest(self): method test_oldest (line 782) | def test_oldest(self): method oldest (line 790) | def oldest(self): method latest (line 796) | def latest(self): FILE: tests/postgres/builder/test_postgres_transaction.py class User (line 15) | class User(Model): class BaseTestQueryRelationships (line 19) | class BaseTestQueryRelationships(unittest.TestCase): method get_builder (line 22) | def get_builder(self, table="users"): method test_transaction (line 31) | def test_transaction(self): FILE: tests/postgres/grammar/test_delete_grammar.py class BaseDeleteGrammarTest (line 8) | class BaseDeleteGrammarTest: method setUp (line 9) | def setUp(self): method test_can_compile_delete (line 12) | def test_can_compile_delete(self): method test_can_compile_delete_in (line 20) | def test_can_compile_delete_in(self): method test_can_compile_delete_with_where (line 28) | def test_can_compile_delete_with_where(self): class TestPostgresDeleteGrammar (line 43) | class TestPostgresDeleteGrammar(BaseDeleteGrammarTest, unittest.TestCase): method can_compile_delete (line 46) | def can_compile_delete(self): method can_compile_delete_in (line 56) | def can_compile_delete_in(self): method can_compile_delete_with_where (line 66) | def can_compile_delete_with_where(self): FILE: tests/postgres/grammar/test_insert_grammar.py class BaseInsertGrammarTest (line 8) | class BaseInsertGrammarTest: method setUp (line 9) | def setUp(self): method test_can_compile_insert (line 12) | def test_can_compile_insert(self): method test_can_compile_insert_with_keywords (line 20) | def test_can_compile_insert_with_keywords(self): method test_can_compile_bulk_create (line 28) | def test_can_compile_bulk_create(self): method test_can_compile_bulk_create_qmark (line 44) | def test_can_compile_bulk_create_qmark(self): class TestPostgresUpdateGrammar (line 55) | class TestPostgresUpdateGrammar(BaseInsertGrammarTest, unittest.TestCase): method can_compile_insert (line 58) | def can_compile_insert(self): method can_compile_insert_with_keywords (line 66) | def can_compile_insert_with_keywords(self): method can_compile_bulk_create (line 72) | def can_compile_bulk_create(self): method can_compile_bulk_create_qmark (line 78) | def can_compile_bulk_create_qmark(self): FILE: tests/postgres/grammar/test_select_grammar.py class TestPostgresGrammar (line 8) | class TestPostgresGrammar(BaseTestCaseSelectGrammar, unittest.TestCase): method can_compile_select (line 11) | def can_compile_select(self): method can_compile_with_columns (line 17) | def can_compile_with_columns(self): method can_compile_with_where (line 23) | def can_compile_with_where(self): method can_compile_with_several_where (line 29) | def can_compile_with_several_where(self): method can_compile_with_several_where_and_limit (line 35) | def can_compile_with_several_where_and_limit(self): method can_compile_with_sum (line 41) | def can_compile_with_sum(self): method can_compile_with_max (line 47) | def can_compile_with_max(self): method can_compile_with_max_and_columns (line 53) | def can_compile_with_max_and_columns(self): method can_compile_with_max_and_columns_different_order (line 59) | def can_compile_with_max_and_columns_different_order(self): method can_compile_with_order_by (line 65) | def can_compile_with_order_by(self): method can_compile_with_multiple_order_by (line 71) | def can_compile_with_multiple_order_by(self): method can_compile_with_group_by (line 79) | def can_compile_with_group_by(self): method can_compile_where_in (line 85) | def can_compile_where_in(self): method can_compile_where_in_empty (line 91) | def can_compile_where_in_empty(self): method can_compile_where_not_in (line 97) | def can_compile_where_not_in(self): method can_compile_where_null (line 103) | def can_compile_where_null(self): method can_compile_where_not_null (line 109) | def can_compile_where_not_null(self): method can_compile_where_raw (line 117) | def can_compile_where_raw(self): method can_compile_having_raw (line 123) | def can_compile_having_raw(self): method can_compile_select_raw (line 129) | def can_compile_select_raw(self): method can_compile_limit_and_offset (line 135) | def can_compile_limit_and_offset(self): method can_compile_select_raw_with_select (line 141) | def can_compile_select_raw_with_select(self): method can_compile_count (line 147) | def can_compile_count(self): method can_compile_count_column (line 154) | def can_compile_count_column(self): method can_compile_where_column (line 161) | def can_compile_where_column(self): method can_compile_or_where (line 168) | def can_compile_or_where(self): method can_grouped_where (line 174) | def can_grouped_where(self): method can_compile_sub_select (line 180) | def can_compile_sub_select(self): method can_compile_sub_select_from_lambda (line 189) | def can_compile_sub_select_from_lambda(self): method can_compile_sub_select_where (line 198) | def can_compile_sub_select_where(self): method can_compile_sub_select_value (line 207) | def can_compile_sub_select_value(self): method can_compile_complex_sub_select (line 216) | def can_compile_complex_sub_select(self): method can_compile_exists (line 227) | def can_compile_exists(self): method can_compile_not_exists (line 235) | def can_compile_not_exists(self): method can_compile_having (line 243) | def can_compile_having(self): method can_compile_having_order (line 249) | def can_compile_having_order(self): method can_compile_having_with_expression (line 255) | def can_compile_having_with_expression(self): method can_compile_order_by_and_first (line 261) | def can_compile_order_by_and_first(self): method can_compile_having_with_greater_than_expression (line 267) | def can_compile_having_with_greater_than_expression(self): method can_compile_join (line 273) | def can_compile_join(self): method can_compile_left_join (line 279) | def can_compile_left_join(self): method can_compile_multiple_join (line 285) | def can_compile_multiple_join(self): method can_compile_between (line 291) | def can_compile_between(self): method can_compile_not_between (line 297) | def can_compile_not_between(self): method test_can_compile_where_raw (line 303) | def test_can_compile_where_raw(self): method test_can_compile_having_raw (line 307) | def test_can_compile_having_raw(self): method test_can_compile_having_raw_order (line 317) | def test_can_compile_having_raw_order(self): method test_can_compile_where_raw_and_where_with_multiple_bindings (line 329) | def test_can_compile_where_raw_and_where_with_multiple_bindings(self): method test_can_compile_select_raw (line 339) | def test_can_compile_select_raw(self): method test_can_compile_select_raw_with_select (line 343) | def test_can_compile_select_raw_with_select(self): method can_compile_first_or_fail (line 347) | def can_compile_first_or_fail(self): method where_not_like (line 354) | def where_not_like(self): method where_like (line 361) | def where_like(self): method where_regexp (line 368) | def where_regexp(self): method where_not_regexp (line 375) | def where_not_regexp(self): method can_compile_join_clause (line 382) | def can_compile_join_clause(self): method can_compile_join_clause_with_value (line 395) | def can_compile_join_clause_with_value(self): method can_compile_join_clause_with_null (line 407) | def can_compile_join_clause_with_null(self): method can_compile_join_clause_with_not_null (line 420) | def can_compile_join_clause_with_not_null(self): method can_compile_join_clause_with_lambda (line 433) | def can_compile_join_clause_with_lambda(self): method can_compile_left_join_clause_with_lambda (line 446) | def can_compile_left_join_clause_with_lambda(self): method can_compile_right_join_clause_with_lambda (line 459) | def can_compile_right_join_clause_with_lambda(self): method shared_lock (line 472) | def shared_lock(self): method update_lock (line 479) | def update_lock(self): method can_user_where_raw_and_where (line 486) | def can_user_where_raw_and_where(self): method where_exists_with_lambda (line 492) | def where_exists_with_lambda(self): method where_not_exists_with_lambda (line 495) | def where_not_exists_with_lambda(self): method where_date (line 498) | def where_date(self): method or_where_null (line 503) | def or_where_null(self): method select_distinct (line 506) | def select_distinct(self): FILE: tests/postgres/grammar/test_update_grammar.py class BaseTestCaseUpdateGrammar (line 10) | class BaseTestCaseUpdateGrammar: method setUp (line 11) | def setUp(self): method test_can_compile_update (line 16) | def test_can_compile_update(self): method test_can_compile_multiple_update (line 26) | def test_can_compile_multiple_update(self): method test_can_compile_update_with_multiple_where (line 36) | def test_can_compile_update_with_multiple_where(self): method test_raw_expression (line 65) | def test_raw_expression(self): method test_update_null (line 74) | def test_update_null(self): class TestPostgresUpdateGrammar (line 83) | class TestPostgresUpdateGrammar(BaseTestCaseUpdateGrammar, unittest.Test... method can_compile_update (line 86) | def can_compile_update(self): method raw_expression (line 94) | def raw_expression(self): method can_compile_multiple_update (line 102) | def can_compile_multiple_update(self): method can_compile_update_with_multiple_where (line 108) | def can_compile_update_with_multiple_where(self): method can_compile_increment (line 116) | def can_compile_increment(self): method can_compile_decrement (line 122) | def can_compile_decrement(self): FILE: tests/postgres/relationships/test_postgres_relationships.py class Profile (line 9) | class Profile(Model): class Articles (line 13) | class Articles(Model): method logo (line 18) | def logo(self): class Logo (line 21) | class Logo(Model): class User (line 25) | class User(Model): method profile (line 33) | def profile(self): method articles (line 37) | def articles(self): method get_is_admin (line 40) | def get_is_admin(self): class TestRelationships (line 43) | class TestRelationships(unittest.TestCase): method test_relationship_can_be_callable (line 46) | def test_relationship_can_be_callable(self): method test_can_access_relationship (line 52) | def test_can_access_relationship(self): method test_can_access_has_many_relationship (line 56) | def test_can_access_has_many_relationship(self): method test_can_access_relationship_multiple_times (line 60) | def test_can_access_relationship_multiple_times(self): method test_loading (line 65) | def test_loading(self): method test_casting (line 70) | def test_casting(self): method test_setting (line 75) | def test_setting(self): method test_relationship_has (line 82) | def test_relationship_has(self): method test_relationship_has_off_builder (line 91) | def test_relationship_has_off_builder(self): method test_relationship_multiple_has (line 100) | def test_relationship_multiple_has(self): method test_nested_has (line 114) | def test_nested_has(self): method test_relationship_where_has (line 124) | def test_relationship_where_has(self): FILE: tests/postgres/schema/test_postgres_schema_builder.py class TestPostgresSchemaBuilder (line 9) | class TestPostgresSchemaBuilder(unittest.TestCase): method setUp (line 12) | def setUp(self): method test_can_add_columns (line 21) | def test_can_add_columns(self): method test_can_add_tiny_text (line 34) | def test_can_add_tiny_text(self): method test_can_add_unsigned_decimal (line 43) | def test_can_add_unsigned_decimal(self): method test_can_create_table_if_not_exists (line 53) | def test_can_create_table_if_not_exists(self): method test_can_add_column_comment (line 66) | def test_can_add_column_comment(self): method test_can_add_table_comment (line 79) | def test_can_add_table_comment(self): method test_can_truncate (line 93) | def test_can_truncate(self): method test_can_rename_table (line 98) | def test_can_rename_table(self): method test_can_drop_table_if_exists (line 103) | def test_can_drop_table_if_exists(self): method test_can_drop_table (line 108) | def test_can_drop_table(self): method test_has_column (line 113) | def test_has_column(self): method test_can_add_columns_with_constaint (line 121) | def test_can_add_columns_with_constaint(self): method test_can_add_columns_with_long_text (line 135) | def test_can_add_columns_with_long_text(self): method test_can_have_unsigned_columns (line 144) | def test_can_have_unsigned_columns(self): method test_can_add_columns_with_foreign_key_constaint (line 164) | def test_can_add_columns_with_foreign_key_constaint(self): method test_can_advanced_table_creation (line 181) | def test_can_advanced_table_creation(self): method test_can_advanced_table_creation2 (line 204) | def test_can_advanced_table_creation2(self): method test_can_add_uuid_column (line 243) | def test_can_add_uuid_column(self): method test_can_add_columns_with_foreign_key_constraint_name (line 261) | def test_can_add_columns_with_foreign_key_constraint_name(self): method test_can_have_composite_keys (line 278) | def test_can_have_composite_keys(self): method test_can_have_column_primary_key (line 298) | def test_can_have_column_primary_key(self): method test_can_add_other_integer_types_column (line 316) | def test_can_add_other_integer_types_column(self): method test_can_add_binary_column (line 331) | def test_can_add_binary_column(self): method test_can_have_float_type (line 341) | def test_can_have_float_type(self): method test_can_enable_foreign_keys (line 350) | def test_can_enable_foreign_keys(self): method test_can_disable_foreign_keys (line 355) | def test_can_disable_foreign_keys(self): method test_can_truncate_without_foreign_keys (line 360) | def test_can_truncate_without_foreign_keys(self): method test_can_add_enum (line 372) | def test_can_add_enum(self): FILE: tests/postgres/schema/test_postgres_schema_builder_alter.py class TestPostgresSchemaBuilderAlter (line 10) | class TestPostgresSchemaBuilderAlter(unittest.TestCase): method setUp (line 13) | def setUp(self): method test_can_add_columns (line 22) | def test_can_add_columns(self): method test_can_add_column_comments (line 35) | def test_can_add_column_comments(self): method test_can_add_table_comment (line 48) | def test_can_add_table_comment(self): method test_alter_rename (line 62) | def test_alter_rename(self): method test_alter_add_and_rename (line 74) | def test_alter_add_and_rename(self): method test_alter_drop (line 90) | def test_alter_drop(self): method test_alter_add_column_and_foreign_key (line 98) | def test_alter_add_column_and_foreign_key(self): method test_can_create_indexes (line 112) | def test_can_create_indexes(self): method test_alter_drop_foreign_key (line 131) | def test_alter_drop_foreign_key(self): method test_alter_drop_foreign_key_shortcut (line 139) | def test_alter_drop_foreign_key_shortcut(self): method test_alter_drop_unique_constraint (line 147) | def test_alter_drop_unique_constraint(self): method test_alter_add_index (line 155) | def test_alter_add_index(self): method test_alter_add_primary (line 163) | def test_alter_add_primary(self): method test_alter_drop_index (line 173) | def test_alter_drop_index(self): method test_alter_drop_index_shortcut (line 181) | def test_alter_drop_index_shortcut(self): method test_alter_drop_primary (line 189) | def test_alter_drop_primary(self): method test_alter_drop_unique_constraint_shortcut (line 197) | def test_alter_drop_unique_constraint_shortcut(self): method test_has_table (line 205) | def test_has_table(self): method test_drop_table (line 212) | def test_drop_table(self): method test_change (line 219) | def test_change(self): method test_change_string (line 238) | def test_change_string(self): method test_drop_add_and_change (line 254) | def test_drop_add_and_change(self): method test_timestamp_alter_add_nullable_column (line 277) | def test_timestamp_alter_add_nullable_column(self): method test_alter_drop_on_table_schema_table (line 292) | def test_alter_drop_on_table_schema_table(self): method test_can_add_column_enum (line 305) | def test_can_add_column_enum(self): method test_can_change_column_enum (line 317) | def test_can_change_column_enum(self): FILE: tests/scopes/test_default_global_scopes.py class MockBuilder (line 16) | class MockBuilder: method __init__ (line 17) | def __init__(self, model): class UserWithUUID (line 23) | class UserWithUUID(Model, UUIDPrimaryKeyMixin): class UserWithTimeStamps (line 27) | class UserWithTimeStamps(Model, TimeStampsMixin): class UserWithCustomTimeStamps (line 31) | class UserWithCustomTimeStamps(Model, TimeStampsMixin): class UserSoft (line 37) | class UserSoft(Model, SoftDeletesMixin): class TestUUIDPrimaryKeyScope (line 41) | class TestUUIDPrimaryKeyScope(unittest.TestCase): method setUp (line 42) | def setUp(self): method test_default_to_uuid4 (line 57) | def test_default_to_uuid4(self): method test_can_set_uuid_version (line 62) | def test_can_set_uuid_version(self): method test_default_to_uuid_str (line 73) | def test_default_to_uuid_str(self): method test_can_set_uuid_bytes (line 78) | def test_can_set_uuid_bytes(self): method test_works_with_custom_pk_column (line 84) | def test_works_with_custom_pk_column(self): class TestSoftDeletesScope (line 90) | class TestSoftDeletesScope(unittest.TestCase): method test_soft_deletes_changes_delete_to_update (line 91) | def test_soft_deletes_changes_delete_to_update(self): class TestTimeStampsScope (line 98) | class TestTimeStampsScope(unittest.TestCase): method setUp (line 99) | def setUp(self): method test_updated_and_created_dates_are_set_when_create (line 107) | def test_updated_and_created_dates_are_set_when_create(self): method test_timestamps_can_be_disabled (line 116) | def test_timestamps_can_be_disabled(self): method test_uses_custom_timestamp_columns_on_create (line 122) | def test_uses_custom_timestamp_columns_on_create(self): method test_uses_custom_updated_column_on_update (line 138) | def test_uses_custom_updated_column_on_update(self): FILE: tests/seeds/test_seeds.py class TestSeeds (line 7) | class TestSeeds(unittest.TestCase): method test_can_run_seeds (line 8) | def test_can_run_seeds(self): FILE: tests/sqlite/builder/test_sqlite_builder_insert.py class User (line 11) | class User(Model): class BaseTestQueryRelationships (line 17) | class BaseTestQueryRelationships(unittest.TestCase): method get_builder (line 20) | def get_builder(self, table="users"): method test_insert (line 30) | def test_insert(self): FILE: tests/sqlite/builder/test_sqlite_builder_pagination.py class User (line 11) | class User(Model): class BaseTestQueryRelationships (line 15) | class BaseTestQueryRelationships(unittest.TestCase): method get_builder (line 18) | def get_builder(self, table="users", model=User()): method test_pagination (line 29) | def test_pagination(self): FILE: tests/sqlite/builder/test_sqlite_query_builder.py class UserMock (line 12) | class UserMock(Model): class BaseTestQueryBuilder (line 17) | class BaseTestQueryBuilder: method get_builder (line 20) | def get_builder(self, table="users"): method test_sum (line 30) | def test_sum(self): method test_sum_aggregate (line 39) | def test_sum_aggregate(self): method test_sum_aggregate_with_alias (line 46) | def test_sum_aggregate_with_alias(self): method test_sum_aggregate_with_alias_in_column_name (line 55) | def test_sum_aggregate_with_alias_in_column_name(self): method test_where_like (line 62) | def test_where_like(self): method test_where_not_like (line 71) | def test_where_not_like(self): method test_max (line 80) | def test_max(self): method test_min (line 89) | def test_min(self): method test_avg (line 98) | def test_avg(self): method test_all (line 106) | def test_all(self): method test_get (line 114) | def test_get(self): method test_first (line 122) | def test_first(self): method test_last (line 129) | def test_last(self): method test_last_with_default_primary_key (line 132) | def test_last_with_default_primary_key(self): method test_first_or_fail_exception (line 135) | def test_first_or_fail_exception(self): method test_find_or_fail_exception (line 139) | def test_find_or_fail_exception(self): method test_find_or_404_exception (line 143) | def test_find_or_404_exception(self): method test_select (line 147) | def test_select(self): method test_select_multiple (line 155) | def test_select_multiple(self): method test_add_select (line 161) | def test_add_select(self): method test_add_select_no_table (line 174) | def test_add_select_no_table(self): method test_add_select_with_raw (line 190) | def test_add_select_with_raw(self): method test_select_raw (line 209) | def test_select_raw(self): method test_create (line 217) | def test_create(self): method test_delete (line 227) | def test_delete(self): method test_where (line 235) | def test_where(self): method test_where_dictionary (line 243) | def test_where_dictionary(self): method test_where_exists (line 249) | def test_where_exists(self): method test_limit (line 257) | def test_limit(self): method test_offset (line 265) | def test_offset(self): method test_offset_with_limit (line 273) | def test_offset_with_limit(self): method test_join (line 281) | def test_join(self): method test_left_join (line 289) | def test_left_join(self): method test_right_join (line 297) | def test_right_join(self): method test_update (line 305) | def test_update(self): method test_increment (line 314) | def test_increment(self): method test_decrement (line 322) | def test_decrement(self): method test_count (line 330) | def test_count(self): method test_order_by_asc (line 338) | def test_order_by_asc(self): method test_order_by_multiple (line 346) | def test_order_by_multiple(self): method test_order_by_reference_direction (line 354) | def test_order_by_reference_direction(self): method test_order_by_raw (line 362) | def test_order_by_raw(self): method test_order_by_desc (line 370) | def test_order_by_desc(self): method test_where_column (line 378) | def test_where_column(self): method test_where_not_in (line 386) | def test_where_not_in(self): method test_between (line 394) | def test_between(self): method test_between_persisted (line 402) | def test_between_persisted(self): method test_not_between (line 408) | def test_not_between(self): method test_not_between_persisted (line 416) | def test_not_between_persisted(self): method test_where_in (line 422) | def test_where_in(self): method test_where_null (line 431) | def test_where_null(self): method test_where_not_null (line 440) | def test_where_not_null(self): method test_having (line 449) | def test_having(self): method test_group_by (line 460) | def test_group_by(self): method test_group_by_raw (line 469) | def test_group_by_raw(self): method test_group_by_multiple (line 478) | def test_group_by_multiple(self): method test_group_by_multiple_in_same_group_by (line 487) | def test_group_by_multiple_in_same_group_by(self): method test_builder_alone (line 494) | def test_builder_alone(self): method test_where_lt (line 508) | def test_where_lt(self): method test_where_lte (line 516) | def test_where_lte(self): method test_where_gt (line 524) | def test_where_gt(self): method test_where_gte (line 532) | def test_where_gte(self): method test_where_ne (line 540) | def test_where_ne(self): method test_or_where (line 548) | def test_or_where(self): method test_can_call_with_schema (line 556) | def test_can_call_with_schema(self): method test_can_call_with_raw (line 569) | def test_can_call_with_raw(self): method test_truncate (line 574) | def test_truncate(self): method test_truncate_without_foreign_keys (line 582) | def test_truncate_without_foreign_keys(self): class SQLiteQueryBuilderTest (line 591) | class SQLiteQueryBuilderTest(BaseTestQueryBuilder, unittest.TestCase): method sum (line 594) | def sum(self): method sum_aggregate_with_alias (line 601) | def sum_aggregate_with_alias(self): method max (line 608) | def max(self): method min (line 615) | def min(self): method avg (line 622) | def avg(self): method first (line 629) | def first(self): method all (line 636) | def all(self): method get (line 643) | def get(self): method select (line 650) | def select(self): method select_multiple (line 657) | def select_multiple(self): method add_select (line 664) | def add_select(self): method add_select_no_table (line 671) | def add_select_no_table(self): method add_select_with_raw (line 682) | def add_select_with_raw(self): method select_raw (line 706) | def select_raw(self): method create (line 713) | def create(self): method delete (line 720) | def delete(self): method where (line 727) | def where(self): method where_exists (line 734) | def where_exists(self): method limit (line 741) | def limit(self): method offset (line 748) | def offset(self): method offset_with_limit (line 755) | def offset_with_limit(self): method join (line 762) | def join(self): method left_join (line 768) | def left_join(self): method right_join (line 774) | def right_join(self): method update (line 780) | def update(self): method increment (line 786) | def increment(self): method decrement (line 792) | def decrement(self): method count (line 798) | def count(self): method order_by_asc (line 804) | def order_by_asc(self): method order_by_multiple (line 810) | def order_by_multiple(self): method order_by_raw (line 818) | def order_by_raw(self): method order_by_reference_direction (line 824) | def order_by_reference_direction(self): method order_by_desc (line 830) | def order_by_desc(self): method where_column (line 836) | def where_column(self): method where_null (line 842) | def where_null(self): method where_not_null (line 848) | def where_not_null(self): method where_not_in (line 854) | def where_not_in(self): method where_in (line 860) | def where_in(self): method between (line 866) | def between(self): method not_between (line 872) | def not_between(self): method having (line 878) | def having(self): method group_by (line 884) | def group_by(self): method group_by_multiple (line 890) | def group_by_multiple(self): method group_by_raw (line 896) | def group_by_raw(self): method where_lt (line 902) | def where_lt(self): method where_lte (line 909) | def where_lte(self): method where_gt (line 916) | def where_gt(self): method where_gte (line 923) | def where_gte(self): method where_ne (line 930) | def where_ne(self): method or_where (line 937) | def or_where(self): method where_like (line 944) | def where_like(self): method where_not_like (line 951) | def where_not_like(self): method test_when (line 958) | def test_when(self): method truncate (line 969) | def truncate(self): method truncate_without_foreign_keys (line 976) | def truncate_without_foreign_keys(self): method test_latest (line 987) | def test_latest(self): method test_oldest (line 995) | def test_oldest(self): method oldest (line 1003) | def oldest(self): method latest (line 1009) | def latest(self): FILE: tests/sqlite/builder/test_sqlite_query_builder_eager_loading.py class Logo (line 12) | class Logo(Model): class Article (line 16) | class Article(Model): method logo (line 20) | def logo(self): method user (line 24) | def user(self): class Profile (line 28) | class Profile(Model): class User (line 32) | class User(Model): method articles (line 38) | def articles(self): method profile (line 42) | def profile(self): class EagerUser (line 46) | class EagerUser(Model): method profile (line 53) | def profile(self): class BaseTestQueryRelationships (line 57) | class BaseTestQueryRelationships(unittest.TestCase): method get_builder (line 60) | def get_builder(self, table="users", model=User()): method test_with (line 70) | def test_with(self): method test_with_from_model (line 77) | def test_with_from_model(self): method test_with_first (line 84) | def test_with_first(self): method test_with_where_no_relation (line 89) | def test_with_where_no_relation(self): method test_with_multiple_per_same_relation (line 94) | def test_with_multiple_per_same_relation(self): FILE: tests/sqlite/builder/test_sqlite_query_builder_relationships.py class Logo (line 14) | class Logo(Model): class Article (line 18) | class Article(Model): method logo (line 22) | def logo(self): class Profile (line 26) | class Profile(Model): class User (line 30) | class User(Model): method articles (line 34) | def articles(self): method profile (line 38) | def profile(self): class BaseTestQueryRelationships (line 42) | class BaseTestQueryRelationships(unittest.TestCase): method get_builder (line 45) | def get_builder(self, table="users"): method test_has (line 51) | def test_has(self): method test_doesnt_have (line 61) | def test_doesnt_have(self): method test_where_doesnt_have (line 71) | def test_where_doesnt_have(self): method test_where_has_query (line 83) | def test_where_has_query(self): method test_relationship_multiple_has (line 93) | def test_relationship_multiple_has(self): method test_relationship_multiple_has_calls (line 104) | def test_relationship_multiple_has_calls(self): method test_nested_has (line 115) | def test_nested_has(self): method test_joins (line 122) | def test_joins(self): FILE: tests/sqlite/builder/test_sqlite_transaction.py class User (line 12) | class User(Model): class BaseTestQueryRelationships (line 17) | class BaseTestQueryRelationships(unittest.TestCase): method get_builder (line 20) | def get_builder(self, table="users"): method test_transaction (line 30) | def test_transaction(self): method test_transaction_globally (line 40) | def test_transaction_globally(self): method test_chunking (line 47) | def test_chunking(self): FILE: tests/sqlite/grammar/test_sqlite_delete_grammar.py class BaseDeleteGrammarTest (line 8) | class BaseDeleteGrammarTest: method setUp (line 9) | def setUp(self): method test_can_compile_delete (line 12) | def test_can_compile_delete(self): method test_can_compile_delete_in (line 20) | def test_can_compile_delete_in(self): method test_can_compile_delete_with_where (line 28) | def test_can_compile_delete_with_where(self): class TestSqliteDeleteGrammar (line 42) | class TestSqliteDeleteGrammar(BaseDeleteGrammarTest, unittest.TestCase): method can_compile_delete (line 45) | def can_compile_delete(self): method can_compile_delete_in (line 55) | def can_compile_delete_in(self): method can_compile_delete_with_where (line 65) | def can_compile_delete_with_where(self): FILE: tests/sqlite/grammar/test_sqlite_insert_grammar.py class BaseInsertGrammarTest (line 8) | class BaseInsertGrammarTest: method setUp (line 9) | def setUp(self): method test_can_compile_insert (line 12) | def test_can_compile_insert(self): method test_can_compile_insert_with_keywords (line 20) | def test_can_compile_insert_with_keywords(self): method test_can_compile_bulk_create (line 28) | def test_can_compile_bulk_create(self): method test_can_compile_bulk_create_qmark (line 44) | def test_can_compile_bulk_create_qmark(self): method test_can_compile_bulk_create_multiple (line 54) | def test_can_compile_bulk_create_multiple(self): class TestSqliteUpdateGrammar (line 70) | class TestSqliteUpdateGrammar(BaseInsertGrammarTest, unittest.TestCase): method can_compile_insert (line 73) | def can_compile_insert(self): method can_compile_insert_with_keywords (line 81) | def can_compile_insert_with_keywords(self): method can_compile_bulk_create (line 87) | def can_compile_bulk_create(self): method can_compile_bulk_create_multiple (line 93) | def can_compile_bulk_create_multiple(self): method can_compile_bulk_create_qmark (line 99) | def can_compile_bulk_create_qmark(self): FILE: tests/sqlite/grammar/test_sqlite_select_grammar.py class TestSQLiteGrammar (line 8) | class TestSQLiteGrammar(BaseTestCaseSelectGrammar, unittest.TestCase): method can_compile_select (line 12) | def can_compile_select(self): method can_compile_order_by_and_first (line 18) | def can_compile_order_by_and_first(self): method can_compile_with_columns (line 24) | def can_compile_with_columns(self): method can_compile_with_where (line 30) | def can_compile_with_where(self): method can_compile_with_several_where (line 36) | def can_compile_with_several_where(self): method can_compile_with_several_where_and_limit (line 42) | def can_compile_with_several_where_and_limit(self): method can_compile_with_sum (line 48) | def can_compile_with_sum(self): method can_compile_with_max (line 54) | def can_compile_with_max(self): method can_compile_with_max_and_columns (line 60) | def can_compile_with_max_and_columns(self): method can_compile_with_max_and_columns_different_order (line 66) | def can_compile_with_max_and_columns_different_order(self): method can_compile_with_order_by (line 72) | def can_compile_with_order_by(self): method can_compile_with_multiple_order_by (line 78) | def can_compile_with_multiple_order_by(self): method can_compile_with_group_by (line 86) | def can_compile_with_group_by(self): method can_compile_where_in (line 92) | def can_compile_where_in(self): method can_compile_where_in_empty (line 98) | def can_compile_where_in_empty(self): method can_compile_where_not_in (line 104) | def can_compile_where_not_in(self): method can_compile_where_null (line 110) | def can_compile_where_null(self): method can_compile_where_not_null (line 116) | def can_compile_where_not_null(self): method can_compile_where_raw (line 124) | def can_compile_where_raw(self): method can_compile_select_raw (line 130) | def can_compile_select_raw(self): method can_compile_limit_and_offset (line 136) | def can_compile_limit_and_offset(self): method can_compile_select_raw_with_select (line 142) | def can_compile_select_raw_with_select(self): method can_compile_count (line 148) | def can_compile_count(self): method can_compile_count_column (line 155) | def can_compile_count_column(self): method can_compile_where_column (line 162) | def can_compile_where_column(self): method can_compile_or_where (line 169) | def can_compile_or_where(self): method can_grouped_where (line 175) | def can_grouped_where(self): method can_compile_sub_select (line 181) | def can_compile_sub_select(self): method can_compile_sub_select_where (line 190) | def can_compile_sub_select_where(self): method can_compile_sub_select_value (line 199) | def can_compile_sub_select_value(self): method can_compile_complex_sub_select (line 208) | def can_compile_complex_sub_select(self): method can_compile_exists (line 219) | def can_compile_exists(self): method can_compile_not_exists (line 227) | def can_compile_not_exists(self): method can_compile_having (line 235) | def can_compile_having(self): method can_compile_having_order (line 241) | def can_compile_having_order(self): method can_compile_having_raw (line 247) | def can_compile_having_raw(self): method can_compile_having_with_expression (line 253) | def can_compile_having_with_expression(self): method can_compile_having_with_greater_than_expression (line 259) | def can_compile_having_with_greater_than_expression(self): method can_compile_join (line 265) | def can_compile_join(self): method can_compile_left_join (line 271) | def can_compile_left_join(self): method can_compile_multiple_join (line 277) | def can_compile_multiple_join(self): method can_compile_between (line 283) | def can_compile_between(self): method can_compile_not_between (line 289) | def can_compile_not_between(self): method test_can_compile_where_raw (line 295) | def test_can_compile_where_raw(self): method test_can_compile_where_raw_and_where_with_multiple_bindings (line 299) | def test_can_compile_where_raw_and_where_with_multiple_bindings(self): method test_can_compile_select_raw (line 309) | def test_can_compile_select_raw(self): method test_can_compile_select_raw_with_select (line 313) | def test_can_compile_select_raw_with_select(self): method can_compile_first_or_fail (line 317) | def can_compile_first_or_fail(self): method where_not_like (line 324) | def where_not_like(self): method where_like (line 331) | def where_like(self): method where_regexp (line 338) | def where_regexp(self): method where_not_regexp (line 345) | def where_not_regexp(self): method can_compile_join_clause (line 352) | def can_compile_join_clause(self): method can_compile_join_clause_with_value (line 365) | def can_compile_join_clause_with_value(self): method can_compile_join_clause_with_null (line 377) | def can_compile_join_clause_with_null(self): method can_compile_join_clause_with_not_null (line 390) | def can_compile_join_clause_with_not_null(self): method can_compile_join_clause_with_lambda (line 403) | def can_compile_join_clause_with_lambda(self): method can_compile_left_join_clause_with_lambda (line 416) | def can_compile_left_join_clause_with_lambda(self): method can_compile_right_join_clause_with_lambda (line 429) | def can_compile_right_join_clause_with_lambda(self): method update_lock (line 442) | def update_lock(self): method shared_lock (line 449) | def shared_lock(self): method can_user_where_raw_and_where (line 456) | def can_user_where_raw_and_where(self): method where_exists_with_lambda (line 462) | def where_exists_with_lambda(self): method where_not_exists_with_lambda (line 465) | def where_not_exists_with_lambda(self): method where_date (line 468) | def where_date(self): method or_where_null (line 473) | def or_where_null(self): method select_distinct (line 476) | def select_distinct(self): FILE: tests/sqlite/grammar/test_sqlite_update_grammar.py class BaseTestCaseUpdateGrammar (line 9) | class BaseTestCaseUpdateGrammar: method setUp (line 10) | def setUp(self): method test_can_compile_update (line 13) | def test_can_compile_update(self): method test_can_compile_multiple_update (line 23) | def test_can_compile_multiple_update(self): method test_can_compile_update_with_multiple_where (line 33) | def test_can_compile_update_with_multiple_where(self): method test_raw_expression (line 60) | def test_raw_expression(self): class TestSqliteUpdateGrammar (line 70) | class TestSqliteUpdateGrammar(BaseTestCaseUpdateGrammar, unittest.TestCa... method can_compile_update (line 73) | def can_compile_update(self): method raw_expression (line 81) | def raw_expression(self): method can_compile_multiple_update (line 89) | def can_compile_multiple_update(self): method can_compile_update_with_multiple_where (line 95) | def can_compile_update_with_multiple_where(self): method can_compile_increment (line 103) | def can_compile_increment(self): method can_compile_decrement (line 109) | def can_compile_decrement(self): FILE: tests/sqlite/models/test_attach_detach.py class Bottle (line 10) | class Bottle(Model): method lid (line 17) | def lid(self): class BottleLid (line 21) | class BottleLid(Model): method bottle (line 28) | def bottle(self): class TestAttachDetach (line 32) | class TestAttachDetach(unittest.TestCase): method setUp (line 33) | def setUp(self): method tearDown (line 49) | def tearDown(self): method test_has_one_attach_detach (line 53) | def test_has_one_attach_detach(self): method test_belongs_to_attach_detach (line 93) | def test_belongs_to_attach_detach(self): FILE: tests/sqlite/models/test_observers.py class TestM (line 14) | class TestM: class UserObserver (line 18) | class UserObserver: method created (line 19) | def created(self, user): method creating (line 22) | def creating(self, user): method saving (line 25) | def saving(self, user): method saved (line 28) | def saved(self, user): method updating (line 31) | def updating(self, user): method updated (line 34) | def updated(self, user): method booted (line 37) | def booted(self, user): method booting (line 40) | def booting(self, user): method hydrating (line 43) | def hydrating(self, user): method hydrated (line 46) | def hydrated(self, user): method deleting (line 49) | def deleting(self, user): method deleted (line 52) | def deleted(self, user): class Observer (line 56) | class Observer(Model): class BaseTestQueryRelationships (line 65) | class BaseTestQueryRelationships(unittest.TestCase): method test_created_is_observed (line 68) | def test_created_is_observed(self): method test_saving_is_observed (line 75) | def test_saving_is_observed(self): method test_updating_is_observed (line 86) | def test_updating_is_observed(self): method test_booting_is_observed (line 96) | def test_booting_is_observed(self): method test_deleting_is_observed (line 106) | def test_deleting_is_observed(self): method test_hydrating_is_observed (line 116) | def test_hydrating_is_observed(self): FILE: tests/sqlite/models/test_sqlite_model.py class User (line 15) | class User(Model): class UserForced (line 21) | class UserForced(Model): class Select (line 29) | class Select(Model): class SelectPass (line 35) | class SelectPass(Model): class UserHydrateHidden (line 40) | class UserHydrateHidden(Model): class Group (line 46) | class Group(Model): method team (line 53) | def team(self): class BaseTestQueryRelationships (line 57) | class BaseTestQueryRelationships(unittest.TestCase): method test_update_specific_record (line 60) | def test_update_specific_record(self): method test_update_all_records (line 69) | def test_update_all_records(self): method test_can_find_list (line 74) | def test_can_find_list(self): method test_find_or_if_record_not_found (line 85) | def test_find_or_if_record_not_found(self): method test_find_or_if_record_found (line 92) | def test_find_or_if_record_found(self): method test_can_set_and_retreive_attribute (line 98) | def test_can_set_and_retreive_attribute(self): method test_model_can_use_selects (line 103) | def test_model_can_use_selects(self): method test_model_can_use_selects_from_methods (line 109) | def test_model_can_use_selects_from_methods(self): method test_update_only_changed_attributes (line 115) | def test_update_only_changed_attributes(self): method test_can_force_update_on_method (line 126) | def test_can_force_update_on_method(self): method test_can_force_update_on_model (line 136) | def test_can_force_update_on_model(self): method test_force_update (line 146) | def test_force_update(self): method test_update_is_not_done_when_no_changes (line 156) | def test_update_is_not_done_when_no_changes(self): method test_should_collect_correct_amount_data_using_between (line 161) | def test_should_collect_correct_amount_data_using_between(self): method test_should_collect_correct_amount_data_using_not_between (line 169) | def test_should_collect_correct_amount_data_using_not_between(self): method test_get_columns (line 177) | def test_get_columns(self): method test_should_return_relation_applying_hidden_attributes (line 205) | def test_should_return_relation_applying_hidden_attributes(self): FILE: tests/sqlite/relationships/test_sqlite_has_many_through_relationship.py class Enrolment (line 11) | class Enrolment(Model): class Student (line 17) | class Student(Model): class Course (line 23) | class Course(Model): method students (line 35) | def students(self): class TestHasManyThroughRelationship (line 39) | class TestHasManyThroughRelationship(unittest.TestCase): method setUp (line 40) | def setUp(self): method test_has_many_through_can_eager_load (line 90) | def test_has_many_through_can_eager_load(self): method test_has_many_through_eager_load_can_be_empty (line 126) | def test_has_many_through_eager_load_can_be_empty(self): method test_has_many_through_can_get_related (line 134) | def test_has_many_through_can_get_related(self): method test_has_many_through_has_query (line 140) | def test_has_many_through_has_query(self): FILE: tests/sqlite/relationships/test_sqlite_has_one_through_relationship.py class Port (line 10) | class Port(Model): class Country (line 16) | class Country(Model): class IncomingShipment (line 22) | class IncomingShipment(Model): method from_country (line 28) | def from_country(self): class TestHasOneThroughRelationship (line 33) | class TestHasOneThroughRelationship(unittest.TestCase): method setUp (line 34) | def setUp(self): method test_has_one_through_can_eager_load (line 92) | def test_has_one_through_can_eager_load(self): method test_has_one_through_eager_load_can_be_empty (line 119) | def test_has_one_through_eager_load_can_be_empty(self): method test_has_one_through_can_get_related (line 130) | def test_has_one_through_can_get_related(self): method test_has_one_through_has_query (line 135) | def test_has_one_through_has_query(self): FILE: tests/sqlite/relationships/test_sqlite_polymorphic.py class Profile (line 9) | class Profile(Model): class Articles (line 14) | class Articles(Model): method logo (line 19) | def logo(self): class Logo (line 23) | class Logo(Model): class Like (line 28) | class Like(Model): method record (line 32) | def record(self): class User (line 36) | class User(Model): class TestRelationships (line 45) | class TestRelationships(unittest.TestCase): method test_can_get_polymorphic_relation (line 48) | def test_can_get_polymorphic_relation(self): method test_can_get_eager_load_polymorphic_relation (line 53) | def test_can_get_eager_load_polymorphic_relation(self): FILE: tests/sqlite/relationships/test_sqlite_relationships.py class Profile (line 7) | class Profile(Model): class Articles (line 12) | class Articles(Model): method logo (line 19) | def logo(self): class Logo (line 23) | class Logo(Model): class User (line 30) | class User(Model): method profile (line 38) | def profile(self): method articles (line 42) | def articles(self): method get_is_admin (line 45) | def get_is_admin(self): class Store (line 49) | class Store(Model): method products (line 53) | def products(self): method products_table (line 57) | def products_table(self): method store_products (line 61) | def store_products(self): class Product (line 65) | class Product(Model): class UserHasOne (line 69) | class UserHasOne(Model): method profile (line 75) | def profile(self): class TestRelationships (line 79) | class TestRelationships(unittest.TestCase): method test_relationship_can_be_callable (line 82) | def test_relationship_can_be_callable(self): method test_can_access_relationship (line 88) | def test_can_access_relationship(self): method test_can_access_has_many_relationship (line 92) | def test_can_access_has_many_relationship(self): method test_can_access_relationship_multiple_times (line 96) | def test_can_access_relationship_multiple_times(self): method test_can_access_relationship_date (line 101) | def test_can_access_relationship_date(self): method test_loading (line 106) | def test_loading(self): method test_relationship_has_one_sql (line 111) | def test_relationship_has_one_sql(self): method test_loading_with_nested_with (line 114) | def test_loading_with_nested_with(self): method test_casting (line 121) | def test_casting(self): method test_setting (line 126) | def test_setting(self): method test_related (line 133) | def test_related(self): method test_associate_records (line 141) | def test_associate_records(self): method test_belongs_to_many (line 150) | def test_belongs_to_many(self): method test_belongs_to_eager_many (line 162) | def test_belongs_to_eager_many(self): FILE: tests/sqlite/schema/test_sqlite_schema_builder.py class TestSQLiteSchemaBuilder (line 9) | class TestSQLiteSchemaBuilder(unittest.TestCase): method setUp (line 12) | def setUp(self): method test_can_add_columns (line 20) | def test_can_add_columns(self): method test_can_add_tiny_text (line 33) | def test_can_add_tiny_text(self): method test_can_add_unsigned_decimal (line 42) | def test_can_add_unsigned_decimal(self): method test_can_create_table_if_not_exists (line 52) | def test_can_create_table_if_not_exists(self): method test_can_add_columns_with_constraint (line 65) | def test_can_add_columns_with_constraint(self): method test_can_have_float_type (line 79) | def test_can_have_float_type(self): method test_can_add_columns_with_foreign_key_constraint (line 88) | def test_can_add_columns_with_foreign_key_constraint(self): method test_can_add_columns_with_foreign_key_constraint_name (line 108) | def test_can_add_columns_with_foreign_key_constraint_name(self): method test_can_use_morphs_for_polymorphism_relationships (line 130) | def test_can_use_morphs_for_polymorphism_relationships(self): method test_can_advanced_table_creation (line 142) | def test_can_advanced_table_creation(self): method test_can_create_indexes (line 168) | def test_can_create_indexes(self): method test_can_create_indexes_on_previous_column (line 189) | def test_can_create_indexes_on_previous_column(self): method test_can_have_composite_keys (line 205) | def test_can_have_composite_keys(self): method test_can_have_column_primary_key (line 225) | def test_can_have_column_primary_key(self): method test_can_advanced_table_creation2 (line 243) | def test_can_advanced_table_creation2(self): method test_has_table (line 280) | def test_has_table(self): method test_can_truncate (line 287) | def test_can_truncate(self): method test_can_rename_table (line 292) | def test_can_rename_table(self): method test_can_drop_table_if_exists (line 297) | def test_can_drop_table_if_exists(self): method test_can_drop_table (line 302) | def test_can_drop_table(self): method test_has_column (line 307) | def test_has_column(self): method test_can_have_unsigned_columns (line 315) | def test_can_have_unsigned_columns(self): method test_can_enable_foreign_keys (line 335) | def test_can_enable_foreign_keys(self): method test_can_disable_foreign_keys (line 340) | def test_can_disable_foreign_keys(self): method test_can_truncate_without_foreign_keys (line 345) | def test_can_truncate_without_foreign_keys(self): method test_can_add_enum (line 357) | def test_can_add_enum(self): FILE: tests/sqlite/schema/test_sqlite_schema_builder_alter.py class TestSQLiteSchemaBuilderAlter (line 10) | class TestSQLiteSchemaBuilderAlter(unittest.TestCase): method setUp (line 13) | def setUp(self): method test_can_add_columns (line 21) | def test_can_add_columns(self): method test_can_add_constraints (line 37) | def test_can_add_constraints(self): method test_alter_rename (line 47) | def test_alter_rename(self): method test_alter_drop (line 65) | def test_alter_drop(self): method test_change (line 85) | def test_change(self): method test_drop_add_and_change (line 108) | def test_drop_add_and_change(self): method test_timestamp_alter_add_nullable_column (line 131) | def test_timestamp_alter_add_nullable_column(self): method test_alter_drop_on_table_schema_table (line 146) | def test_alter_drop_on_table_schema_table(self): method test_alter_add_primary (line 155) | def test_alter_add_primary(self): method test_alter_add_column_and_foreign_key (line 165) | def test_alter_add_column_and_foreign_key(self): method test_alter_add_foreign_key_only (line 190) | def test_alter_add_foreign_key_only(self): method test_can_add_column_enum (line 213) | def test_can_add_column_enum(self): method test_can_change_column_enum (line 225) | def test_can_change_column_enum(self): FILE: tests/sqlite/schema/test_table.py class TestTable (line 9) | class TestTable(unittest.TestCase): method setUp (line 12) | def setUp(self): method test_add_columns (line 15) | def test_add_columns(self): method test_primary_key (line 21) | def test_primary_key(self): method test_create_sql (line 28) | def test_create_sql(self): method test_create_sql_with_primary_key (line 36) | def test_create_sql_with_primary_key(self): method test_create_sql_with_unique_constraint (line 45) | def test_create_sql_with_unique_constraint(self): method test_create_sql_with_multiple_unique_constraints (line 56) | def test_create_sql_with_multiple_unique_constraints(self): method test_create_sql_with_multiple_unique_constraint (line 69) | def test_create_sql_with_multiple_unique_constraint(self): method test_create_sql_with_foreign_key_constraint (line 81) | def test_create_sql_with_foreign_key_constraint(self): method test_can_build_table_from_connection_call (line 100) | def test_can_build_table_from_connection_call(self): FILE: tests/sqlite/schema/test_table_diff.py class TestTableDiff (line 8) | class TestTableDiff(unittest.TestCase): method setUp (line 9) | def setUp(self): method test_rename_table (line 12) | def test_rename_table(self): method test_drop_index (line 24) | def test_drop_index(self): method test_drop_index_and_rename_table (line 36) | def test_drop_index_and_rename_table(self): method test_alter_add_column (line 49) | def test_alter_add_column(self): method test_alter_rename (line 64) | def test_alter_rename(self): method test_alter_advanced_rename_columns (line 82) | def test_alter_advanced_rename_columns(self): method test_alter_rename_column_and_rename_table (line 102) | def test_alter_rename_column_and_rename_table(self): method test_alter_rename_column_and_rename_table_and_drop_index (line 122) | def test_alter_rename_column_and_rename_table_and_drop_index(self): method test_alter_can_drop_column (line 145) | def test_alter_can_drop_column(self): FILE: tests/utils.py class MockMySQLConnection (line 9) | class MockMySQLConnection(MySQLConnection): method make_connection (line 10) | def make_connection(self): method get_default_platform (line 17) | def get_default_platform(cls): class MockMSSQLConnection (line 21) | class MockMSSQLConnection(MySQLConnection): method make_connection (line 22) | def make_connection(self): method get_default_platform (line 29) | def get_default_platform(cls): class MockPostgresConnection (line 33) | class MockPostgresConnection(MySQLConnection): method make_connection (line 34) | def make_connection(self): class MockSQLiteConnection (line 40) | class MockSQLiteConnection(SQLiteConnection): method make_connection (line 41) | def make_connection(self): method query (line 46) | def query(self, *args, **kwargs): class MockConnectionFactory (line 50) | class MockConnectionFactory(ConnectionFactory):