Grammar
abstract class Grammar extends Grammar (View source)
Traits
Properties
| static protected array | $macros | The registered string macros.  | 
                from Macroable | 
| protected string | $tablePrefix | The grammar table prefix.  | 
                from Grammar | 
| protected bool | $transactions | If this Grammar supports schema changes wrapped in a transaction.  | 
                |
| protected array | $fluentCommands | The commands to be executed outside of create or alter command.  | 
                
Methods
Mix another object into the class.
Dynamically handle calls to the class.
Dynamically handle calls to the class.
Wrap a value that has an alias.
Convert an array of column names into a delimited string.
Get the appropriate query parameter place-holder for a value.
Split the given JSON selector into the field and the optional path and wrap them separately.
Wrap the given JSON path.
Wrap the given JSON path segment.
Compile a drop database if exists command.
Compile a rename column command.
Compile a change column command into a series of SQL statements.
Add the column modifiers to the definition.
Get the primary key command if it exists on the blueprint.
Add a prefix to an array of values.
Format a value so that it can be used in "default" clauses.
Create an empty Doctrine DBAL TableDiff from the Blueprint.
Get the fluent commands for the grammar.
Check if this Grammar supports schema changes wrapped in a transaction.
Details
        
                static            void
    macro(string $name, object|callable $macro)
        
    
    Register a custom macro.
        
                static            void
    mixin(object $mixin, bool $replace = true)
        
    
    Mix another object into the class.
        
                static            bool
    hasMacro(string $name)
        
    
    Checks if macro is registered.
        
                static            void
    flushMacros()
        
    
    Flush the existing macros.
        
                static            mixed
    __callStatic(string $method, array $parameters)
        
    
    Dynamically handle calls to the class.
        
                            mixed
    __call(string $method, array $parameters)
        
    
    Dynamically handle calls to the class.
        
                            array
    wrapArray(array $values)
        
    
    Wrap an array of values.
        
                            string
    wrapTable(Expression|string $table)
        
    
    Wrap a table in keyword identifiers.
        
                            string
    wrap(Expression|string $value, bool $prefixAlias = false)
        
    
    Wrap a value in keyword identifiers.
        
                    protected        string
    wrapAliasedValue(string $value, bool $prefixAlias = false)
        
    
    Wrap a value that has an alias.
        
                    protected        string
    wrapSegments(array $segments)
        
    
    Wrap the given value segments.
        
                    protected        string
    wrapValue(string $value)
        
    
    Wrap a single string in keyword identifiers.
        
                    protected        string
    wrapJsonSelector(string $value)
        
    
    Wrap the given JSON selector.
        
                    protected        bool
    isJsonSelector(string $value)
        
    
    Determine if the given string is a JSON selector.
        
                            string
    columnize(array $columns)
        
    
    Convert an array of column names into a delimited string.
        
                            string
    parameterize(array $values)
        
    
    Create query parameter place-holders for an array.
        
                            string
    parameter(mixed $value)
        
    
    Get the appropriate query parameter place-holder for a value.
        
                            string
    quoteString(string|array $value)
        
    
    Quote the given string literal.
        
                            bool
    isExpression(mixed $value)
        
    
    Determine if the given value is a raw expression.
        
                            mixed
    getValue(Expression $expression)
        
    
    Get the value of a raw expression.
        
                            string
    getDateFormat()
        
    
    Get the format for database stored dates.
        
                            string
    getTablePrefix()
        
    
    Get the grammar's table prefix.
        
                            $this
    setTablePrefix(string $prefix)
        
    
    Set the grammar's table prefix.
        
                    protected        array
    wrapJsonFieldAndPath(string $column)
        
    
    Split the given JSON selector into the field and the optional path and wrap them separately.
        
                    protected        string
    wrapJsonPath(string $value, string $delimiter = '->')
        
    
    Wrap the given JSON path.
        
                    protected        string
    wrapJsonPathSegment(string $segment)
        
    
    Wrap the given JSON path segment.
        
                            void
    compileCreateDatabase(string $name, Connection $connection)
        
    
    Compile a create database command.
        
                            void
    compileDropDatabaseIfExists(string $name)
        
    
    Compile a drop database if exists command.
        
                            array|string
    compileRenameColumn(Blueprint $blueprint, Fluent $command, Connection $connection)
        
    
    Compile a rename column command.
        
                            array
    compileChange(Blueprint $blueprint, Fluent $command, Connection $connection)
        
    
    Compile a change column command into a series of SQL statements.
        
                            string
    compileDropFullText(Blueprint $blueprint, Fluent $command)
        
    
    Compile a drop fulltext index command.
        
                    protected        array
    getColumns(Blueprint $blueprint)
        
    
    Compile the blueprint's column definitions.
        
                    protected        string
    getType(Fluent $column)
        
    
    Get the SQL for the column data type.
        
                    protected        void
    typeComputed(Fluent $column)
        
    
    Create the column definition for a generated, computed column type.
        
                    protected        string
    addModifiers(string $sql, Blueprint $blueprint, Fluent $column)
        
    
    Add the column modifiers to the definition.
        
                    protected        Fluent|null
    getCommandByName(Blueprint $blueprint, string $name)
        
    
    Get the primary key command if it exists on the blueprint.
        
                    protected        array
    getCommandsByName(Blueprint $blueprint, string $name)
        
    
    Get all of the commands with a given name.
        
                            array
    prefixArray(string $prefix, array $values)
        
    
    Add a prefix to an array of values.
        
                    protected        string
    getDefaultValue(mixed $value)
        
    
    Format a value so that it can be used in "default" clauses.
        
                            TableDiff
    getDoctrineTableDiff(Blueprint $blueprint, AbstractSchemaManager $schema)
        
    
    Create an empty Doctrine DBAL TableDiff from the Blueprint.
        
                            array
    getFluentCommands()
        
    
    Get the fluent commands for the grammar.
        
                            bool
    supportsSchemaTransactions()
        
    
    Check if this Grammar supports schema changes wrapped in a transaction.