Postgres82::getOpClasses() - Code Metrics - Inspection of "testing new scrutinizer" - HuasoFoundries/phpPgAdmin6 - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — develop ( c2019a...2cab77 )

by Felipe

created 2018-06-19 16:14 UTC

Postgres82::getOpClasses() A

↳ Parent: Postgres82

Complexity

Conditions	1
Paths	1

Size

Total Lines	21
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	5
nc	1
nop	0
dl	0
loc	21
rs	9.3142
c	0
b	0
f	0

<?php

/**
 * PHPPgAdmin v6.0.0-beta.48
 */

namespace PHPPgAdmin\Database;

/**
 * @file
 * PostgreSQL 8.2 support
 *
 * Id: Postgres82.php,v 1.10 2007/12/28 16:21:25 ioguix Exp $
 *
 * @package PHPPgAdmin
 */
class Postgres82 extends Postgres83
{
    public $major_version = 8.2;

    // Select operators
    public $selectOps = [
        '='              => 'i',
        '!='             => 'i',
        '<'              => 'i',
        '>'              => 'i',
        '<='             => 'i',
        '>='             => 'i',
        '<<'             => 'i',
        '>>'             => 'i',
        '<<='            => 'i',
        '>>='            => 'i',
        'LIKE'           => 'i',
        'NOT LIKE'       => 'i',
        'ILIKE'          => 'i',
        'NOT ILIKE'      => 'i',
        'SIMILAR TO'     => 'i',
        'NOT SIMILAR TO' => 'i',
        '~'              => 'i',
        '!~'             => 'i',
        '~*'             => 'i',
        '!~*'            => 'i',
        'IS NULL'        => 'p',
        'IS NOT NULL'    => 'p',
        'IN'             => 'x',
        'NOT IN'         => 'x',
    ];

    // Database functions

    /**
     * Returns table locks information in the current database.
     *
     * @return \PHPPgAdmin\ADORecordSet A recordset
     */
    public function getLocks()
    {
        $conf = $this->conf;

        if (!$conf['show_system']) {
            $where = 'AND pn.nspname NOT LIKE $$pg\_%$$';
        } else {
            $where = "AND nspname !~ '^pg_t(emp_[0-9]+|oast)$'";
        }

        $sql = "SELECT pn.nspname, pc.relname AS tablename, pl.transaction, pl.pid, pl.mode, pl.granted
		FROM pg_catalog.pg_locks pl, pg_catalog.pg_class pc, pg_catalog.pg_namespace pn
		WHERE pl.relation = pc.oid AND pc.relnamespace=pn.oid {$where}
		ORDER BY nspname,tablename";

        return $this->selectSet($sql);
    }

    // Sequence functions

    /**
     * Rename a sequence.
     *
     * @param \PHPPgAdmin\ADORecordSet $seqrs The sequence RecordSet returned by getSequence()
     * @param string                   $name  The new name for the sequence
     *
     * @return int 0 if operation was successful
     */
    public function alterSequenceName($seqrs, $name)
    {
        /* vars are cleaned in _alterSequence */
        if (!empty($name) && ($seqrs->fields['seqname'] != $name)) {
            $f_schema = $this->_schema;
            $this->fieldClean($f_schema);
            $sql    = "ALTER TABLE \"{$f_schema}\".\"{$seqrs->fields['seqname']}\" RENAME TO \"{$name}\"";
            $status = $this->execute($sql);
            if ($status == 0) {
                $seqrs->fields['seqname'] = $name;
            } else {
                return $status;
            }
        }

        return 0;
    }

    // View functions

    /**
     * Rename a view.
     *
     * @param \PHPPgAdmin\ADORecordSet $vwrs The view recordSet returned by getView()
     * @param string                   $name The new view's name
     *
     * @return int -1 if Failed
     */
    public function alterViewName($vwrs, $name)
    {
        // Rename (only if name has changed)
        /* $vwrs and $name are cleaned in _alterView */
        if (!empty($name) && ($name != $vwrs->fields['relname'])) {
            $f_schema = $this->_schema;
            $this->fieldClean($f_schema);
            $sql    = "ALTER TABLE \"{$f_schema}\".\"{$vwrs->fields['relname']}\" RENAME TO \"{$name}\"";
            $status = $this->execute($sql);
            if ($status == 0) {
                $vwrs->fields['relname'] = $name;
            } else {
                return $status;
            }
        }

        return 0;
    }

    // Trigger functions

    /**
     * Grabs a list of triggers on a table.
     *
     * @param string $table The name of a table whose triggers to retrieve
     *
     * @return \PHPPgAdmin\ADORecordSet A recordset
     */
    public function getTriggers($table = '')
    {
        $c_schema = $this->_schema;
        $this->clean($c_schema);
        $this->clean($table);

        $sql = "SELECT
				t.tgname, pg_catalog.pg_get_triggerdef(t.oid) AS tgdef, t.tgenabled, p.oid AS prooid,
				p.proname || ' (' || pg_catalog.oidvectortypes(p.proargtypes) || ')' AS proproto,
				ns.nspname AS pronamespace
			FROM pg_catalog.pg_trigger t, pg_catalog.pg_proc p, pg_catalog.pg_namespace ns
			WHERE t.tgrelid = (SELECT oid FROM pg_catalog.pg_class WHERE relname='{$table}'
				AND relnamespace=(SELECT oid FROM pg_catalog.pg_namespace WHERE nspname='{$c_schema}'))
				AND (NOT tgisconstraint OR NOT EXISTS
						(SELECT 1 FROM pg_catalog.pg_depend d    JOIN pg_catalog.pg_constraint c
							ON (d.refclassid = c.tableoid AND d.refobjid = c.oid)
						WHERE d.classid = t.tableoid AND d.objid = t.oid AND d.deptype = 'i' AND c.contype = 'f'))
				AND p.oid=t.tgfoid
				AND p.pronamespace = ns.oid";

        return $this->selectSet($sql);
    }

    // Function functions

    /**
     * Returns all details for a particular function.
     *
     * @param int $function_oid
     *
     * @return \PHPPgAdmin\ADORecordSet Function info
     *
     * @internal param string The $func name of the function to retrieve
     */
    public function getFunction($function_oid)
    {
        $this->clean($function_oid);

        $sql = "SELECT
					pc.oid AS prooid,
					proname,
					pg_catalog.pg_get_userbyid(proowner) AS proowner,
					nspname as proschema,
					lanname as prolanguage,
					pg_catalog.format_type(prorettype, NULL) as proresult,
					prosrc,
					probin,
					proretset,
					proisstrict,
					provolatile,
					prosecdef,
					pg_catalog.oidvectortypes(pc.proargtypes) AS proarguments,
					proargnames AS proargnames,
					pg_catalog.obj_description(pc.oid, 'pg_proc') AS procomment
				FROM
					pg_catalog.pg_proc pc, pg_catalog.pg_language pl, pg_catalog.pg_namespace pn
				WHERE
					pc.oid = '{$function_oid}'::oid
					AND pc.prolang = pl.oid
					AND pc.pronamespace = pn.oid
				";

        return $this->selectSet($sql);
    }

    /**
     * Creates a new function.
     *
     * @param string $funcname   The name of the function to create
     * @param string $args       A comma separated string of types
     * @param string $returns    The return type
     * @param string $definition The definition for the new function
     * @param string $language   The language the function is written for
     * @param array  $flags      An array of optional flags
     * @param bool   $setof      True if it returns a set, false otherwise
     * @param float  $cost       cost the planner should use in the function execution step
     * @param int    $rows       number of rows planner should estimate will be returned
     * @param string $comment    The comment on the function
     * @param bool   $replace    (optional) True if OR REPLACE, false for normal
     *
     * @return bool|int 0 success
     */
    public function createFunction($funcname, $args, $returns, $definition, $language, $flags, $setof, $cost, $rows, $comment, $replace = false)
    {
        // Begin a transaction
        $status = $this->beginTransaction();
        if ($status != 0) {
            $this->rollbackTransaction();

            return -1;
        }

        $f_schema = $this->_schema;
        $this->fieldClean($f_schema);
        $this->fieldClean($funcname);
        $this->clean($args);
        $this->fieldClean($language);
        $this->arrayClean($flags);

        $sql = 'CREATE';
        if ($replace) {
            $sql .= ' OR REPLACE';
        }

        $sql .= " FUNCTION \"{$f_schema}\".\"{$funcname}\" (";

        if ($args != '') {
            $sql .= $args;
        }

        // For some reason, the returns field cannot have quotes...
        $sql .= ') RETURNS ';
        if ($setof) {
            $sql .= 'SETOF ';
        }

        $sql .= "{$returns} AS ";

        if (is_array($definition)) {
            $this->arrayClean($definition);
            $sql .= "'".$definition[0]."'";
            if ($definition[1]) {
                $sql .= ",'".$definition[1]."'";
            }
        } else {
            $this->clean($definition);
            $sql .= "'".$definition."'";
        }

        $sql .= " LANGUAGE \"{$language}\"";

        // Add flags
        foreach ($flags as $v) {
            // Skip default flags
            if ($v == '') {
                continue;
            }

            $sql .= "\n{$v}";
        }

        $status = $this->execute($sql);
        if ($status != 0) {
            $this->rollbackTransaction();

            return -3;
        }

        /* set the comment */
        $status = $this->setComment('FUNCTION', "\"{$funcname}\"({$args})", null, $comment);
        if ($status != 0) {
            $this->rollbackTransaction();

            return -4;
        }

        return $this->endTransaction();
    }

    // Index functions

    /**
     * Clusters an index.
     *
     * @param string $table The table the index is on
     * @param string $index The name of the index
     *
     * @return array 0 if operation was successful
     */
    public function clusterIndex($table = '', $index = '')
    {
        $sql = 'CLUSTER';

        // We don't bother with a transaction here, as there's no point rolling
        // back an expensive cluster if a cheap analyze fails for whatever reason

        if (!empty($table)) {
            $f_schema = $this->_schema;
            $this->fieldClean($f_schema);
            $this->fieldClean($table);

            if (!empty($index)) {
                $this->fieldClean($index);
                $sql .= " \"{$index}\" ON \"{$f_schema}\".\"{$table}\"";
            } else {
                $sql .= " \"{$f_schema}\".\"{$table}\"";
            }
        }

        $status = $this->execute($sql);

        return [$status, $sql];
    }

    // Operator functions

    /**
     * Returns all details for a particular operator.
     *
     * @param int $operator_oid The oid of the operator
     *
     * @return \PHPPgAdmin\ADORecordSet Function info
     */
    public function getOperator($operator_oid)
    {
        $this->clean($operator_oid);

        $sql = "
			SELECT
				po.oid, po.oprname,
				oprleft::pg_catalog.regtype AS oprleftname,
				oprright::pg_catalog.regtype AS oprrightname,
				oprresult::pg_catalog.regtype AS resultname,
				po.oprcanhash,
				oprcom::pg_catalog.regoperator AS oprcom,
				oprnegate::pg_catalog.regoperator AS oprnegate,
				oprlsortop::pg_catalog.regoperator AS oprlsortop,
				oprrsortop::pg_catalog.regoperator AS oprrsortop,
				oprltcmpop::pg_catalog.regoperator AS oprltcmpop,
				oprgtcmpop::pg_catalog.regoperator AS oprgtcmpop,
				po.oprcode::pg_catalog.regproc AS oprcode,
				po.oprrest::pg_catalog.regproc AS oprrest,
				po.oprjoin::pg_catalog.regproc AS oprjoin
			FROM
				pg_catalog.pg_operator po
			WHERE
				po.oid='{$operator_oid}'
		";

        return $this->selectSet($sql);
    }

    // Operator Class functions

    /**
     * Gets all opclasses.
     *
     * @return \PHPPgAdmin\ADORecordSet A recordset
     */
    public function getOpClasses()
    {
        $c_schema = $this->_schema;
        $this->clean($c_schema);
        $sql = "
			SELECT
				pa.amname,
				po.opcname,
				po.opcintype::pg_catalog.regtype AS opcintype,
				po.opcdefault,
				pg_catalog.obj_description(po.oid, 'pg_opclass') AS opccomment
			FROM
				pg_catalog.pg_opclass po, pg_catalog.pg_am pa, pg_catalog.pg_namespace pn
			WHERE
				po.opcamid=pa.oid
				AND po.opcnamespace=pn.oid
				AND pn.nspname='{$c_schema}'
			ORDER BY 1,2
		";

        return $this->selectSet($sql);
    }

    // Capabilities

    public function hasCreateTableLikeWithIndexes()
    {
        return false;
    }

    public function hasEnumTypes()
    {
        return false;
    }

    public function hasFTS()
    {
        return false;
    }

    public function hasFunctionCosting()
    {
        return false;
    }

    public function hasFunctionGUC()
    {
        return false;
    }

    public function hasVirtualTransactionId()
    {
        return false;
    }
}


1			<?php
2
3			/**
4			* PHPPgAdmin v6.0.0-beta.48
5			*/
6
7			namespace PHPPgAdmin\Database;
8
9			/**
10			* @file
11			* PostgreSQL 8.2 support
12			*
13			* Id: Postgres82.php,v 1.10 2007/12/28 16:21:25 ioguix Exp $
14			*
15			* @package PHPPgAdmin
16			*/
17			class Postgres82 extends Postgres83
18			{
19			public $major_version = 8.2;
20
21			// Select operators
22			public $selectOps = [
23			'=' => 'i',
24			'!=' => 'i',
25			'<' => 'i',
26			'>' => 'i',
27			'<=' => 'i',
28			'>=' => 'i',
29			'<<' => 'i',
30			'>>' => 'i',
31			'<<=' => 'i',
32			'>>=' => 'i',
33			'LIKE' => 'i',
34			'NOT LIKE' => 'i',
35			'ILIKE' => 'i',
36			'NOT ILIKE' => 'i',
37			'SIMILAR TO' => 'i',
38			'NOT SIMILAR TO' => 'i',
39			'~' => 'i',
40			'!~' => 'i',
41			'~*' => 'i',
42			'!~*' => 'i',
43			'IS NULL' => 'p',
44			'IS NOT NULL' => 'p',
45			'IN' => 'x',
46			'NOT IN' => 'x',
47			];
48
49			// Database functions
50
51			/**
52			* Returns table locks information in the current database.
53			*
54			* @return \PHPPgAdmin\ADORecordSet A recordset
55			*/
56			public function getLocks()
57			{
58			$conf = $this->conf;
59
60			if (!$conf['show_system']) {
61			$where = 'AND pn.nspname NOT LIKE $$pg\_%$$';
62			} else {
63			$where = "AND nspname !~ '^pg_t(emp_[0-9]+\|oast)$'";
64			}
65
66			$sql = "SELECT pn.nspname, pc.relname AS tablename, pl.transaction, pl.pid, pl.mode, pl.granted
67			FROM pg_catalog.pg_locks pl, pg_catalog.pg_class pc, pg_catalog.pg_namespace pn
68			WHERE pl.relation = pc.oid AND pc.relnamespace=pn.oid {$where}
69			ORDER BY nspname,tablename";
70
71			return $this->selectSet($sql);
72			}
73
74			// Sequence functions
75
76			/**
77			* Rename a sequence.
78			*
79			* @param \PHPPgAdmin\ADORecordSet $seqrs The sequence RecordSet returned by getSequence()
80			* @param string $name The new name for the sequence
81			*
82			* @return int 0 if operation was successful
83			*/
84			public function alterSequenceName($seqrs, $name)
85			{
86			/* vars are cleaned in _alterSequence */
87			if (!empty($name) && ($seqrs->fields['seqname'] != $name)) {
88			$f_schema = $this->_schema;
89			$this->fieldClean($f_schema);
90			$sql = "ALTER TABLE \"{$f_schema}\".\"{$seqrs->fields['seqname']}\" RENAME TO \"{$name}\"";
91			$status = $this->execute($sql);
92			if ($status == 0) {
93			$seqrs->fields['seqname'] = $name;
94			} else {
95			return $status;
96			}
97			}
98
99			return 0;
100			}
101
102			// View functions
103
104			/**
105			* Rename a view.
106			*
107			* @param \PHPPgAdmin\ADORecordSet $vwrs The view recordSet returned by getView()
108			* @param string $name The new view's name
109			*
110			* @return int -1 if Failed
111			*/
112			public function alterViewName($vwrs, $name)
113			{
114			// Rename (only if name has changed)
115			/* $vwrs and $name are cleaned in _alterView */
116			if (!empty($name) && ($name != $vwrs->fields['relname'])) {
117			$f_schema = $this->_schema;
118			$this->fieldClean($f_schema);
119			$sql = "ALTER TABLE \"{$f_schema}\".\"{$vwrs->fields['relname']}\" RENAME TO \"{$name}\"";
120			$status = $this->execute($sql);
121			if ($status == 0) {
122			$vwrs->fields['relname'] = $name;
123			} else {
124			return $status;
125			}
126			}
127
128			return 0;
129			}
130
131			// Trigger functions
132
133			/**
134			* Grabs a list of triggers on a table.
135			*
136			* @param string $table The name of a table whose triggers to retrieve
137			*
138			* @return \PHPPgAdmin\ADORecordSet A recordset
139			*/
140			public function getTriggers($table = '')
141			{
142			$c_schema = $this->_schema;
143			$this->clean($c_schema);
144			$this->clean($table);
145
146			$sql = "SELECT
147			t.tgname, pg_catalog.pg_get_triggerdef(t.oid) AS tgdef, t.tgenabled, p.oid AS prooid,
148			p.proname \|\| ' (' \|\| pg_catalog.oidvectortypes(p.proargtypes) \|\| ')' AS proproto,
149			ns.nspname AS pronamespace
150			FROM pg_catalog.pg_trigger t, pg_catalog.pg_proc p, pg_catalog.pg_namespace ns
151			WHERE t.tgrelid = (SELECT oid FROM pg_catalog.pg_class WHERE relname='{$table}'
152			AND relnamespace=(SELECT oid FROM pg_catalog.pg_namespace WHERE nspname='{$c_schema}'))
153			AND (NOT tgisconstraint OR NOT EXISTS
154			(SELECT 1 FROM pg_catalog.pg_depend d JOIN pg_catalog.pg_constraint c
155			ON (d.refclassid = c.tableoid AND d.refobjid = c.oid)
156			WHERE d.classid = t.tableoid AND d.objid = t.oid AND d.deptype = 'i' AND c.contype = 'f'))
157			AND p.oid=t.tgfoid
158			AND p.pronamespace = ns.oid";
159
160			return $this->selectSet($sql);
161			}
162
163			// Function functions
164
165			/**
166			* Returns all details for a particular function.
167			*
168			* @param int $function_oid
169			*
170			* @return \PHPPgAdmin\ADORecordSet Function info
171			*
172			* @internal param string The $func name of the function to retrieve
173			*/
174			public function getFunction($function_oid)
175			{
176			$this->clean($function_oid);
177
178			$sql = "SELECT
179			pc.oid AS prooid,
180			proname,
181			pg_catalog.pg_get_userbyid(proowner) AS proowner,
182			nspname as proschema,
183			lanname as prolanguage,
184			pg_catalog.format_type(prorettype, NULL) as proresult,
185			prosrc,
186			probin,
187			proretset,
188			proisstrict,
189			provolatile,
190			prosecdef,
191			pg_catalog.oidvectortypes(pc.proargtypes) AS proarguments,
192			proargnames AS proargnames,
193			pg_catalog.obj_description(pc.oid, 'pg_proc') AS procomment
194			FROM
195			pg_catalog.pg_proc pc, pg_catalog.pg_language pl, pg_catalog.pg_namespace pn
196			WHERE
197			pc.oid = '{$function_oid}'::oid
198			AND pc.prolang = pl.oid
199			AND pc.pronamespace = pn.oid
200			";
201
202			return $this->selectSet($sql);
203			}
204
205			/**
206			* Creates a new function.
207			*
208			* @param string $funcname The name of the function to create
209			* @param string $args A comma separated string of types
210			* @param string $returns The return type
211			* @param string $definition The definition for the new function
212			* @param string $language The language the function is written for
213			* @param array $flags An array of optional flags
214			* @param bool $setof True if it returns a set, false otherwise
215			* @param float $cost cost the planner should use in the function execution step
216			* @param int $rows number of rows planner should estimate will be returned
217			* @param string $comment The comment on the function
218			* @param bool $replace (optional) True if OR REPLACE, false for normal
219			*
220			* @return bool\|int 0 success
221			*/
222			public function createFunction($funcname, $args, $returns, $definition, $language, $flags, $setof, $cost, $rows, $comment, $replace = false)
223			{
224			// Begin a transaction
225			$status = $this->beginTransaction();
226			if ($status != 0) {
227			$this->rollbackTransaction();
228
229			return -1;
230			}
231
232			$f_schema = $this->_schema;
233			$this->fieldClean($f_schema);
234			$this->fieldClean($funcname);
235			$this->clean($args);
236			$this->fieldClean($language);
237			$this->arrayClean($flags);
238
239			$sql = 'CREATE';
240			if ($replace) {
241			$sql .= ' OR REPLACE';
242			}
243
244			$sql .= " FUNCTION \"{$f_schema}\".\"{$funcname}\" (";
245
246			if ($args != '') {
247			$sql .= $args;
248			}
249
250			// For some reason, the returns field cannot have quotes...
251			$sql .= ') RETURNS ';
252			if ($setof) {
253			$sql .= 'SETOF ';
254			}
255
256			$sql .= "{$returns} AS ";
257
258			if (is_array($definition)) {
259			$this->arrayClean($definition);
260			$sql .= "'".$definition[0]."'";
261			if ($definition[1]) {
262			$sql .= ",'".$definition[1]."'";
263			}
264			} else {
265			$this->clean($definition);
266			$sql .= "'".$definition."'";
267			}
268
269			$sql .= " LANGUAGE \"{$language}\"";
270
271			// Add flags
272			foreach ($flags as $v) {
273			// Skip default flags
274			if ($v == '') {
275			continue;
276			}
277
278			$sql .= "\n{$v}";
279			}
280
281			$status = $this->execute($sql);
282			if ($status != 0) {
283			$this->rollbackTransaction();
284
285			return -3;
286			}
287
288			/* set the comment */
289			$status = $this->setComment('FUNCTION', "\"{$funcname}\"({$args})", null, $comment);
290			if ($status != 0) {
291			$this->rollbackTransaction();
292
293			return -4;
294			}
295
296			return $this->endTransaction();
297			}
298
299			// Index functions
300
301			/**
302			* Clusters an index.
303			*
304			* @param string $table The table the index is on
305			* @param string $index The name of the index
306			*
307			* @return array 0 if operation was successful
308			*/
309			public function clusterIndex($table = '', $index = '')
310			{
311			$sql = 'CLUSTER';
312
313			// We don't bother with a transaction here, as there's no point rolling
314			// back an expensive cluster if a cheap analyze fails for whatever reason
315
316			if (!empty($table)) {
317			$f_schema = $this->_schema;
318			$this->fieldClean($f_schema);
319			$this->fieldClean($table);
320
321			if (!empty($index)) {
322			$this->fieldClean($index);
323			$sql .= " \"{$index}\" ON \"{$f_schema}\".\"{$table}\"";
324			} else {
325			$sql .= " \"{$f_schema}\".\"{$table}\"";
326			}
327			}
328
329			$status = $this->execute($sql);
330
331			return [$status, $sql];
332			}
333
334			// Operator functions
335
336			/**
337			* Returns all details for a particular operator.
338			*
339			* @param int $operator_oid The oid of the operator
340			*
341			* @return \PHPPgAdmin\ADORecordSet Function info
342			*/
343			public function getOperator($operator_oid)
344			{
345			$this->clean($operator_oid);
346
347			$sql = "
348			SELECT
349			po.oid, po.oprname,
350			oprleft::pg_catalog.regtype AS oprleftname,
351			oprright::pg_catalog.regtype AS oprrightname,
352			oprresult::pg_catalog.regtype AS resultname,
353			po.oprcanhash,
354			oprcom::pg_catalog.regoperator AS oprcom,
355			oprnegate::pg_catalog.regoperator AS oprnegate,
356			oprlsortop::pg_catalog.regoperator AS oprlsortop,
357			oprrsortop::pg_catalog.regoperator AS oprrsortop,
358			oprltcmpop::pg_catalog.regoperator AS oprltcmpop,
359			oprgtcmpop::pg_catalog.regoperator AS oprgtcmpop,
360			po.oprcode::pg_catalog.regproc AS oprcode,
361			po.oprrest::pg_catalog.regproc AS oprrest,
362			po.oprjoin::pg_catalog.regproc AS oprjoin
363			FROM
364			pg_catalog.pg_operator po
365			WHERE
366			po.oid='{$operator_oid}'
367			";
368
369			return $this->selectSet($sql);
370			}
371
372			// Operator Class functions
373
374			/**
375			* Gets all opclasses.
376			*
377			* @return \PHPPgAdmin\ADORecordSet A recordset
378			*/
379			public function getOpClasses()
380			{
381			$c_schema = $this->_schema;
382			$this->clean($c_schema);
383			$sql = "
384			SELECT
385			pa.amname,
386			po.opcname,
387			po.opcintype::pg_catalog.regtype AS opcintype,
388			po.opcdefault,
389			pg_catalog.obj_description(po.oid, 'pg_opclass') AS opccomment
390			FROM
391			pg_catalog.pg_opclass po, pg_catalog.pg_am pa, pg_catalog.pg_namespace pn
392			WHERE
393			po.opcamid=pa.oid
394			AND po.opcnamespace=pn.oid
395			AND pn.nspname='{$c_schema}'
396			ORDER BY 1,2
397			";
398
399			return $this->selectSet($sql);
400			}
401
402			// Capabilities
403
404			public function hasCreateTableLikeWithIndexes()
405			{
406			return false;
407			}
408
409			public function hasEnumTypes()
410			{
411			return false;
412			}
413
414			public function hasFTS()
415			{
416			return false;
417			}
418
419			public function hasFunctionCosting()
420			{
421			return false;
422			}
423
424			public function hasFunctionGUC()
425			{
426			return false;
427			}
428
429			public function hasVirtualTransactionId()
430			{
431			return false;
432			}
433			}
434

HuasoFoundries / phpPgAdmin6

Push — develop ( c2019a...2cab77 )

Postgres82::getOpClasses() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like