TableDumper::getTable() - Code Metrics - Y0lk/sqldumper - Measure and Improve Code Quality continuously with Scrutinizer

TableDumper::getTable() A
last analyzed 2023-08-23 16:26 UTC

↳ Parent: TableDumper

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	2
Bugs	0	Features	0

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

<?php declare(strict_types=1);
namespace Y0lk\SQLDumper;

use PDO;

/**
 * A TableDumper instance is used to dump a single Table, allowing you to specify certain dump options for this table only
 *
 * @author Gabriel Jean <[email protected]>
 */
class TableDumper {

    /**
     * @var Table   Table instance related to this dumper
     */
    protected $table;

    /**
     * @var boolean Specifies whether to include the table's structure (CREATE statement)
     */
    protected $withStructure = true;

    /**
     * @var boolean Specifies whether to include the table's data (INSERT statements)
     */
    protected $withData = true;

    /**
     * @var boolean Specifies whether to include a DROP TABLE statement
     */
    protected $withDrop = true;

    /**
     * @var string WHERE parameters written as a regular SQL string to select specific data from this table
     */
    protected $where = '';


    /**
     * @param Table Table this dumper will be used for
     */
    public function __construct(Table $table)
    {
        $this->table = $table;
    }

    /**
     * Specifies whether to include the table's structure (CREATE statement)
     * 
     * @param  boolean  $withStructure  TRUE to include structure, FALSE otherwise
     * 
     * @return TableDumper  Returns the TableDumper instance
     */
    public function withStructure(bool $withStructure = true): TableDumper
    {
        $this->withStructure = $withStructure;
        return $this;
    }

    /**
     * Specifies whether to include the table's data (INSERT statements)
     * 
     * @param  boolean  $withData   TRUE to include data, FALSE otherwise
     * 
     * @return TableDumper  Returns the TableDumper instance
     */
    public function withData(bool $withData = true): TableDumper
    {
        $this->withData = $withData;
        return $this;
    }

    /**
     * Specifies whether to include a DROP TABLE statement
     * 
     * @param  boolean  $withDrop   TRUE to include DROP statement, FALSE otherwise
     * 
     * @return TableDumper  Returns the TableDumper instance
     */
    public function withDrop(bool $withDrop = true): TableDumper
    {
        $this->withDrop = $withDrop;
        return $this;
    }

    /**
     * Returns whether or not this dumper will include the table's structure
     * 
     * @return boolean Returns TRUE if it includes it, FALSE otherwise
     */
    public function hasStructure(): bool
    {
        return $this->withStructure;
    }


    /**
     * Returns whether or not this dumper will include the table's data
     * 
     * @return boolean Returns TRUE if it includes it, FALSE otherwise
     */
    public function hasData(): bool
    {
        return $this->withData;
    }


    /**
     * Returns whether or not this dumper will include the table's DROP statement
     * 
     * @return boolean Returns TRUE if it includes it, FALSE otherwise
     */
    public function hasDrop(): bool
    {
        return $this->withDrop;
    }


    /**
     * Add WHERE parameters to use when dumping the data 
     * 
     * @param  string   $where_string   SQL string that you would normally write after WHERE keyowrd
     * 
     * @return TableDumper  Returns the TableDumper instance
     */
    public function where(string $where_string): TableDumper
    {
        $this->where = $where_string;
        return $this;
    }

    /**
     * Get the where param string
     * @return string Returns the WHERE param string
     */
    public function getWhere(): string
    {
        return $this->where;
    }

    /**
     * Get the Table related to this dumper
     * 
     * @return Table    Returns the Table instance
     */
    public function getTable(): Table
    {
        return $this->table;
    }

    /**
     * Writes the CREATE statement to the dump stream
     * 
     * @param  PDO      $db     PDO instance to use for DB queries
     * @param  resource $stream Stream to write the dump to
     * 
     * @return void
     */
    public function dumpCreateStatement(PDO $db, $stream): void 
    {
        if (!$this->hasStructure()) return;

        $stmt = $db->query('SHOW CREATE TABLE `'.$this->table->getName().'`');

        fwrite($stream, $stmt->fetchColumn(1).";\r\n");

        $stmt->closeCursor();
    }

    /**
     * Writes the DROP statement to the dump stream
     * 
     * @param  resource $stream Stream to write the dump to
     * 
     * @return void
     */
    public function dumpDropStatement($stream): void
    {
        if (!$this->hasDrop()) return;

        fwrite($stream, 'DROP TABLE IF EXISTS `'.$this->table->getName()."`;\r\n");
    }

    /**
     * Writes the INSERT statements to the dump stream
     * 
     * @param  PDO      $db     PDO instance to use for DB queries
     * @param  resource $stream Stream to write the dump to
     * 
     * @return void
     */
    public function dumpInsertStatement(PDO $db, $stream): void
    {
        if (!$this->hasData()) return;

        $dataDumper = new TableDataDumper($this);
        $dataDumper->dump($db, $stream);
    }

    /**
     * Writes all the SQL statements of this dumper to the dump stream
     * 
     * @param  PDO      $db     PDO instance to use for DB queries
     * @param  resource $stream Stream to write the dump to
     * 
     * @return void
     */
    public function dump(PDO $db, $stream): void
    {
        //Drop table statement
        $this->dumpDropStatement($stream);

        //Create table statement
        $this->dumpCreateStatement($db, $stream);

        //Data
        $this->dumpInsertStatement($db, $stream);
    }
}

1		<?php declare(strict_types=1);
2		namespace Y0lk\SQLDumper;
3
4		use PDO;
5
6		/**
7		* A TableDumper instance is used to dump a single Table, allowing you to specify certain dump options for this table only
8		*
9		* @author Gabriel Jean <[email protected]>
10		*/
11		class TableDumper {
12
13		/**
14		* @var Table Table instance related to this dumper
15		*/
16		protected $table;
17
18		/**
19		* @var boolean Specifies whether to include the table's structure (CREATE statement)
20		*/
21		protected $withStructure = true;
22
23		/**
24		* @var boolean Specifies whether to include the table's data (INSERT statements)
25		*/
26		protected $withData = true;
27
28		/**
29		* @var boolean Specifies whether to include a DROP TABLE statement
30		*/
31		protected $withDrop = true;
32
33		/**
34		* @var string WHERE parameters written as a regular SQL string to select specific data from this table
35		*/
36		protected $where = '';
37
38
39		/**
40		* @param Table Table this dumper will be used for
41		*/
42	111	public function __construct(Table $table)
43		{
44	111	$this->table = $table;
45	111	}
46
47		/**
48		* Specifies whether to include the table's structure (CREATE statement)
49		*
50		* @param boolean $withStructure TRUE to include structure, FALSE otherwise
51		*
52		* @return TableDumper Returns the TableDumper instance
53		*/
54	30	public function withStructure(bool $withStructure = true): TableDumper
55		{
56	30	$this->withStructure = $withStructure;
57	30	return $this;
58		}
59
60		/**
61		* Specifies whether to include the table's data (INSERT statements)
62		*
63		* @param boolean $withData TRUE to include data, FALSE otherwise
64		*
65		* @return TableDumper Returns the TableDumper instance
66		*/
67	21	public function withData(bool $withData = true): TableDumper
68		{
69	21	$this->withData = $withData;
70	21	return $this;
71		}
72
73		/**
74		* Specifies whether to include a DROP TABLE statement
75		*
76		* @param boolean $withDrop TRUE to include DROP statement, FALSE otherwise
77		*
78		* @return TableDumper Returns the TableDumper instance
79		*/
80	21	public function withDrop(bool $withDrop = true): TableDumper
81		{
82	21	$this->withDrop = $withDrop;
83	21	return $this;
84		}
85
86		/**
87		* Returns whether or not this dumper will include the table's structure
88		*
89		* @return boolean Returns TRUE if it includes it, FALSE otherwise
90		*/
91	51	public function hasStructure(): bool
92		{
93	51	return $this->withStructure;
94		}
95
96
97		/**
98		* Returns whether or not this dumper will include the table's data
99		*
100		* @return boolean Returns TRUE if it includes it, FALSE otherwise
101		*/
102	45	public function hasData(): bool
103		{
104	45	return $this->withData;
105		}
106
107
108		/**
109		* Returns whether or not this dumper will include the table's DROP statement
110		*
111		* @return boolean Returns TRUE if it includes it, FALSE otherwise
112		*/
113	45	public function hasDrop(): bool
114		{
115	45	return $this->withDrop;
116		}
117
118
119		/**
120		* Add WHERE parameters to use when dumping the data
121		*
122		* @param string $where_string SQL string that you would normally write after WHERE keyowrd
123		*
124		* @return TableDumper Returns the TableDumper instance
125		*/
126	9	public function where(string $where_string): TableDumper
127		{
128	9	$this->where = $where_string;
129	9	return $this;
130		}
131
132		/**
133		* Get the where param string
134		* @return string Returns the WHERE param string
135		*/
136	36	public function getWhere(): string
137		{
138	36	return $this->where;
139		}
140
141		/**
142		* Get the Table related to this dumper
143		*
144		* @return Table Returns the Table instance
145		*/
146	87	public function getTable(): Table
147		{
148	87	return $this->table;
149		}
150
151		/**
152		* Writes the CREATE statement to the dump stream
153		*
154		* @param PDO $db PDO instance to use for DB queries
155		* @param resource $stream Stream to write the dump to
156		*
157		* @return void
158		*/
159	36	public function dumpCreateStatement(PDO $db, $stream): void
160		{
161	36	if (!$this->hasStructure()) return;
162	12
163		$stmt = $db->query('SHOW CREATE TABLE `'.$this->table->getName().'`');
164
165	24	fwrite($stream, $stmt->fetchColumn(1).";\r\n");
166
167	24	$stmt->closeCursor();
168		}
169	24
170	24	/**
171		* Writes the DROP statement to the dump stream
172		*
173		* @param resource $stream Stream to write the dump to
174		*
175		* @return void
176		*/
177		public function dumpDropStatement($stream): void
178		{
179	39	if (!$this->hasDrop()) return;
180
181	39	fwrite($stream, 'DROP TABLE IF EXISTS `'.$this->table->getName()."`;\r\n");
182	12	}
183
184		/**
185	27	* Writes the INSERT statements to the dump stream
186	27	*
187		* @param PDO $db PDO instance to use for DB queries
188		* @param resource $stream Stream to write the dump to
189		*
190		* @return void
191		*/
192		public function dumpInsertStatement(PDO $db, $stream): void
193		{
194		if (!$this->hasData()) return;
195
196	39	$dataDumper = new TableDataDumper($this);
197		$dataDumper->dump($db, $stream);
198	39	}
199	9
200		/**
201		* Writes all the SQL statements of this dumper to the dump stream
202	30	*
203	30	* @param PDO $db PDO instance to use for DB queries
204	30	* @param resource $stream Stream to write the dump to
205		*
206		* @return void
207		*/
208		public function dump(PDO $db, $stream): void
209		{
210		//Drop table statement
211		$this->dumpDropStatement($stream);
212
213		//Create table statement
214	3	$this->dumpCreateStatement($db, $stream);
215
216		//Data
217	3	$this->dumpInsertStatement($db, $stream);
218		}
219		}

Y0lk / sqldumper

TableDumper::getTable() A last analyzed 2023-08-23 16:26 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

TableDumper::getTable() A
last analyzed 2023-08-23 16:26 UTC