WhereQueryBuilder::buildWhereRawQuery() - Code Metrics - Inspection of "fixed coding standards" - CruzerSoftwares/Dolphin - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d07708...58b099 )

by RN

created 2019-12-29 11:48 UTC

WhereQueryBuilder::buildWhereRawQuery() A

↳ Parent: WhereQueryBuilder

Complexity

Conditions	6
Paths	13

Size

Total Lines	27
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
cc	6
eloc	16
c	3
b	1
f	0
nc	13
nop	2
dl	0
loc	27
rs	9.1111

<?php
/**
 * The Query builder API.
 *
 * @author RN Kushwaha <[email protected]>
 * @since v0.0.1 <Date: 16th April, 2019>
 */

namespace Dolphin\Builders;

use Dolphin\Parsers\WhereQueryParser;

/**
 * This class provides the mechanism to build the Where Queries.
 */
class WhereQueryBuilder extends QueryBuilder
{
    private $qb;

    public function __construct(){
        $this->qb = new QueryBuilder();
    }

    private function buildWhereInClauseQuery($terms = array())
    {
        if (is_int($terms[0])) {
            $dataStr = join(',', $terms);
            return $dataStr;
        } elseif (is_string($terms[0])) {
            $dataStr = join("', '", $terms);
            $dataStr = "'".$dataStr."'";
            return $dataStr;
        }

        return null;
    }

    private function whereAddedCondition($conditions = array()){
      return $this->whereAdded === false && count($conditions);
    }

    public function buildWhereQuery($conditions = array())
    {
        $whereQuery = array();
        if (count($conditions)<=0) {
            return array();
        }

        $firstTime = true;
        if ($this->whereAddedCondition($conditions)) {
          $whereQuery[] = 'WHERE';
          $this->whereAdded = true;
        }

        foreach ($conditions as $where) {
            $sign = '=';
            if(count($where)==3) {
                $sign = $where[1];
            }
            if ($firstTime) {
                $whereQuery[] = $this->qb->quote(trim($where[0])).' '.$sign.' '.$this->qb->enclose(end($where));
                $firstTime = false;
            } else {
                $whereQuery[] = 'AND '.$this->qb->quote(trim($where[0])).' '.$sign.' '.$this->qb->enclose(end($where));
            }
        }

        return $whereQuery;
    }

    public function buildWhereRawQuery($conditions = array(), $query = array())
    {
        $whereRawQuery = array();

        if (count($conditions)<=0) {
            return $query;
        }

        $firstTime = true;
        if ($this->whereAddedCondition($conditions)) {
            $whereRawQuery[] = 'WHERE';
            $this->whereAdded = true;
        }

        foreach ($conditions as $whereRaw) {
            if ($firstTime === true) {
                $whereRawQuery[] = $whereRaw;
                $firstTime = false;
            } else {
                $whereRawQuery[] = 'AND '.$whereRaw;
            }
        }

        if (count($whereRawQuery)) {
            $query = array_merge($query, $whereRawQuery);
        }
        return $query;
    }

    public function buildWhereInQuery($conditions = array())
    {
        $whereInQuery = array();

        if (count($conditions)<=0) {
            return array();
        }

        $firstTime = false;
        if ($this->whereAdded === false) {
            $whereInQuery[] = 'WHERE';
            $firstTime = true;
            $this->whereAdded = true;
        }

        foreach ($conditions as $whereIn) {
            $dataStr = $this->buildWhereInClauseQuery($whereIn[1]);
            if ($dataStr === null) {
                continue;
            }

            if ($firstTime) {
                $whereInQuery[] = trim($whereIn[0]).' IN ('.$dataStr.')';
                $firstTime = false;
            } else {
                $whereInQuery[] = 'AND '.trim($whereIn[0]).' IN ('.$dataStr.')';
            }
        }

        return $whereInQuery;
    }

    public function buildWhereNotInQuery($conditions = array())
    {
        $whereNotInQuery = array();

        if (count($conditions)<=0) {
            return array();
        }

        $firstTime = false;
        if ($this->whereAdded === false) {
            $whereNotInQuery[] = 'WHERE';
            $firstTime = true;
            $this->whereAdded = true;
        }

        foreach ($conditions as $whereNotIn) {
            $dataStr = $this->buildWhereInClauseQuery($whereNotIn[1]);
            if ($dataStr === null) {
                continue;
            }

            if ($firstTime) {
                $whereNotInQuery[] = trim($whereNotIn[0]).' NOT IN ('.$dataStr.')';
                $firstTime = false;
            } else {
                $whereNotInQuery[] = 'AND '.trim($whereNotIn[0]).' NOT IN ('.$dataStr.')';
            }
        }

        return $whereNotInQuery;
    }

    public function buildWhereNullQuery($conditions = array(), $query = array())
    {
        $whereNullQuery = array();

        if (count($conditions)<=0) {
            return $query;
        }

        $firstTime = false;
        if ($this->whereAdded === false) {
            $whereNullQuery[] = 'WHERE';
            $firstTime = true;
            $this->whereAdded = true;
        }

        foreach ($conditions as $whereNull) {
            if ($firstTime) {
                $whereNullQuery[] = trim($whereNull).' IS NULL';
                $firstTime = false;
            } else {
                $whereNullQuery[] = 'AND '.trim($whereNull).' IS NULL';
            }
        }
        if (count($whereNullQuery)) {
            $query = array_merge($query, $whereNullQuery);
        }
        return $query;
    }

    public function buildWhereNotNullQuery($conditions = array(), $query = array())
    {
        $whereNotNullQuery = array();

        if (count($conditions)<=0) {
            return $query;
        }

        $firstTime = false;
        if ($this->whereAdded === false) {
            $whereNotNullQuery[] = 'WHERE';
            $firstTime = true;
            $this->whereAdded = true;
        }

        foreach ($conditions as $whereNotNull) {
            if ($firstTime) {
                $whereNotNullQuery[] = trim($whereNotNull).' IS NOT NULL';
                $firstTime = false;
            } else {
                $whereNotNullQuery[] = 'AND '.trim($whereNotNull).' IS NOT NULL';
            }
        }
        if (count($whereNotNullQuery)) {
            $query = array_merge($query, $whereNotNullQuery);
        }
        return $query;
    }

    public function buildAllWhereQuery($where, $whereRaw, $whereIn, $whereNotIn, $whereNull, $whereNotNull, $mainQuery = array())
    {
        $query = $this->buildWhereQuery($where);
        $query = $this->buildWhereRawQuery($whereRaw, $query);
        $whereInQuery = $this->buildWhereInQuery($whereIn);
        if (count($whereInQuery)) {
            $query = array_merge($query, $whereInQuery);
        }
        $whereNotInQuery = $this->buildWhereNotInQuery($whereNotIn);
        if (count($whereNotInQuery)) {
            $query = array_merge($query, $whereNotInQuery);
        }
        $query = $this->buildWhereNullQuery($whereNull, $query);
        $query = $this->buildWhereNotNullQuery($whereNotNull, $query);

        if (count($query)) {
            $mainQuery = array_merge($mainQuery, $query);
        }
        return $mainQuery;
    }
}


1			<?php
2			/**
3			* The Query builder API.
4			*
5			* @author RN Kushwaha <[email protected]>
6			* @since v0.0.1 <Date: 16th April, 2019>
7			*/
8
9			namespace Dolphin\Builders;
10
11			use Dolphin\Parsers\WhereQueryParser;
12
13			/**
14			* This class provides the mechanism to build the Where Queries.
15			*/
16			class WhereQueryBuilder extends QueryBuilder
17			{
18			private $qb;
19
20			public function __construct(){
21			$this->qb = new QueryBuilder();
22			}
23
24			private function buildWhereInClauseQuery($terms = array())
25			{
26			if (is_int($terms[0])) {
27			$dataStr = join(',', $terms);
28			return $dataStr;
29			} elseif (is_string($terms[0])) {
30			$dataStr = join("', '", $terms);
31			$dataStr = "'".$dataStr."'";
32			return $dataStr;
33			}
34
35			return null;
36			}
37
38			private function whereAddedCondition($conditions = array()){
39			return $this->whereAdded === false && count($conditions);
40			}
41
42			public function buildWhereQuery($conditions = array())
43			{
44			$whereQuery = array();
45			if (count($conditions)<=0) {
46			return array();
47			}
48
49			$firstTime = true;
50			if ($this->whereAddedCondition($conditions)) {
51			$whereQuery[] = 'WHERE';
52			$this->whereAdded = true;
53			}
54
55			foreach ($conditions as $where) {
56			$sign = '=';
57			if(count($where)==3) {
58			$sign = $where[1];
59			}
60			if ($firstTime) {
61			$whereQuery[] = $this->qb->quote(trim($where[0])).' '.$sign.' '.$this->qb->enclose(end($where));
62			$firstTime = false;
63			} else {
64			$whereQuery[] = 'AND '.$this->qb->quote(trim($where[0])).' '.$sign.' '.$this->qb->enclose(end($where));
65			}
66			}
67
68			return $whereQuery;
69			}
70
71			public function buildWhereRawQuery($conditions = array(), $query = array())
72			{
73			$whereRawQuery = array();
74
75			if (count($conditions)<=0) {
76			return $query;
77			}
78
79			$firstTime = true;
80			if ($this->whereAddedCondition($conditions)) {
81			$whereRawQuery[] = 'WHERE';
82			$this->whereAdded = true;
83			}
84
85			foreach ($conditions as $whereRaw) {
86			if ($firstTime === true) {
87			$whereRawQuery[] = $whereRaw;
88			$firstTime = false;
89			} else {
90			$whereRawQuery[] = 'AND '.$whereRaw;
91			}
92			}
93
94			if (count($whereRawQuery)) {
95			$query = array_merge($query, $whereRawQuery);
96			}
97			return $query;
98			}
99
100			public function buildWhereInQuery($conditions = array())
101			{
102			$whereInQuery = array();
103
104			if (count($conditions)<=0) {
105			return array();
106			}
107
108			$firstTime = false;
109			if ($this->whereAdded === false) {
110			$whereInQuery[] = 'WHERE';
111			$firstTime = true;
112			$this->whereAdded = true;
113			}
114
115			foreach ($conditions as $whereIn) {
116			$dataStr = $this->buildWhereInClauseQuery($whereIn[1]);
117			if ($dataStr === null) {
118			continue;
119			}
120
121			if ($firstTime) {
122			$whereInQuery[] = trim($whereIn[0]).' IN ('.$dataStr.')';
123			$firstTime = false;
124			} else {
125			$whereInQuery[] = 'AND '.trim($whereIn[0]).' IN ('.$dataStr.')';
126			}
127			}
128
129			return $whereInQuery;
130			}
131
132			public function buildWhereNotInQuery($conditions = array())
133			{
134			$whereNotInQuery = array();
135
136			if (count($conditions)<=0) {
137			return array();
138			}
139
140			$firstTime = false;
141			if ($this->whereAdded === false) {
142			$whereNotInQuery[] = 'WHERE';
143			$firstTime = true;
144			$this->whereAdded = true;
145			}
146
147			foreach ($conditions as $whereNotIn) {
148			$dataStr = $this->buildWhereInClauseQuery($whereNotIn[1]);
149			if ($dataStr === null) {
150			continue;
151			}
152
153			if ($firstTime) {
154			$whereNotInQuery[] = trim($whereNotIn[0]).' NOT IN ('.$dataStr.')';
155			$firstTime = false;
156			} else {
157			$whereNotInQuery[] = 'AND '.trim($whereNotIn[0]).' NOT IN ('.$dataStr.')';
158			}
159			}
160
161			return $whereNotInQuery;
162			}
163
164			public function buildWhereNullQuery($conditions = array(), $query = array())
165			{
166			$whereNullQuery = array();
167
168			if (count($conditions)<=0) {
169			return $query;
170			}
171
172			$firstTime = false;
173			if ($this->whereAdded === false) {
174			$whereNullQuery[] = 'WHERE';
175			$firstTime = true;
176			$this->whereAdded = true;
177			}
178
179			foreach ($conditions as $whereNull) {
180			if ($firstTime) {
181			$whereNullQuery[] = trim($whereNull).' IS NULL';
182			$firstTime = false;
183			} else {
184			$whereNullQuery[] = 'AND '.trim($whereNull).' IS NULL';
185			}
186			}
187			if (count($whereNullQuery)) {
188			$query = array_merge($query, $whereNullQuery);
189			}
190			return $query;
191			}
192
193			public function buildWhereNotNullQuery($conditions = array(), $query = array())
194			{
195			$whereNotNullQuery = array();
196
197			if (count($conditions)<=0) {
198			return $query;
199			}
200
201			$firstTime = false;
202			if ($this->whereAdded === false) {
203			$whereNotNullQuery[] = 'WHERE';
204			$firstTime = true;
205			$this->whereAdded = true;
206			}
207
208			foreach ($conditions as $whereNotNull) {
209			if ($firstTime) {
210			$whereNotNullQuery[] = trim($whereNotNull).' IS NOT NULL';
211			$firstTime = false;
212			} else {
213			$whereNotNullQuery[] = 'AND '.trim($whereNotNull).' IS NOT NULL';
214			}
215			}
216			if (count($whereNotNullQuery)) {
217			$query = array_merge($query, $whereNotNullQuery);
218			}
219			return $query;
220			}
221
222			public function buildAllWhereQuery($where, $whereRaw, $whereIn, $whereNotIn, $whereNull, $whereNotNull, $mainQuery = array())
223			{
224			$query = $this->buildWhereQuery($where);
225			$query = $this->buildWhereRawQuery($whereRaw, $query);
226			$whereInQuery = $this->buildWhereInQuery($whereIn);
227			if (count($whereInQuery)) {
228			$query = array_merge($query, $whereInQuery);
229			}
230			$whereNotInQuery = $this->buildWhereNotInQuery($whereNotIn);
231			if (count($whereNotInQuery)) {
232			$query = array_merge($query, $whereNotInQuery);
233			}
234			$query = $this->buildWhereNullQuery($whereNull, $query);
235			$query = $this->buildWhereNotNullQuery($whereNotNull, $query);
236
237			if (count($query)) {
238			$mainQuery = array_merge($mainQuery, $query);
239			}
240			return $mainQuery;
241			}
242			}
243

CruzerSoftwares / Dolphin

Push — master ( d07708...58b099 )

WhereQueryBuilder::buildWhereRawQuery() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like