mindplay\sql\model\schema\Table

Complexity

Total Complexity

20

Size/Duplication

Total Lines	187
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	getSchema()	0	4	1
A	getName()	0	4	1
A	getAlias()	0	4	1
A	getNode()	0	12	2
C	listColumns()	0	34	7
A	requiredColumn()	0	4	1
A	optionalColumn()	0	4	1
A	autoColumn()	0	4	1
A	__toString()	0	6	2
A	__get()	0	6	2

<?php

namespace mindplay\sql\model\schema;

use mindplay\sql\model\Driver;
use mindplay\sql\model\TypeProvider;
use ReflectionClass;
use ReflectionMethod;

/**
 * This is an abstract base-class for user-defined Table-types belonging to a Schema.
 */
abstract class Table
{
    /**
     * @var Schema
     */
    private $schema;

    /**
     * @var Driver
     */
    private $driver;

    /**
     * @var TypeProvider
     */
    private $types;

    /**
     * @var string
     */
    private $name;

    /**
     * @var string|null
     */
    private $alias;

    /**
     * @param Schema       $schema
     * @param Driver       $driver
     * @param TypeProvider $types
     * @param string       $name
     * @param string|null  $alias
     */
    public function __construct(Schema $schema, Driver $driver, TypeProvider $types, $name, $alias)
    {
        $this->schema = $schema;
        $this->driver = $driver;
        $this->types = $types;
        $this->name = $name;
        $this->alias = $alias;
    }

    /**
     * @return Schema owner Schema instance
     */
    public function getSchema()
    {
        return $this->schema;
    }

    /**
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @return string|null
     */
    public function getAlias()
    {
        return $this->alias;
    }

    /**
     * @return string table expression (e.g. "{table} AS {alias}" for use in the FROM clause of an SQL statement)
     */
    public function getNode()
    {
        $alias = $this->getAlias();

        $quoted_table_name = $this->driver->quoteTableName($this->schema->getName(), $this->getName());

        if ($alias) {

The expression $alias of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            return $quoted_table_name . ' AS ' . $this->driver->quoteName($alias);
        }

        return $quoted_table_name;
    }

    /**
     * @param string|null $prefix optional Column Alias prefix
     *
     * @return Column[] list of all available Columns
     */
    public function listColumns($prefix = null)
    {
        // create a whitelist of parent types, excluding the Table class itself:

        $type = get_class($this);

        $whitelist = [];

        while ($type && $type !== self::class) {
            $whitelist[$type] = true;

            $type = get_parent_class($type);
        }

        // reflect all available public methods:

        $reflection = new ReflectionClass($this);

        $methods = $reflection->getMethods(ReflectionMethod::IS_PUBLIC);

        $columns = [];

        foreach ($methods as $method) {
            if (isset($whitelist[$method->class]) && !$method->isStatic()) {
                $alias = $prefix
                    ? "{$prefix}_{$method->name}"
                    : null;

                $columns[] =  $method->invoke($this, $alias);
            }
        }

        return $columns;
    }

    /**
     * @param string      $name
     * @param string      $type Type class-name
     * @param string|null $alias
     * @param mixed       $default
     *
     * @return Column
     */
    protected function requiredColumn($name, $type, $alias = null, $default = null)
    {
        return new Column($this->driver, $this, $name, $this->types->getType($type), $alias, true, $default, false);
    }

    /**
     * @param string      $name
     * @param string      $type Type class-name
     * @param string|null $alias
     * @param mixed       $default
     *
     * @return Column
     */
    protected function optionalColumn($name, $type, $alias = null, $default = null)
    {
        return new Column($this->driver, $this, $name, $this->types->getType($type), $alias, false, $default, false);
    }

    /**
     * @param string      $name
     * @param string      $type Type class-name
     * @param string|null $alias
     *
     * @return Column
     */
    protected function autoColumn($name, $type, $alias = null)
    {
        return new Column($this->driver, $this, $name, $this->types->getType($type), $alias, false, null, true);
    }

    /**
     * @ignore
     *
     * @return string
     */
    public function __toString()
    {
        return $this->alias
            ? $this->driver->quoteName($this->alias)
            : $this->driver->quoteTableName($this->schema->getName(), $this->name);
    }

    /**
     * @ignore
     *
     * @param string $name
     *
     * @return Column
     */
    public function __get($name)
    {
        // TODO caching

        return $this->$name($this->alias ? "{$this->alias}_{$name}" : null);
    }
}