Table::getSchema() - Code Metrics - Inspection of "Schema support" - mindplay-dk/sql - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#31)

by Rasmus

created 2017-01-26 15:57 UTC

Table::getSchema() A

↳ Parent: Table

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	1

<?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) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            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);
    }
}


1		<?php
2
3		namespace mindplay\sql\model\schema;
4
5		use mindplay\sql\model\Driver;
6		use mindplay\sql\model\TypeProvider;
7		use ReflectionClass;
8		use ReflectionMethod;
9
10		/**
11		* This is an abstract base-class for user-defined Table-types belonging to a Schema.
12		*/
13		abstract class Table
14		{
15		/**
16		* @var Schema
17		*/
18		private $schema;
19
20		/**
21		* @var Driver
22		*/
23		private $driver;
24
25		/**
26		* @var TypeProvider
27		*/
28		private $types;
29
30		/**
31		* @var string
32		*/
33		private $name;
34
35		/**
36		* @var string\|null
37		*/
38		private $alias;
39
40		/**
41		* @param Schema $schema
42		* @param Driver $driver
43		* @param TypeProvider $types
44		* @param string $name
45		* @param string\|null $alias
46		*/
47	1	public function __construct(Schema $schema, Driver $driver, TypeProvider $types, $name, $alias)
48		{
49	1	$this->schema = $schema;
50	1	$this->driver = $driver;
51	1	$this->types = $types;
52	1	$this->name = $name;
53	1	$this->alias = $alias;
54	1	}
55
56		/**
57		* @return Schema owner Schema instance
58		*/
59	1	public function getSchema()
60		{
61	1	return $this->schema;
62		}
63
64		/**
65		* @return string
66		*/
67	1	public function getName()
68		{
69	1	return $this->name;
70		}
71
72		/**
73		* @return string\|null
74		*/
75	1	public function getAlias()
76		{
77	1	return $this->alias;
78		}
79
80		/**
81		* @return string table expression (e.g. "{table} AS {alias}" for use in the FROM clause of an SQL statement)
82		*/
83	1	public function getNode()
84		{
85	1	$alias = $this->getAlias();
86
87	1	$quoted_table_name = $this->driver->quoteTableName($this->schema->getName(), $this->getName());
88
89	1	if ($alias) {
		0 ignored issues – show Bug Best Practice introduced 2017-01-26 16:02 UTC by Report Bug Copy Issue Report 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. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
90	1	return $quoted_table_name . ' AS ' . $this->driver->quoteName($alias);
91		}
92
93	1	return $quoted_table_name;
94		}
95
96		/**
97		* @param string\|null $prefix optional Column Alias prefix
98		*
99		* @return Column[] list of all available Columns
100		*/
101	1	public function listColumns($prefix = null)
102		{
103		// create a whitelist of parent types, excluding the Table class itself:
104
105	1	$type = get_class($this);
106
107	1	$whitelist = [];
108
109	1	while ($type && $type !== self::class) {
110	1	$whitelist[$type] = true;
111
112	1	$type = get_parent_class($type);
113		}
114
115		// reflect all available public methods:
116
117	1	$reflection = new ReflectionClass($this);
118
119	1	$methods = $reflection->getMethods(ReflectionMethod::IS_PUBLIC);
120
121	1	$columns = [];
122
123	1	foreach ($methods as $method) {
124	1	if (isset($whitelist[$method->class]) && !$method->isStatic()) {
125	1	$alias = $prefix
126	1	? "{$prefix}_{$method->name}"
127	1	: null;
128
129	1	$columns[] = $method->invoke($this, $alias);
130		}
131		}
132
133	1	return $columns;
134		}
135
136		/**
137		* @param string $name
138		* @param string $type Type class-name
139		* @param string\|null $alias
140		* @param mixed $default
141		*
142		* @return Column
143		*/
144	1	protected function requiredColumn($name, $type, $alias = null, $default = null)
145		{
146	1	return new Column($this->driver, $this, $name, $this->types->getType($type), $alias, true, $default, false);
147		}
148
149		/**
150		* @param string $name
151		* @param string $type Type class-name
152		* @param string\|null $alias
153		* @param mixed $default
154		*
155		* @return Column
156		*/
157		protected function optionalColumn($name, $type, $alias = null, $default = null)
158		{
159		return new Column($this->driver, $this, $name, $this->types->getType($type), $alias, false, $default, false);
160		}
161
162		/**
163		* @param string $name
164		* @param string $type Type class-name
165		* @param string\|null $alias
166		*
167		* @return Column
168		*/
169	1	protected function autoColumn($name, $type, $alias = null)
170		{
171	1	return new Column($this->driver, $this, $name, $this->types->getType($type), $alias, false, null, true);
172		}
173
174		/**
175		* @ignore
176		*
177		* @return string
178		*/
179	1	public function __toString()
180		{
181	1	return $this->alias
182	1	? $this->driver->quoteName($this->alias)
183	1	: $this->driver->quoteTableName($this->schema->getName(), $this->name);
184		}
185
186		/**
187		* @ignore
188		*
189		* @param string $name
190		*
191		* @return Column
192		*/
193	1	public function __get($name)
194		{
195		// TODO caching
196
197	1	return $this->$name($this->alias ? "{$this->alias}_{$name}" : null);
198		}
199		}
200

mindplay-dk / sql

Pull Request — master (#31)

Table::getSchema() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like