========================================================================================================
===  Tidy report for :M:\romaSql-1.0.2\queryBuilder.au3
========================================================================================================

00001    ;-- TIME_STAMP   2017-03-05 20:00:22   v 0.1
00002    
00003    #include-once
00004    #include <queryBuilder.au3>
00005    
00006    ; #FUNCTION# ====================================================================================================================
00007    ; Author ........: 4ern.de
00008    ; Building ......:
00009    ;				   - SELECT oder DISTINCT
00010    ;				   - Take (only sqlServer)
00011    ;				   - From Table
00012    ;				   - LIMIT
00013    ;				   - Joins - (in Plannung)
00014    ;				   - WHERE
00015    ;				   - Groupby
00016    ;				   - Having
00017    ;				   - Order BY
00018    ; ===============================================================================================================================
00019  +-func __4ern_SQL_QueryBuilder_get()
00020  |    
00021  |    	Local $SQL = Null
00022  |    
00023  |    	;----------------------------------------------------------------------------------------------/
00024  |    	; Stelle SQL String zusammen.
00025  |    	;----------------------------------------------------------------------------------------------/
00026  |    		$select  = __4ern_SQL__QueryBuilder__select('get')
00027  |    		$from    = __4ern_SQL__QueryBuilder__table('get')
00028  |    		if @error then return SetError(@error, 0, $from)
00029  |    
00030  |    		;----------------------------------------------------------------------------------------------/
00031  |    		; Bei SQL-Server nehmen Take anstatt von LIMIT
00032  |    		;----------------------------------------------------------------------------------------------/
00033  |    		$limit   = (__4ern_SQL_Connection() <> 'sqlServer') ? __4ern_SQL__QueryBuilder__limit(-1,'get') : ''
00034  |    		$where   = __4ern_SQL__QueryBuilder__where('getWhere')
00035  |    		$groupBy = __4ern_SQL__QueryBuilder__groupBy('get')
00036  |    		$having  = __4ern_SQL__QueryBuilder__where('getHaving')
00037  |    		$orderBy = __4ern_SQL__QueryBuilder__orderBy('get')
00038  |    
00039  |    	;----------------------------------------------------------------------------------------------/
00040  |    	; Erstelle SQL String
00041  |    	;----------------------------------------------------------------------------------------------/
00042  |    		$SQL = StringStripWS($select & $from & $where & $groupBy & $having & $orderBy & $limit, 4)
00043  |    
00044  |    	;----------------------------------------------------------------------------------------------/
00045  |    	; Feuere Abfrage ab.
00046  |    	;----------------------------------------------------------------------------------------------/
00047  |    	$ret = __4ern_SQL_rawQuery($SQL,'get()')
00048  |    	return SetError(@error, 0, $ret)
00049  +-endfunc
00050    
00051    ; #FUNCTION# ====================================================================================================================
00052    ; Author ........: 4ern.de
00053    ; Description....: UPDATE Statement
00054    ; Source.........: https://www.w3schools.com/sql/sql_update.asp
00055    ; ===============================================================================================================================
00056  +-func __4ern_SQL_QueryBuilder_Update(ByRef $COLM, $VAL = DEFAULT)
00057  |    
00058  |    	Local $SQL    = NULL
00059  |    	Local $String = ''
00060  |    
00061  |    	;----------------------------------------------------------------------------------------------/
00062  |    	; Erstelle Update String
00063  |    	;----------------------------------------------------------------------------------------------/
00064  |  +-		if IsArray($COLM) then
00065  |  |    			$iColm = UBound($COLM, 2)
00066  |  |  +-			Select
00067  |  |  |    
00068  |  |  |    				;----------------------------------------------------------------------------------------------/
00069  |  |  |    				; 1D Array
00070  |  |  |    				;----------------------------------------------------------------------------------------------/
00071  |  |  |  +-				Case $iColm = 0
00072  |  |  |  |    					__4ern_SQL_Console('error', 'UPDATE -- QUERY BUILDER', '2D Array erforderlich')
00073  |  |  |  |    					return SetError(1, 0, 0)
00074  |  |  |  |    
00075  |  |  |  +-				Case $iColm > 2
00076  |  |  |  |    					__4ern_SQL_Console('error', 'UPDATE -- QUERY BUILDER', '2D Array erforderlich')
00077  |  |  |  |    					return SetError(1, 0, 0)
00078  |  |  |  |    
00079  |  |  |  |    				;----------------------------------------------------------------------------------------------/
00080  |  |  |  |    				; 2D Array with 2 Colms
00081  |  |  |  |    				; Without Operators
00082  |  |  |  |    				;----------------------------------------------------------------------------------------------/
00083  |  |  |  +-				Case $iColm = 2
00084  |  |  |  |  +-					for $i = 0 to $iColm -1
00085  |  |  |  |  |  +-						if (IsString($COLM[$i][1]) = 1) and (StringRegExp($COLM[$i][1], '\w*\(\)|NULL') = 0) then
00086  |  |  |  |  |  |    							$String &= StringFormat('%s="%s", ',$COLM[$i][0],$COLM[$i][1])
00087  |  |  |  |  |  +-						else
00088  |  |  |  |  |  |    							$String &= StringFormat('%s=%s, ',$COLM[$i][0],$COLM[$i][1])
00089  |  |  |  |  |  +-						endif
00090  |  |  |  |  +-					next
00091  |  |  |  |    					$String = StringReplace($String, ', ', '', -1)
00092  |  |  +-			endselect
00093  |  +-		else
00094  |  |  +-			if $VAL = DEFAULT then
00095  |  |  |    				__4ern_SQL_Console('error', 'UPDATE -- QUERY BUILDER', 'Es wurde kein Update Wert eingegeben')
00096  |  |  |    				return SetError(1, 0, 0)
00097  |  |  +-			endif
00098  |  |  +-			if (IsString($VAL) = 1) and (StringRegExp($VAL, '\w*\(\)|NULL') = 0) then
00099  |  |  |    				$String &= StringFormat('%s="%s" ',$COLM,$VAL)
00100  |  |  +-			else
00101  |  |  |    				$String &= StringFormat('%s=%s ',$COLM,$VAL)
00102  |  |  +-			endif
00103  |  +-		endif
00104  |    
00105  |    	;----------------------------------------------------------------------------------------------/
00106  |    	; Stelle SQL String zusammen.
00107  |    	;----------------------------------------------------------------------------------------------/get')
00108  |    
00109  |    		$table = __4ern_SQL__QueryBuilder__table('get')
00110  |    		if @error then return SetError(@error, 0, $table)
00111  |    		$table = StringReplace($table, 'FROM', 'UPDATE')
00112  |    		$table = (StringSplit($table, ',', 2))[0] & ' SET '
00113  |    		$where = __4ern_SQL__QueryBuilder__where('getWhere')
00114  |    
00115  |    	;----------------------------------------------------------------------------------------------/
00116  |    	; Erstelle SQL String
00117  |    	;----------------------------------------------------------------------------------------------/
00118  |    	$SQL = StringStripWS($table & $String &' '& $where, 4)
00119  |    
00120  |    	;----------------------------------------------------------------------------------------------/
00121  |    	; Feuere Abfrage ab.
00122  |    	;----------------------------------------------------------------------------------------------/
00123  |    	return __4ern_SQL_rawQuery($SQL,'update()')
00124  +-endfunc
00125    
00126    ; #FUNCTION# ====================================================================================================================
00127    ; Author ........: 4ern.de
00128    ; Description....: DELTE Statement
00129    ; Source.........: https://www.w3schools.com/sql/sql_delete.asp
00130    ; ===============================================================================================================================
00131  +-func __4ern_SQL_QueryBuilder_Delete()
00132  |    
00133  |    	Local $SQL    = NULL
00134  |    	Local $String = ''
00135  |    	;----------------------------------------------------------------------------------------------/
00136  |    	; Stelle SQL String zusammen.
00137  |    	;----------------------------------------------------------------------------------------------/get')
00138  |    
00139  |    		$table = __4ern_SQL__QueryBuilder__table('get')
00140  |    		if @error then return SetError(@error, 0, $table)
00141  |    		$where   = __4ern_SQL__QueryBuilder__where('getWhere')
00142  |    
00143  |    	;----------------------------------------------------------------------------------------------/
00144  |    	; Erstelle SQL String
00145  |    	;----------------------------------------------------------------------------------------------/
00146  |    	$SQL = StringStripWS('DELETE ' & $table & $String & $where, 4)
00147  |    
00148  |    	;----------------------------------------------------------------------------------------------/
00149  |    	; Feuere Abfrage ab.
00150  |    	;----------------------------------------------------------------------------------------------/
00151  |    	return __4ern_SQL_rawQuery($SQL,'update()')
00152  +-endfunc
00153    
00154    ; #FUNCTION# ====================================================================================================================
00155    ; Author ........: 4ern.de
00156    ; Description....: INSERT INTO Statement
00157    ; Source.........: http://www.w3schools.com/sql/sql_insert.asp
00158    ; ===============================================================================================================================
00159  +-func __4ern_SQL_Query_insert($COLM , $V1 = DEFAULT)
00160  |    
00161  |    	local Static $table = __4ern_SQL__QueryBuilder__table('get')
00162  |    		if @error then return SetError(@error, 0, $table)
00163  |    	$table = StringReplace($table, 'FROM', 'INSERT INTO ')
00164  |    
00165  |    	;----------------------------------------------------------------------------------------------/
00166  |    	; Prüfen ob $COLM ein 2D Array ist..
00167  |    	;----------------------------------------------------------------------------------------------/
00168  |  +-	if IsArray($COLM) then
00169  |  |    
00170  |  |    		;----------------------------------------------------------------------------------------------/
00171  |  |    		; Check Array
00172  |  |    		;----------------------------------------------------------------------------------------------/
00173  |  |  +-		if UBound($COLM, 2) <> 2 then
00174  |  |  |    			__4ern_SQL_Console('error', 'Insert Into -- QUERY BUILDER', 'Es muss ein 2D Array mit exakt 2 Spalten sein')
00175  |  |  |    			return SetError(1, 0, 0)
00176  |  |  +-		endif
00177  |  |    
00178  |  |    		$string = ' ('
00179  |  |  +-		for $i = 0 to Ubound($COLM) -1
00180  |  |  |    			$string &= stringformat('%s,' ,$COLM[$i][0])
00181  |  |  +-		next
00182  |  |    		$string = StringReplace($string, ',', '', -1)
00183  |  |    
00184  |  |    		$string &= ') VALUES('
00185  |  |  +-		for $i = 0 to Ubound($COLM) -1
00186  |  |  |  +-			if (IsString($COLM[$i][1]) = 1) and (StringRegExp($COLM[$i][1], '\w*\(\)|NULL') = 0) then
00187  |  |  |  |    				$COLM[$i][1] = StringReplace($COLM[$i][1], '"', '`')
00188  |  |  |  |    				$COLM[$i][1] = StringReplace($COLM[$i][1], "'", '`')
00189  |  |  |  |    				$string &= StringFormat('"%s",', $COLM[$i][1])
00190  |  |  |  +-			else
00191  |  |  |  |    				$string &= StringFormat('%s,', $COLM[$i][1])
00192  |  |  |  +-			endif
00193  |  |  +-		next
00194  |  |    		$string = StringReplace($string, ',', '', -1)
00195  |  |    		$string &= ');'
00196  |  |    
00197  |  |    		;----------------------------------------------------------------------------------------------/
00198  |  |    		; Erstelle SQL String
00199  |  |    		;----------------------------------------------------------------------------------------------/
00200  |  |    		$SQL = StringStripWS($table & $string,4)
00201  |  |    		;----------------------------------------------------------------------------------------------/
00202  |  |    		; Feuere Abfrage ab.
00203  |  |    		;----------------------------------------------------------------------------------------------/
00204  |  |    
00205  |  |    		return __4ern_SQL_rawQuery($SQL,'update()')
00206  |  +-	endif
00207  |    
00208  |    	;----------------------------------------------------------------------------------------------/
00209  |    	; Insert über Parameter
00210  |    	;----------------------------------------------------------------------------------------------/
00211  |    	$V1 = StringReplace($V1, '"', '`')
00212  |    	$V1 = StringReplace($V1, "'", '`')
00213  |    
00214  |  +-	if (IsString($V1) = 1) and (StringRegExp($V1, '\w*\(\)|NULL') = 0) then
00215  |  |    		$string = StringFormat('(%s) VALUES ("%s")', $COLM, $V1)
00216  |  +-	else
00217  |  |    		$string = StringFormat('(%s) VALUES (%s)', $COLM, $V1)
00218  |  +-	endif
00219  |    
00220  |    	$SQL = StringStripWS($table & $string,4)
00221  |    	return __4ern_SQL_rawQuery($SQL,'update()')
00222  +-endfunc
00223    
00224    ; #FUNCTION# ====================================================================================================================
00225    ; Author ........: 4ern.de
00226    ; Description....: Set table command
00227    ; ===============================================================================================================================
00228  +-func __4ern_SQL__QueryBuilder__table($ACTION = DEFAULT, $COLM = DEFAULT)
00229  |    	;----------------------------------------------------------------------------------------------/
00230  |    	; Eigenschaften
00231  |    	;----------------------------------------------------------------------------------------------/
00232  |    	Local Static $QUEUE = ObjCreate("System.Collections.Queue")
00233  |    	if IsObj($QUEUE) = 0 then $QUEUE = ObjCreate("System.Collections.Queue")
00234  |    	if __4ern_SQL__IsDefault($ACTION, '-1,', ',') Then $ACTION = 'store'
00235  |    
00236  |    	;----------------------------------------------------------------------------------------------/
00237  |    	; AKTION
00238  |    	;----------------------------------------------------------------------------------------------/
00239  |  +-	Switch $ACTION
00240  |  |    		;----------------------------------------------------------------------------------------------/
00241  |  |    		; Speichere die Select spalten in eine Queue
00242  |  |    		;----------------------------------------------------------------------------------------------/
00243  |  |  +-		Case 'store'
00244  |  |  |    			;----------------------------------------------------------------------------------------------/
00245  |  |  |    			; Array Verarbeitung
00246  |  |  |    			; 	-> Ansonsten String
00247  |  |  |    			;----------------------------------------------------------------------------------------------/
00248  |  |  |  +-			IF IsArray($COLM) then
00249  |  |  |  |  +-				for $element in $COLM
00250  |  |  |  |  |    					if isstring($element) then $QUEUE.Enqueue($element)
00251  |  |  |  |  +-				next
00252  |  |  |  +-			ELSE
00253  |  |  |  |    				if IsString($COLM) then $QUEUE.Enqueue($COLM)
00254  |  |  |  +-			endif
00255  |  |  |    
00256  |  |  |    		;----------------------------------------------------------------------------------------------/
00257  |  |  |    		; Ermittle alle Elemete aus der Queue, und erstelle an Select String
00258  |  |  |    		;----------------------------------------------------------------------------------------------/
00259  |  |  +-		Case 'get'
00260  |  |  |    
00261  |  |  |    			$String = 'FROM '
00262  |  |  |    			;----------------------------------------------------------------------------------------------/
00263  |  |  |    			; Wenn keine Einträge vorhanden, dann *
00264  |  |  |    			;----------------------------------------------------------------------------------------------/
00265  |  |  |  +-			If $QUEUE.Count = 0 then
00266  |  |  |  |    				$ret =  __4ern_SQL__QueryBuilder__setTable(-1,-1,'getTable')
00267  |  |  |  |    				if @error then return SetError(@error, 0, $ret)
00268  |  |  |  |    				return $String & $ret & ' '
00269  |  |  |  +-			endif
00270  |  |  |    			;----------------------------------------------------------------------------------------------/
00271  |  |  |    			; Erstelle String
00272  |  |  |    			;----------------------------------------------------------------------------------------------/
00273  |  |  |  +-			for $elemet in $QUEUE
00274  |  |  |  |    				$String &= $elemet & ', '
00275  |  |  |  +-			next
00276  |  |  |    			;----------------------------------------------------------------------------------------------/
00277  |  |  |    			; Lösche alle Einträge aus der Queue
00278  |  |  |    			;----------------------------------------------------------------------------------------------/
00279  |  |  |    			$QUEUE.clear
00280  |  |  |    
00281  |  |  |    			;----------------------------------------------------------------------------------------------/
00282  |  |  |    			; Return
00283  |  |  |    			;----------------------------------------------------------------------------------------------/
00284  |  |  |    			return StringReplace($String, ',', '', -1)
00285  |  |  |    
00286  |  +-	EndSwitch
00287  +-endfunc
00288  +-func __4ern_SQL_Query_table($COLM = DEFAULT,$C1=DEFAULT,$C2=DEFAULT,$C3=DEFAULT,$C4=DEFAULT,$C5=DEFAULT,$C6=DEFAULT,$C7=DEFAULT,$C8=DEFAULT,$C9=DEFAULT)
00289  |    
00290  |    	;----------------------------------------------------------------------------------------------/
00291  |    	; Prüfen ob $COLM ein 2D Array ist..
00292  |    	;----------------------------------------------------------------------------------------------/
00293  |  +-	if IsArray($COLM) then
00294  |  |  +-		if UBound($COLM, 2) <> 0 then
00295  |  |  |    			__4ern_SQL_Console('error', 'TABLE -- QUERY BUILDER', 'Es sind nur 1D Arrays erlaubt')
00296  |  |  |    			return SetError(1, 0, 0)
00297  |  |  +-		endif
00298  |  +-	endif
00299  |    
00300  |    	;----------------------------------------------------------------------------------------------/
00301  |    	; Übergabe der Parameter an QueryBuilder
00302  |    	;----------------------------------------------------------------------------------------------/
00303  |    	__4ern_SQL__QueryBuilder__table(-1,$COLM)
00304  |    	Local $aC = [$C1, $C2, $C3, $C4, $C5, $C6, $C7, $C8, $C9]
00305  |  +-	For $Key In $aC
00306  |  |    		If $Key <> DEFAULT then __4ern_SQL__QueryBuilder__table(-1,$Key)
00307  |  +-	Next
00308  |    
00309  |    	return 1
00310  +-endfunc
00311    
00312    ; #FUNCTION# ====================================================================================================================
00313    ; Author ........: 4ern.de
00314    ; Description....: To limit the number of results returned from the query
00315    ; ===============================================================================================================================
00316  +-func __4ern_SQL__QueryBuilder__limit($pLIMIT = DEFAULT, $ACTION = 'set')
00317  |    
00318  |    	Local Static $LIMIT = NULL
00319  |    
00320  |  +-	Switch $ACTION
00321  |  |  +-		Case 'set'
00322  |  |  |  +-			If IsNumber($pLIMIT) then
00323  |  |  |  |    				$LIMIT = $pLIMIT
00324  |  |  |  |    				return
00325  |  |  |  +-			endif
00326  |  |  |    			__4ern_SQL_Console('error', 'TAKE/LIMIT -- QUERY BUILDER', 'Keine gueltige Nummer')
00327  |  |  |    
00328  |  |  +-		Case 'get'
00329  |  |  |    			if $LIMIT = NULL Then return ''
00330  |  |  |    
00331  |  |  |    			Local $defDatabase = __4ern_SQL_Connection()
00332  |  |  |    			;----------------------------------------------------------------------------------------------/
00333  |  |  |    			; Return TOP für SQL Server Syntax
00334  |  |  |    			;----------------------------------------------------------------------------------------------/
00335  |  |  |    			if ($defDatabase = 'sqlserver') then return StringFormat(' TOP %s ', $LIMIT)
00336  |  |  |    
00337  |  |  |    			;----------------------------------------------------------------------------------------------/
00338  |  |  |    			; Setze eine Where Abfrage für Oracle Syntax
00339  |  |  |    			;----------------------------------------------------------------------------------------------/
00340  |  |  |  +-			if ($defDatabase = 'oracle') then
00341  |  |  |  |    				__4ern_SQL_Query_where('ROWNUM','<=', $LIMIT)
00342  |  |  |  |    				return ''
00343  |  |  |  +-			endif
00344  |  |  |    
00345  |  |  |    			;----------------------------------------------------------------------------------------------/
00346  |  |  |    			; Return LIMIT
00347  |  |  |    			;----------------------------------------------------------------------------------------------/
00348  |  |  |    			return StringFormat(' LIMIT %s ', $LIMIT)
00349  |  +-	EndSwitch
00350  +-endfunc
00351    
00352    ; #FUNCTION# ====================================================================================================================
00353    ; Author ........: 4ern.de
00354    ; Description....: SELECT & DISTINCT Statement
00355    ; Source.........: http://www.w3schools.com/sql/sql_select.asp
00356    ; Source.........: http://www.w3schools.com/sql/sql_distinct.asp
00357    ; ===============================================================================================================================
00358  +-func __4ern_SQL__QueryBuilder__select($ACTION = DEFAULT, $COLM = DEFAULT, $METHODE = 'SELECT')
00359  |    	;----------------------------------------------------------------------------------------------/
00360  |    	; Eigenschaften
00361  |    	;----------------------------------------------------------------------------------------------/
00362  |    	Local Static $QUEUE = ObjCreate("System.Collections.Queue")
00363  |    	if __4ern_SQL__IsDefault($ACTION, '-1,', ',') Then $ACTION = 'store'
00364  |    	Local Static $isMethode = Null
00365  |    
00366  |    	;----------------------------------------------------------------------------------------------/
00367  |    	; Setze Methode
00368  |    	;----------------------------------------------------------------------------------------------/
00369  |    	if $isMethode = Null then $isMethode = $METHODE
00370  |    
00371  |    	;----------------------------------------------------------------------------------------------/
00372  |    	; AKTION
00373  |    	;----------------------------------------------------------------------------------------------/
00374  |  +-	Switch $ACTION
00375  |  |    
00376  |  |    		;----------------------------------------------------------------------------------------------/
00377  |  |    		; Speichere die Select spalten in eine Queue
00378  |  |    		;----------------------------------------------------------------------------------------------/
00379  |  |  +-		Case 'store'
00380  |  |  |  +-			Switch $METHODE
00381  |  |  |  |    
00382  |  |  |  |    				;----------------------------------------------------------------------------------------------/
00383  |  |  |  |    				; Methode SELECT
00384  |  |  |  |    				;----------------------------------------------------------------------------------------------/
00385  |  |  |  |  +-				Case 'SELECT'
00386  |  |  |  |  |  +-					if $isMethode <> $METHODE then
00387  |  |  |  |  |  |    						__4ern_SQL_Console('error', 'SELECT -- QUERY BUILDER', 'Es wurde bereits die Methode DISTINCT aufgerufen.')
00388  |  |  |  |  |  |    						return SetError(1, 0, 0)
00389  |  |  |  |  |  +-					endif
00390  |  |  |  |  |    
00391  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00392  |  |  |  |  |    					; Array Verarbeitung
00393  |  |  |  |  |    					; 	-> Ansonsten String
00394  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00395  |  |  |  |  |  +-					IF IsArray($COLM) then
00396  |  |  |  |  |  |  +-						for $element in $COLM
00397  |  |  |  |  |  |  |    							if isstring($element) then $QUEUE.Enqueue($element)
00398  |  |  |  |  |  |  +-						next
00399  |  |  |  |  |  +-					ELSE
00400  |  |  |  |  |  |    						if IsString($COLM) then $QUEUE.Enqueue($COLM)
00401  |  |  |  |  |  +-					endif
00402  |  |  |  |  |    
00403  |  |  |  |  |    				;----------------------------------------------------------------------------------------------/
00404  |  |  |  |  |    				; Methode DISTINCT
00405  |  |  |  |  |    				;----------------------------------------------------------------------------------------------/
00406  |  |  |  |  +-				Case 'DISTINCT'
00407  |  |  |  |  |  +-					if $isMethode <> $METHODE then
00408  |  |  |  |  |  |    						__4ern_SQL_Console('error', 'DISTINCT -- QUERY BUILDER', 'Es wurde bereits die Methode SELECT aufgerufen.')
00409  |  |  |  |  |  |    						return SetError(1, 0, 0)
00410  |  |  |  |  |  +-					endif
00411  |  |  |  |  |    
00412  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00413  |  |  |  |  |    					; Array Verarbeitung
00414  |  |  |  |  |    					; 	-> Ansonsten String
00415  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00416  |  |  |  |  |  +-					IF IsArray($COLM) then
00417  |  |  |  |  |  |  +-						for $element in $COlM
00418  |  |  |  |  |  |  |    							if isstring($element) then $QUEUE.Enqueue($element)
00419  |  |  |  |  |  |  +-						next
00420  |  |  |  |  |  +-					ELSE
00421  |  |  |  |  |  |    						if IsString($COlM) then $QUEUE.Enqueue($COlM)
00422  |  |  |  |  |  +-					endif
00423  |  |  |  +-			EndSwitch
00424  |  |  |    
00425  |  |  |    		;----------------------------------------------------------------------------------------------/
00426  |  |  |    		; Ermittle alle Elemete aus der Queue, und erstelle an Select String
00427  |  |  |    		;----------------------------------------------------------------------------------------------/
00428  |  |  +-		Case 'get'
00429  |  |  |    
00430  |  |  |    			;----------------------------------------------------------------------------------------------/
00431  |  |  |    			; Bei SQL-Server nehmen Take anstatt von LIMIT
00432  |  |  |    			;----------------------------------------------------------------------------------------------/
00433  |  |  |  +-			if __4ern_SQL_Connection = 'sqlServer' then
00434  |  |  |  |    				Local $take = __4ern_SQL__QueryBuilder__limit(-1,'get')
00435  |  |  |  |    				Local $String = StringFormat('%s %s ', $isMethode,  $take)
00436  |  |  |  +-			else
00437  |  |  |  |    				Local $String = $isMethode & ' '
00438  |  |  |  +-			endif
00439  |  |  |    
00440  |  |  |    			;----------------------------------------------------------------------------------------------/
00441  |  |  |    			; Wenn keine Einträge vorhanden, dann *
00442  |  |  |    			;----------------------------------------------------------------------------------------------/
00443  |  |  |    			If $QUEUE.Count = 0 then Return $String & '* '
00444  |  |  |    
00445  |  |  |    			;----------------------------------------------------------------------------------------------/
00446  |  |  |    			; Erstelle String
00447  |  |  |    			;----------------------------------------------------------------------------------------------/
00448  |  |  |  +-			for $elemet in $QUEUE
00449  |  |  |  |    				$String &= $elemet & ', '
00450  |  |  |  +-			next
00451  |  |  |    
00452  |  |  |    			;----------------------------------------------------------------------------------------------/
00453  |  |  |    			; Lösche alle Einträge aus der Queue
00454  |  |  |    			;----------------------------------------------------------------------------------------------/
00455  |  |  |  +-			while $QUEUE.Count <> 0
00456  |  |  |  |    				$QUEUE.clear
00457  |  |  |  +-			wend
00458  |  |  |    			$isMethode = Null
00459  |  |  |    
00460  |  |  |    			;----------------------------------------------------------------------------------------------/
00461  |  |  |    			; Return
00462  |  |  |    			;----------------------------------------------------------------------------------------------/
00463  |  |  |    			return StringReplace($String, ',', '', -1)
00464  |  +-	EndSwitch
00465  +-endfunc
00466  +-func __4ern_SQL_Query_select($COLM,$C1=DEFAULT,$C2=DEFAULT,$C3=DEFAULT,$C4=DEFAULT,$C5=DEFAULT,$C6=DEFAULT,$C7=DEFAULT,$C8=DEFAULT,$C9=DEFAULT)
00467  |    
00468  |    	;----------------------------------------------------------------------------------------------/
00469  |    	; Prüfen ob $COLM ein 2D Array ist..
00470  |    	;----------------------------------------------------------------------------------------------/
00471  |  +-	if IsArray($COLM) then
00472  |  |  +-		if UBound($COLM, 2) <> 0 then
00473  |  |  |    			__4ern_SQL_Console('error', 'SELECT -- QUERY BUILDER', 'Es sind nur 1D Arrays erlaubt')
00474  |  |  |    			return SetError(1, 0, 0)
00475  |  |  +-		endif
00476  |  +-	endif
00477  |    
00478  |    	;----------------------------------------------------------------------------------------------/
00479  |    	; Übergabe der Parameter an QueryBuilder
00480  |    	;----------------------------------------------------------------------------------------------/
00481  |    	__4ern_SQL__QueryBuilder__SELECT(-1,$COLM)
00482  |    	Local $aC = [$C1, $C2, $C3, $C4, $C5, $C6, $C7, $C8, $C9]
00483  |  +-	For $Key In $aC
00484  |  |    		If $Key <> DEFAULT then __4ern_SQL__QueryBuilder__SELECT(-1,$Key)
00485  |  +-	Next
00486  |    
00487  |    	return 1
00488  +-endfunc
00489  +-func __4ern_SQL_Query_distinct($COLM,$C1=DEFAULT,$C2=DEFAULT,$C3=DEFAULT,$C4=DEFAULT,$C5=DEFAULT,$C6=DEFAULT,$C7=DEFAULT,$C8=DEFAULT,$C9=DEFAULT)
00490  |    
00491  |    	;----------------------------------------------------------------------------------------------/
00492  |    	; Prüfen ob $COLM ein 2D Array ist..
00493  |    	;----------------------------------------------------------------------------------------------/
00494  |  +-	if IsArray($COLM) then
00495  |  |  +-		if UBound($COLM, 2) <> 0 then
00496  |  |  |    			__4ern_SQL_Console('error', 'DISTINCT -- QUERY BUILDER', 'Es sind nur 1D Arrays erlaubt')
00497  |  |  |    			return SetError(1, 0, 0)
00498  |  |  +-		endif
00499  |  +-	endif
00500  |    
00501  |    	;----------------------------------------------------------------------------------------------/
00502  |    	; Übergabe der Parameter an QueryBuilder
00503  |    	;----------------------------------------------------------------------------------------------/
00504  |    		__4ern_SQL__QueryBuilder__SELECT(-1,$COLM, 'DISTINCT')
00505  |    	Local $aC = [$C1, $C2, $C3, $C4, $C5, $C6, $C7, $C8, $C9]
00506  |  +-	For $Key In $aC
00507  |  |    		If $Key <> DEFAULT then __4ern_SQL__QueryBuilder__SELECT(-1,$Key)
00508  |  +-	Next
00509  |    
00510  |    	return 1
00511  +-endfunc
00512    
00513    ; #FUNCTION# ====================================================================================================================
00514    ; Author ........: 4ern.de
00515    ; Description....: WHERE Clause
00516    ; Source.........: http://www.w3schools.com/sql/sql_where.asp
00517    ; ===============================================================================================================================
00518  +-func __4ern_SQL__QueryBuilder__where($ACTION = DEFAULT, $aVALUE = DEFAULT, $METHODE = DEFAULT, $SQL_OPERATOR = DEFAULT, $SET_QUE = DEFAULT)
00519  |    
00520  |    	;----------------------------------------------------------------------------------------------/
00521  |    	; Eigenschaften
00522  |    	;----------------------------------------------------------------------------------------------/
00523  |    	Local Static $WHERE_QUEUE    = ObjCreate("System.Collections.Queue")
00524  |    	Local Static $HAVING_QUEUE   = ObjCreate("System.Collections.Queue")
00525  |    	Local Static $bWhereBetween  = Null
00526  |    	Local Static $bHavingBetween = Null
00527  |    	Local Static $bWhereIn       = Null
00528  |    	Local Static $bHavingIn      = Null
00529  |    
00530  |    	;----------------------------------------------------------------------------------------------/
00531  |    	; DEFAUL Eingenschaften
00532  |    	;----------------------------------------------------------------------------------------------/
00533  |    	if __4ern_SQL__IsDefault($ACTION, '-1,', ',') Then $ACTION             = 'store'
00534  |    	if __4ern_SQL__IsDefault($SET_QUE, '-1,', ',') Then $SET_QUE           = 'WHERE'
00535  |    	if __4ern_SQL__IsDefault($SQL_OPERATOR, '-1,', ',') Then $SQL_OPERATOR = 'AND'
00536  |    	if __4ern_SQL__IsDefault($METHODE, '-1,', ',') Then $METHODE           = 'AND'
00537  |    
00538  |    	;----------------------------------------------------------------------------------------------/
00539  |    	; QUE
00540  |    	;----------------------------------------------------------------------------------------------/
00541  |  +-	if $SET_QUE = 'WHERE' then
00542  |  |    		$QUEUE    = $WHERE_QUEUE
00543  |  |    		$bBetween = $bWhereBetween
00544  |  |    		$bIn      = $bWhereIn
00545  |  +-	endif
00546  |    
00547  |  +-	if $SET_QUE = 'HAVING' then
00548  |  |    		$QUEUE    = $HAVING_QUEUE
00549  |  |    		$bBetween = $bHavingBetween
00550  |  |    		$bIn      = $bHavingIn
00551  |  +-	endif
00552  |    
00553  |    	;----------------------------------------------------------------------------------------------/
00554  |    	; METHODEN
00555  |    	;----------------------------------------------------------------------------------------------/
00556  |  +-	Switch $ACTION
00557  |  |  +-		Case 'store'
00558  |  |  |    
00559  |  |  |    			;----------------------------------------------------------------------------------------------/
00560  |  |  |    			; SQL Operator
00561  |  |  |    			;----------------------------------------------------------------------------------------------/
00562  |  |  |  +-			Switch $METHODE
00563  |  |  |  |    
00564  |  |  |  |  +-				Case 'AND', 'OR'
00565  |  |  |  |  |  +-					IF IsArray($aVALUE) then
00566  |  |  |  |  |  |  +-						for $element in $aVALUE
00567  |  |  |  |  |  |  |    							if isString($element) then $QUEUE.Enqueue(stringformat('%s (%s)', $METHODE, $element))
00568  |  |  |  |  |  |  +-						next
00569  |  |  |  |  |  +-					ELSE
00570  |  |  |  |  |  |    						if IsString($aVALUE) then $QUEUE.Enqueue(stringformat('%s (%s)', $METHODE, $aVALUE))
00571  |  |  |  |  |  +-					endif
00572  |  |  |  |  |    
00573  |  |  |  |  +-				Case 'BETWEEN', 'NOT BETWEEN'
00574  |  |  |  |  |  +-					if $bBetween = Null then
00575  |  |  |  |  |  |    						if IsString($aVALUE) then $QUEUE.Enqueue(stringformat('%s (%s)', $SQL_OPERATOR, $aVALUE))
00576  |  |  |  |  |  |    						$bBetween = 1
00577  |  |  |  |  |  +-					else
00578  |  |  |  |  |  |    						__4ern_SQL_Console('error', 'BETWEEN -- QUERY BUILDER', 'Der Parameter BETWEEN kann nur einmal pro Query erfolgen')
00579  |  |  |  |  |  +-					endif
00580  |  |  |  |  |    
00581  |  |  |  |  +-				Case 'IN', 'NOT IN'
00582  |  |  |  |  |  +-					if $bIn = Null then
00583  |  |  |  |  |  |    						if IsString($aVALUE) then $QUEUE.Enqueue(stringformat('%s (%s)', $SQL_OPERATOR, $aVALUE))
00584  |  |  |  |  |  |    						$bIn = 1
00585  |  |  |  |  |  +-					else
00586  |  |  |  |  |  |    						__4ern_SQL_Console('error', 'BETWEEN -- QUERY BUILDER', 'Der Parameter BETWEEN kann nur einmal pro Query erfolgen')
00587  |  |  |  |  |  +-					endif
00588  |  |  |  |  |    
00589  |  |  |  |  +-				Case 'IS NULL', 'IS NOT NULL'
00590  |  |  |  |  |  +-					IF IsArray($aVALUE) then
00591  |  |  |  |  |  |  +-						for $element in $aVALUE
00592  |  |  |  |  |  |  |    							if isString($element) then $QUEUE.Enqueue(stringformat('%s (%s)', $SQL_OPERATOR, $element))
00593  |  |  |  |  |  |  +-						next
00594  |  |  |  |  |  +-					ELSE
00595  |  |  |  |  |  |    						if IsString($aVALUE) then $QUEUE.Enqueue(stringformat('%s (%s)', $SQL_OPERATOR, $aVALUE))
00596  |  |  |  |  |  +-					endif
00597  |  |  |  +-			EndSwitch
00598  |  |  |    
00599  |  |  |    		;----------------------------------------------------------------------------------------------/
00600  |  |  |    		; Ermittle alle Elemete aus der Queue, und erstelle an Select String
00601  |  |  |    		;----------------------------------------------------------------------------------------------/
00602  |  |  +-		Case 'getWhere'
00603  |  |  |    
00604  |  |  |    			;**********************************************************************************************/
00605  |  |  |    			; Ablauf
00606  |  |  |    			;	- Erstelle String 'WHERE '
00607  |  |  |    			;	- Anzahl der Que = 0 dan return String 'Where 1'
00608  |  |  |    			;	- Erstelle String mit aus der Que heraus
00609  |  |  |    			;	- Bereinige Static Variablen und leere die QUE
00610  |  |  |    			;	- Bereinigung und Return des Strings
00611  |  |  |    			;**********************************************************************************************/
00612  |  |  |    
00613  |  |  |    			$String = 'WHERE '
00614  |  |  |    			If $WHERE_QUEUE.Count = 0 then Return ''
00615  |  |  |  +-			for $elemet in $WHERE_QUEUE
00616  |  |  |  |    				$String &= $elemet & ' '
00617  |  |  |  +-			next
00618  |  |  |    			$WHERE_QUEUE.clear
00619  |  |  |    			$bHavingBetween = Null
00620  |  |  |    			$bHavingIn      = Null
00621  |  |  |    			return StringStripWS(StringReplace(StringReplace($String, 'WHERE AND', 'WHERE', 1), 'WHERE OR', 'WHERE', 1), 4)
00622  |  |  |    
00623  |  |  |    		;----------------------------------------------------------------------------------------------/
00624  |  |  |    		; Ermittle alle Elemete aus der Queue, und erstelle an Select String
00625  |  |  |    		;----------------------------------------------------------------------------------------------/
00626  |  |  +-		Case 'getHaving'
00627  |  |  |    
00628  |  |  |    			;**********************************************************************************************/
00629  |  |  |    			; Ablauf
00630  |  |  |    			;	- Erstelle String 'HAVING '
00631  |  |  |    			;	- Anzahl der Que = 0 dan return String leer String
00632  |  |  |    			;	- Erstelle String mit aus der Que heraus
00633  |  |  |    			;	- Bereinige Static Variablen und leere die QUE
00634  |  |  |    			;	- Bereinigung und Return des Strings
00635  |  |  |    			;**********************************************************************************************/
00636  |  |  |    
00637  |  |  |    			$String = 'HAVING '
00638  |  |  |    			If $HAVING_QUEUE.Count = 0 then Return ''
00639  |  |  |  +-			for $elemet in $HAVING_QUEUE
00640  |  |  |  |    				$String &= $elemet & ' '
00641  |  |  |  +-			next
00642  |  |  |    			$HAVING_QUEUE.clear
00643  |  |  |    			$bHavingBetween = Null
00644  |  |  |    			$bHavingIn      = Null
00645  |  |  |    			return StringStripWS(StringReplace(StringReplace($String, 'HAVING AND', 'WHERE', 1), 'HAVING OR', 'HAVING', 1), 4)
00646  |  |  |    
00647  |  +-	EndSwitch
00648  +-endfunc
00649  +-func __4ern_SQL_Query_where($COLM,$V1 = DEFAULT, $V2 = DEFAULT, $METHODE = 'AND', $SET_QUE = DEFAULT)
00650  |    	Local $FO
00651  |    	;----------------------------------------------------------------------------------------------/
00652  |    	; Prüfen ob COLM ein 2D Array ist.
00653  |    	;----------------------------------------------------------------------------------------------/
00654  |  +-	if IsArray($COLM) Then
00655  |  |    		$iColm = UBound($COLM, 2)
00656  |  |  +-		Select
00657  |  |  |    
00658  |  |  |    			;----------------------------------------------------------------------------------------------/
00659  |  |  |    			; 1D Array
00660  |  |  |    			;----------------------------------------------------------------------------------------------/
00661  |  |  |  +-			Case $iColm = 0
00662  |  |  |  |    				__4ern_SQL_Console('error', 'WHERE - HAVING -- QUERY BUILDER', '2D Array erforderlich')
00663  |  |  |  |    				return SetError(1, 0, 0)
00664  |  |  |  |    
00665  |  |  |  |    			;----------------------------------------------------------------------------------------------/
00666  |  |  |  |    			; 2D Array with 2 Colms
00667  |  |  |  |    			; Without Operators
00668  |  |  |  |    			;----------------------------------------------------------------------------------------------/
00669  |  |  |  +-			Case $iColm = 2
00670  |  |  |  |  +-				for $i = 0 to Ubound($COLM) -1
00671  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00672  |  |  |  |  |    					; Unterscheidung zwischen INT & String
00673  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00674  |  |  |  |  |    					$FO = (IsString($COLM[$i][1])) ? '%s = "%s"' : '%s = %s'
00675  |  |  |  |  |    					$string = StringFormat($FO, $COLM[$i][0], $COLM[$i][1])
00676  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00677  |  |  |  |  |    					; Store Where String
00678  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00679  |  |  |  |  |    					__4ern_SQL__QueryBuilder__WHERE(-1,$string, $METHODE, DEFAULT, $SET_QUE)
00680  |  |  |  |  +-				next
00681  |  |  |  |    
00682  |  |  |  |    			;----------------------------------------------------------------------------------------------/
00683  |  |  |  |    			; 2D Array with 3 Colms
00684  |  |  |  |    			; With Operators
00685  |  |  |  |    			;----------------------------------------------------------------------------------------------/
00686  |  |  |  +-			Case $iColm = 3
00687  |  |  |  |  +-				for $i = 0 to Ubound($COLM) -1
00688  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00689  |  |  |  |  |    					; Prüfung auf Parameter Gültigkeit
00690  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00691  |  |  |  |  |  +-					if (StringRegExp($COLM[$i][1], '(<>|!=|>=|<=)')) = 0 and _
00692  |  |  |  |  |  |       						(StringRegExp(StringMid($COLM[$i][1], 1, 1), '(=|<|>)')) = 0 Then
00693  |  |  |  |  ^--|----						ContinueLoop
00694  |  |  |  |  |  +-					endif
00695  |  |  |  |  |    
00696  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00697  |  |  |  |  |    					; Unterscheidung zwischen INT & String
00698  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00699  |  |  |  |  |    					$FO = (IsString($COLM[$i][2])) ? '%s %s "%s"' : '%s %s %s'
00700  |  |  |  |  |    					$string = StringFormat($FO, $COLM[$i][0], $COLM[$i][1], $COLM[$i][2])
00701  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00702  |  |  |  |  |    					; Store Where String
00703  |  |  |  |  |    					;----------------------------------------------------------------------------------------------/
00704  |  |  |  |  |    					__4ern_SQL__QueryBuilder__WHERE(-1,$string, $METHODE, DEFAULT, $SET_QUE)
00705  |  |  |  |  +-				next
00706  |  |  |  |    
00707  |  |  |  |    			;----------------------------------------------------------------------------------------------/
00708  |  |  |  |    			; 2D Array undefinierte Spalten
00709  |  |  |  |    			;----------------------------------------------------------------------------------------------/
00710  |  |  |  +-			Case Else
00711  |  |  |  |    				__4ern_SQL_Console('error', 'WHERE - HAVING -- QUERY BUILDER', '2D Array hat mehr als 3 Spalten')
00712  |  |  |  |    				return SetError(1, 0, 0)
00713  |  |  +-		Endselect
00714  |  +-	endif
00715  |    
00716  |    	;----------------------------------------------------------------------------------------------/
00717  |    	; Param Übergabe
00718  |    	;----------------------------------------------------------------------------------------------/
00719  |    	;----------------------------------------------------------------------------------------------/
00720  |    	; Prüfen ob ein Vergleichswert übergeben wurde.
00721  |    	;----------------------------------------------------------------------------------------------/
00722  |  +-	If $V1 = DEFAULT then
00723  |  |    		__4ern_SQL_Console('error', 'WHERE - HAVING -- QUERY BUILDER', 'Es wurde kein Vergleichswert angegeben')
00724  |  |    		return SetError(1, 0, 0)
00725  |  +-	endif
00726  |    
00727  |    	;----------------------------------------------------------------------------------------------/
00728  |    	; Prüfe ob V1 ein Operator ist
00729  |    	;----------------------------------------------------------------------------------------------/
00730  |  +-	if (StringRegExp($V1, '(<>|!=|>=|<=)')) = 1 or _
00731  |  |       		(StringRegExp(StringMid($V1, 1, 1), '(=|<|>)')) = 1 Then
00732  |  |    
00733  |  |    		;----------------------------------------------------------------------------------------------/
00734  |  |    		; Prüfe ob ein Vergleichswert angegeben wurde
00735  |  |    		;----------------------------------------------------------------------------------------------/
00736  |  |  +-		If $V2 = DEFAULT then
00737  |  |  |    			__4ern_SQL_Console('error', 'WHERE - HAVING -- QUERY BUILDER', 'Es wurde kein Vergleichswert angegeben')
00738  |  |  |    			return SetError(1, 0, 0)
00739  |  |  +-		endif
00740  |  |    
00741  |  |    		;----------------------------------------------------------------------------------------------/
00742  |  |    		; Unterscheidung zwischen INT & String
00743  |  |    		;----------------------------------------------------------------------------------------------/
00744  |  |    		$FO = (IsString($V2)) ? '%s %s "%s"' : '%s %s %s'
00745  |  |    		$string = StringFormat($FO, $COLM, $V1, $V2)
00746  |  |    		;----------------------------------------------------------------------------------------------/
00747  |  |    		; Store Where String
00748  |  |    		;----------------------------------------------------------------------------------------------/
00749  |  |    		__4ern_SQL__QueryBuilder__WHERE(-1,$string, $METHODE, DEFAULT, $SET_QUE)
00750  |  |    		return 1
00751  |  +-	else
00752  |  |    		;----------------------------------------------------------------------------------------------/
00753  |  |    		; Unterscheidung zwischen INT & String
00754  |  |    		;----------------------------------------------------------------------------------------------/
00755  |  |    		$FO = (IsString($V1)) ? '%s = "%s"' : '%s = %s'
00756  |  |    		$string = StringFormat($FO, $COLM, $V1)
00757  |  |    		;----------------------------------------------------------------------------------------------/
00758  |  |    		; Store Where String
00759  |  |    		;----------------------------------------------------------------------------------------------/
00760  |  |    		__4ern_SQL__QueryBuilder__WHERE(-1,$string, $METHODE, DEFAULT, $SET_QUE)
00761  |  |    		return 1
00762  |  +-	endif
00763  +-endfunc
00764  +-func __4ern_SQL_Query_orWhere($COLM, $V1 = DEFAULT, $V2 = DEFAULT)
00765  |    	$ret = __4ern_SQL_Query_where($COLM, $V1, $V2, 'OR')
00766  |    	Return SetError(@error, 0, $ret)
00767  +-endfunc
00768  +-func __4ern_SQL_Query_whereBetween($COLM, $V1 = DEFAULT, $V2 = DEFAULT, $METHODE = 'BETWEEN', $SET_QUE = DEFAULT)
00769  |    
00770  |  +-	Select
00771  |  |  +-		Case IsString($V1)
00772  |  |  |  +-			if IsString($V2) = 0 then
00773  |  |  |  |    				__4ern_SQL_Console('error', 'WHERE '&$METHODE&' -- QUERY BUILDER', 'Beide Paremter muessen den selben Typ besitzen')
00774  |  |  |  |    				return SetError(1, 0, 0)
00775  |  |  |  +-			endif
00776  |  |  |    			__4ern_SQL__QueryBuilder__WHERE(-1, StringFormat('%s %s "%s" AND "%s"',$COLM, $METHODE, $V1, $V2), $METHODE, DEFAULT, $SET_QUE)
00777  |  |  |    
00778  |  |  +-		Case IsInt($V1)
00779  |  |  |  +-			If IsInt($V2) = 0 then
00780  |  |  |  |    				__4ern_SQL_Console('error', 'WHERE '&$METHODE&' -- QUERY BUILDER', 'Beide Paremter muessen den selben Typ besitzen')
00781  |  |  |  |    				return SetError(1, 0, 0)
00782  |  |  |  +-			endif
00783  |  |  |    			__4ern_SQL__QueryBuilder__WHERE(-1, StringFormat('%s %s %s AND %s',$COLM, $METHODE, $V1, $V2), $METHODE, DEFAULT, $SET_QUE)
00784  |  +-	EndSelect
00785  +-endfunc
00786  +-func __4ern_SQL_Query_whereNotBetween($COLM, $V1 = DEFAULT, $V2 = DEFAULT)
00787  |    	$ret = __4ern_SQL_Query_whereBetween($COLM, $V1, $V2, 'NOT BETWEEN')
00788  |    	return SetError(@error, 0, $ret)
00789  +-endfunc
00790  +-func __4ern_SQL_Query_whereIn($COLM, $V1 = DEFAULT, $V2 = DEFAULT, $METHODE = 'IN', $SET_QUE = DEFAULT)
00791  |    
00792  |  +-	Select
00793  |  |  +-		case IsArray($V1)
00794  |  |  |  +-			if UBound($V1, 2) = 0 then
00795  |  |  |  |  +-				for $element in $V1
00796  |  |  |  |  |    					$FO = (IsString($element)) ? '%s %s "%s"' : '%s %s %s'
00797  |  |  |  |  |    					$string = StringFormat($FO, $COLM, $METHODE, $element)
00798  |  |  |  |  +-				next
00799  |  |  |  |    				__4ern_SQL__QueryBuilder__WHERE(-1, $string, $METHODE, DEFAULT, $SET_QUE)
00800  |  |  |  |    				return 1
00801  |  |  |  +-			endif
00802  |  |  |    
00803  |  |  +-		Case IsString($V1)
00804  |  |  |  +-			if IsString($V2) = 0 then
00805  |  |  |  |    				__4ern_SQL_Console('error', 'WHERE '&$METHODE&' -- QUERY BUILDER', 'Beide Paremter muessen den selben Typ besitzen')
00806  |  |  |  |    				return SetError(1, 0, 0)
00807  |  |  |  +-			endif
00808  |  |  |    			__4ern_SQL__QueryBuilder__WHERE(-1, StringFormat('%s %s "%s" AND "%s"',$COLM, $METHODE, $V1, $V2), $METHODE)
00809  |  |  |    
00810  |  |  +-		Case IsInt($V1)
00811  |  |  |  +-			If IsInt($V2) = 0 then
00812  |  |  |  |    				__4ern_SQL_Console('error', 'WHERE '&$METHODE&' -- QUERY BUILDER', 'Beide Paremter muessen den selben Typ besitzen')
00813  |  |  |  |    				return SetError(1, 0, 0)
00814  |  |  |  +-			endif
00815  |  |  |    			__4ern_SQL__QueryBuilder__WHERE(-1, StringFormat('%s %s %s AND %s',$COLM, $METHODE, $V1, $V2), $METHODE, DEFAULT, $SET_QUE)
00816  |  +-	EndSelect
00817  +-endfunc
00818  +-func __4ern_SQL_Query_whereNotIn($COLM, $V1 = DEFAULT, $V2 = DEFAULT)
00819  |    	$ret = __4ern_SQL_Query_whereIn($COLM, $V1, $V2, 'NOT IN')
00820  |    	return SetError(@error, 0, $ret)
00821  +-endfunc
00822  +-func __4ern_SQL_Query_whereNull($COLM, $METHODE = 'IS NULL', $SET_QUE = DEFAULT)
00823  |    	$ret = __4ern_SQL__QueryBuilder__WHERE(-1, StringFormat('%s %s', $COLM, $METHODE), $METHODE, DEFAULT, $SET_QUE)
00824  |    	return SetError(@error, 0, $ret)
00825  +-endfunc
00826  +-func __4ern_SQL_Query_whereNotNull($COLM)
00827  |    	$ret = __4ern_SQL_Query_whereNull($COLM, 'IS NOT NULL')
00828  |    	return SetError(@error, 0, $ret)
00829  +-endfunc
00830    
00831    ; #FUNCTION# ====================================================================================================================
00832    ; Author ........: 4ern.de
00833    ; Description....: SQL HAVING Clause
00834    ; Source.........: http://www.w3schools.com/sql/sql_having.asp
00835    ; ===============================================================================================================================
00836  +-func __4ern_SQL_Query_having($COLM,$V1 = DEFAULT, $V2 = DEFAULT)
00837  |    	$ret = __4ern_SQL_Query_where($COLM,$V1, $V2, 'AND', 'HAVING')
00838  |    	return SetError(@error, 0, $ret)
00839  +-endfunc
00840  +-func __4ern_SQL_Query_orHaving($COLM,$V1 = DEFAULT, $V2 = DEFAULT)
00841  |    	$ret = __4ern_SQL_Query_where($COLM,$V1, $V2, 'OR', 'HAVING')
00842  |    	return SetError(@error, 0, $ret)
00843  +-endfunc
00844  +-func __4ern_SQL_Query_havingBetween($COLM, $V1 = DEFAULT, $V2 = DEFAULT)
00845  |    	$ret = __4ern_SQL_Query_whereBetween($COLM,$V1, $V2, 'BETWEEN', 'HAVING')
00846  |    	return SetError(@error, 0, $ret)
00847  +-endfunc
00848  +-func __4ern_SQL_Query_havingNotBetween($COLM, $V1 = DEFAULT, $V2 = DEFAULT)
00849  |    	$ret = __4ern_SQL_Query_whereBetween($COLM,$V1, $V2, 'NOT BETWEEN', 'HAVING')
00850  |    	return SetError(@error, 0, $ret)
00851  +-endfunc
00852  +-func __4ern_SQL_Query_havingIn($COLM, $V1 = DEFAULT, $V2 = DEFAULT)
00853  |    	$ret = __4ern_SQL_Query_whereIn($COLM,$V1, $V2, 'IN', 'HAVING')
00854  |    	return SetError(@error, 0, $ret)
00855  +-endfunc
00856  +-func __4ern_SQL_Query_havingNotIn($COLM, $V1 = DEFAULT, $V2 = DEFAULT)
00857  |    	$ret = __4ern_SQL_Query_whereIn($COLM,$V1, $V2, 'NOT IN', 'HAVING')
00858  |    	return SetError(@error, 0, $ret)
00859  +-endfunc
00860  +-func __4ern_SQL_Query_havingNull($COLM)
00861  |    	$ret = __4ern_SQL_Query_whereNull($COLM, 'IS NULL', 'HAVING')
00862  |    	return SetError(@error, 0, $ret)
00863  +-endfunc
00864  +-func __4ern_SQL_Query_havingNotNull($COLM)
00865  |    	$ret = __4ern_SQL_Query_whereNull($COLM, 'IS NOT NULL', 'HAVING')
00866  |    	return SetError(@error, 0, $ret)
00867  +-endfunc
00868    
00869    ; #FUNCTION# ====================================================================================================================
00870    ; Author ........: 4ern.de
00871    ; Description....: SQL GROUP BY Statement
00872    ; Source.........: http://www.w3schools.com/sql/sql_groupby.asp
00873    ; ===============================================================================================================================
00874  +-func __4ern_SQL__QueryBuilder__groupBy($ACTION = DEFAULT, $COLM = DEFAULT)
00875  |    	;----------------------------------------------------------------------------------------------/
00876  |    	; Eigenschaften
00877  |    	;----------------------------------------------------------------------------------------------/
00878  |    	Local Static $QUEUE = ObjCreate("System.Collections.Queue")
00879  |    	if __4ern_SQL__IsDefault($ACTION, '-1,', ',') Then $ACTION = 'store'
00880  |    
00881  |    	;----------------------------------------------------------------------------------------------/
00882  |    	; AKTION
00883  |    	;----------------------------------------------------------------------------------------------/
00884  |  +-	Switch $ACTION
00885  |  |    
00886  |  |    		;----------------------------------------------------------------------------------------------/
00887  |  |    		; Speichere die Select spalten in eine Queue
00888  |  |    		;----------------------------------------------------------------------------------------------/
00889  |  |  +-		Case 'store'
00890  |  |  |    			if IsString($COLM) then $QUEUE.Enqueue(stringformat('AND %s ', $COLM))
00891  |  |  |    			return 1
00892  |  |  |    
00893  |  |  |    		;----------------------------------------------------------------------------------------------/
00894  |  |  |    		; Ermittle alle Elemete aus der Queue, und erstelle an Select String
00895  |  |  |    		;----------------------------------------------------------------------------------------------/
00896  |  |  +-		Case 'get'
00897  |  |  |    
00898  |  |  |    			Local $SQL = 'GROUP BY '
00899  |  |  |    
00900  |  |  |    			;----------------------------------------------------------------------------------------------/
00901  |  |  |    			; Wenn keine Einträge vorhanden, dann *
00902  |  |  |    			;----------------------------------------------------------------------------------------------/
00903  |  |  |    			If $QUEUE.Count = 0 then Return ''
00904  |  |  |    
00905  |  |  |    			;----------------------------------------------------------------------------------------------/
00906  |  |  |    			; Erstelle String
00907  |  |  |    			;----------------------------------------------------------------------------------------------/
00908  |  |  |  +-			for $elemet in $QUEUE
00909  |  |  |  |    				$SQL &= $elemet
00910  |  |  |  +-			next
00911  |  |  |    
00912  |  |  |    			;----------------------------------------------------------------------------------------------/
00913  |  |  |    			; Lösche alle Einträge aus der Queue
00914  |  |  |    			;----------------------------------------------------------------------------------------------/
00915  |  |  |    			$QUEUE.clear
00916  |  |  |    
00917  |  |  |    			;----------------------------------------------------------------------------------------------/
00918  |  |  |    			; Return
00919  |  |  |    			;----------------------------------------------------------------------------------------------/
00920  |  |  |    			return StringStripWS(StringReplace($SQL, 'BY AND', 'BY', 1), 4)
00921  |  +-	EndSwitch
00922  +-endfunc
00923  +-func __4ern_SQL_Query_groupBy($COLM)
00924  |    	$ret = __4ern_SQL__QueryBuilder__groupBy(-1, $COLM)
00925  |    	return SetError(@error, 0, $ret)
00926  +-endfunc
00927    
00928    ; #FUNCTION# ====================================================================================================================
00929    ; Author ........: 4ern.de
00930    ; Description....: SQL ORDER BY Keyword
00931    ; Source.........: http://www.w3schools.com/sql/sql_orderby.asp
00932    ; ===============================================================================================================================
00933  +-func __4ern_SQL__QueryBuilder__Orderby($ACTION = DEFAULT, $COLM = DEFAULT)
00934  |    	;----------------------------------------------------------------------------------------------/
00935  |    	; Eigenschaften
00936  |    	;----------------------------------------------------------------------------------------------/
00937  |    	Local Static $QUEUE = ObjCreate("System.Collections.Queue")
00938  |    	if __4ern_SQL__IsDefault($ACTION, '-1,', ',') Then $ACTION = 'store'
00939  |    
00940  |    	;----------------------------------------------------------------------------------------------/
00941  |    	; AKTION
00942  |    	;----------------------------------------------------------------------------------------------/
00943  |  +-	Switch $ACTION
00944  |  |    
00945  |  |    		;----------------------------------------------------------------------------------------------/
00946  |  |    		; Speichere die Select spalten in eine Queue
00947  |  |    		;----------------------------------------------------------------------------------------------/
00948  |  |  +-		Case 'store'
00949  |  |  |    			;----------------------------------------------------------------------------------------------/
00950  |  |  |    			; Array Verarbeitung
00951  |  |  |    			; 	-> Ansonsten String
00952  |  |  |    			;----------------------------------------------------------------------------------------------/
00953  |  |  |    			if IsString($COLM) then $QUEUE.Enqueue($COLM)
00954  |  |  |    
00955  |  |  |    		;----------------------------------------------------------------------------------------------/
00956  |  |  |    		; Ermittle alle Elemete aus der Queue, und erstelle an Select String
00957  |  |  |    		;----------------------------------------------------------------------------------------------/
00958  |  |  +-		Case 'get'
00959  |  |  |    
00960  |  |  |    			$string = 'ORDER BY '
00961  |  |  |    			;----------------------------------------------------------------------------------------------/
00962  |  |  |    			; Wenn keine Einträge vorhanden, dann *
00963  |  |  |    			;----------------------------------------------------------------------------------------------/
00964  |  |  |    			If $QUEUE.Count = 0 then Return ''
00965  |  |  |    
00966  |  |  |    			;----------------------------------------------------------------------------------------------/
00967  |  |  |    			; Erstelle String
00968  |  |  |    			;----------------------------------------------------------------------------------------------/
00969  |  |  |  +-			for $elemet in $QUEUE
00970  |  |  |  |    				$string &= $elemet & ', '
00971  |  |  |  +-			next
00972  |  |  |    
00973  |  |  |    			;----------------------------------------------------------------------------------------------/
00974  |  |  |    			; Lösche alle Einträge aus der Queue
00975  |  |  |    			;----------------------------------------------------------------------------------------------/
00976  |  |  |    			$QUEUE.clear
00977  |  |  |    			;----------------------------------------------------------------------------------------------/
00978  |  |  |    			; Return
00979  |  |  |    			;----------------------------------------------------------------------------------------------/
00980  |  |  |    			return StringReplace($string, ',', '', -1)
00981  |  +-	EndSwitch
00982  +-endfunc
00983  +-func __4ern_SQL_Query_orderBy($COLM,$V1='asc')
00984  |    
00985  |    	;----------------------------------------------------------------------------------------------/
00986  |    	; Prüfe ob ein valider Sortier wert eingegeben wurde
00987  |    	;----------------------------------------------------------------------------------------------/
00988  |  +-	if StringRegExp($V1, '(asc|desc)') = 0 then
00989  |  |    		__4ern_SQL_Console('error', 'ORDER BY -- QUERY BUILDER', StringFormat('(%s) ist kein valider ORDER BY Keyword', $V1))
00990  |  |    		return SetError(1, 0, 0)
00991  |  +-	endif
00992  |    
00993  |    	;----------------------------------------------------------------------------------------------/
00994  |    	; Übergabe der Parameter an QueryBuilder
00995  |    	;----------------------------------------------------------------------------------------------/
00996  |    	$ret = __4ern_SQL__QueryBuilder__ORDERBY(-1,StringFormat('%s %s', $COLM, $V1))
00997  |    	return SetError(@error, 0, $ret)
00998  +-endfunc
00999    
01000    ; #FUNCTION# ====================================================================================================================
01001    ; Author ........: 4ern.de
01002    ; Description....: Table DEFAULT Settings
01003    ; ===============================================================================================================================
01004  +-func __4ern_SQL__QueryBuilder__setTable($P_TABLE = DEFAULT, $P_TKEY = DEFAULT, $ACTION = 'set')
01005  |    
01006  |    	Local Static $S_table
01007  |    	Local Static $S_tKey
01008  |    
01009  |  +-	Switch $ACTION
01010  |  |  +-		Case 'set'
01011  |  |  |    			If not __4ern_SQL__IsDefault($P_TABLE, '-1,', ',') Then $S_table = $P_TABLE
01012  |  |  |    			If not __4ern_SQL__IsDefault($P_TKEY, '-1,', ',') Then $S_tKey   = $P_TKEY
01013  |  |  |    
01014  |  |  |    		;----------------------------------------------------------------------------------------------/
01015  |  |  |    		; Tabelle übergeben.
01016  |  |  |    		;----------------------------------------------------------------------------------------------/
01017  |  |  +-		Case 'getTable'
01018  |  |  |  +-			If not __4ern_SQL__IsDefault($S_table, '-1,', ',') Then
01019  |  |  |  |    				$S_table = DEFAULT
01020  |  |  |  |    				return $S_table
01021  |  |  |  +-			endif
01022  |  |  |    			__4ern_SQL_Console('error', 'SQL Table', 'Es wurde keine Tabelle ausgewaehlt')
01023  |  |  |    			return SetError(1, 0, 0)
01024  |  |  |    
01025  |  |  |    		;----------------------------------------------------------------------------------------------/
01026  |  |  |    		; Schlüssel übergeben
01027  |  |  |    		;----------------------------------------------------------------------------------------------/
01028  |  |  +-		Case 'getTKey'
01029  |  |  |    			If not __4ern_SQL__IsDefault($S_tKey, '-1,', ',') Then return $S_tKey
01030  |  |  |    			__4ern_SQL_Console('warning', 'Es wurde kein Tabellen Schluessel ausgewaehlt.')
01031  |  |  |    			return $S_tKey
01032  |  |  |    
01033  |  +-	EndSwitch
01034  +-endfunc
01035  +-func __4ern_SQL__QueryBuilder__setkey($key)
01036  |    
01037  |    	__4ern_SQL__QueryBuilder__setTable(DEFAULT, $key)
01038  +-endfunc
01039    
01040    ; #FUNCTION# ====================================================================================================================
01041    ; Author ........: 4ern.de
01042    ; Description....: RAW SQL Statement
01043    ; ===============================================================================================================================
01044  +-func __4ern_SQL_rawQueryExpr($SQL)
01045  |    	__4ern_SQL_rawQuery($SQL,'get()')
01046  +-endfunc

======================
=== xref reports =====
======================

== User functions =================================================================================================
                          Func
Function name             Row     Referenced at Row(s)
========================= ====== ==================================================================================
__4ern_SQL_QueryBuilder_Delete  00131 
__4ern_SQL_QueryBuilder_Update  00056 
__4ern_SQL_QueryBuilder_get  00019 
__4ern_SQL_Query_distinct  00489 
__4ern_SQL_Query_groupBy  00923 
__4ern_SQL_Query_having   00836 
__4ern_SQL_Query_havingBetween  00844 
__4ern_SQL_Query_havingIn  00852 
__4ern_SQL_Query_havingNotBetween  00848 
__4ern_SQL_Query_havingNotIn  00856 
__4ern_SQL_Query_havingNotNull  00864 
__4ern_SQL_Query_havingNull  00860 
__4ern_SQL_Query_insert   00159 
__4ern_SQL_Query_orHaving  00840 
__4ern_SQL_Query_orWhere  00764 
__4ern_SQL_Query_orderBy  00983 
__4ern_SQL_Query_select   00466 
__4ern_SQL_Query_table    00288 
__4ern_SQL_Query_where    00649 
__4ern_SQL_Query_whereBetween  00768 
__4ern_SQL_Query_whereIn  00790 
__4ern_SQL_Query_whereNotBetween  00786 
__4ern_SQL_Query_whereNotIn  00818 
__4ern_SQL_Query_whereNotNull  00826 
__4ern_SQL_Query_whereNull  00822 
__4ern_SQL__QueryBuilder__Orderby  00933 
__4ern_SQL__QueryBuilder__groupBy  00874 
__4ern_SQL__QueryBuilder__limit  00316 
__4ern_SQL__QueryBuilder__select  00358 
__4ern_SQL__QueryBuilder__setTable  01005 
__4ern_SQL__QueryBuilder__setkey  01036 
__4ern_SQL__QueryBuilder__table  00228 
__4ern_SQL__QueryBuilder__where  00518 
__4ern_SQL_rawQueryExpr   01045 

#### indicates that this specific variable only occurs one time in the script.
---- indicates that this specific variable isn't declared with Dim/Local/Global/Const.

== Variables ======================================================================================================
Variable name             Dim   Used in Row(s)
========================= ===== ===================================================================================
#include                  ----- 00003 00004
$ACTION                   ----- 00228 00234 00239 00316 00320 00358 00363 00374 00518 00533 00556 00874 00879 00884 
                                00933 00938 00943 01004 01009
$C1                       ----- 00288 00304 00466 00482 00489 00505
$C2                       ----- 00288 00304 00466 00482 00489 00505
$C3                       ----- 00288 00304 00466 00482 00489 00505
$C4                       ----- 00288 00304 00466 00482 00489 00505
$C5                       ----- 00288 00304 00466 00482 00489 00505
$C6                       ----- 00288 00304 00466 00482 00489 00505
$C7                       ----- 00288 00304 00466 00482 00489 00505
$C8                       ----- 00288 00304 00466 00482 00489 00505
$C9                       ----- 00288 00304 00466 00482 00489 00505
$COLM                     ----- 00056 00064 00065 00085 00086 00088 00099 00101 00159 00168 00173 00179 00180 00185 
                                00186 00187 00188 00189 00191 00215 00217 00228 00248 00249 00253 00288 00293 00294 
                                00303 00358 00395 00396 00400 00416 00417 00421 00466 00471 00472 00481 00489 00494 
                                00495 00504 00649 00654 00655 00670 00674 00675 00687 00691 00699 00700 00745 00756 
                                00764 00765 00768 00776 00783 00786 00787 00790 00797 00808 00815 00818 00819 00822 
                                00823 00826 00827 00836 00837 00840 00841 00844 00845 00848 00849 00852 00853 00856 
                                00857 00860 00861 00864 00865 00874 00890 00923 00924 00933 00953 00983 00996
$FO                       ----- 00650 00674 00675 00699 00700 00744 00745 00755 00756 00796 00797
$HAVING_QUEUE             ----- 00524 00548 00638 00639 00642
$METHODE                  ----- 00358 00369 00380 00386 00407 00518 00536 00562 00567 00570 00649 00679 00704 00749 
                                00760 00768 00773 00776 00780 00783 00790 00797 00799 00805 00808 00812 00815 00822 
                                00823
$P_TABLE                  ----- 01004 01011
$P_TKEY                   ----- 01004 01012
$QUEUE                    ----- 00232 00233 00250 00253 00265 00273 00279 00362 00397 00400 00418 00421 00443 00448 
                                00455 00456 00542 00548 00567 00570 00575 00583 00592 00595 00878 00890 00903 00908 
                                00915 00937 00953 00964 00969 00976
$SET_QUE                  ----- 00518 00534 00541 00547 00649 00679 00704 00749 00760 00768 00776 00783 00790 00799 
                                00815 00822 00823
$SQL                      ----- 00021 00042 00047 00058 00118 00123 00133 00146 00151 00200 00205 00220 00221 00898 
                                00909 00920 01044 01045
$SQL_OPERATOR             ----- 00518 00535 00575 00583 00592 00595
$S_tKey                   ----- 01007 01012 01029 01031
$S_table                  ----- 01006 01011 01018 01019 01020
$String                   ----- 00059 00086 00088 00091 00099 00101 00118 00134 00146 00178 00180 00182 00184 00189 
                                00191 00194 00195 00200 00215 00217 00220 00261 00268 00274 00284 00435 00437 00443 
                                00449 00463 00613 00616 00621 00637 00640 00645 00675 00679 00700 00704 00745 00749 
                                00756 00760 00797 00799 00960 00970 00980
$V1                       ----- 00159 00211 00212 00214 00215 00217 00649 00722 00730 00745 00755 00756 00764 00765 
                                00768 00771 00776 00778 00783 00786 00787 00790 00793 00794 00795 00803 00808 00810 
                                00815 00818 00819 00836 00837 00840 00841 00844 00845 00848 00849 00852 00853 00856 
                                00857 00983 00988 00989 00996
$V2                       ----- 00649 00736 00744 00745 00764 00765 00768 00772 00776 00779 00783 00786 00787 00790 
                                00804 00808 00811 00815 00818 00819 00836 00837 00840 00841 00844 00845 00848 00849 
                                00852 00853 00856 00857
$VAL                      ----- 00056 00094 00098 00099 00101
$WHERE_QUEUE              ----- 00523 00542 00614 00615 00618
$aC                       ----- 00304 00305 00482 00483 00505 00506
$aVALUE                   ----- 00518 00565 00566 00570 00575 00583 00590 00591 00595
$bBetween                 ----- 00543 00549 00574 00576
$bHavingBetween           ----- 00526 00549 00619 00643
$bHavingIn                ----- 00528 00550 00620 00644
$bIn                      ----- 00544 00550 00582 00584
$bWhereBetween            ----- 00525 00543
$bWhereIn                 ----- 00527 00544
$defDatabase              ----- 00331 00335 00340
$element                  ----- 00249 00250 00396 00397 00417 00418 00566 00567 00591 00592 00795 00796 00797
$elemet                   ----- 00273 00274 00448 00449 00615 00616 00639 00640 00908 00909 00969 00970
$from                     ----- 00027 00028 00042
$groupBy                  ----- 00035 00042
$having                   ----- 00036 00042
$i                        ----- 00084 00085 00086 00088 00179 00180 00185 00186 00187 00188 00189 00191 00670 00674 
                                00675 00687 00691 00699 00700
$iColm                    ----- 00065 00071 00075 00083 00084 00655 00661 00669 00686
$isMethode                ----- 00364 00369 00386 00407 00435 00437 00458
$key                      ----- 00305 00306 00483 00484 00506 00507 01035 01037
$limit                    ----- 00033 00042 00318 00323 00329 00335 00341 00348
$orderBy                  ----- 00037 00042
$pLIMIT                   ----- 00316 00322 00323
$ret                      ----- 00047 00048 00266 00267 00268 00765 00766 00787 00788 00819 00820 00823 00824 00827 
                                00828 00837 00838 00841 00842 00845 00846 00849 00850 00853 00854 00857 00858 00861 
                                00862 00865 00866 00924 00925 00996 00997
$select                   ----- 00026 00042
$table                    ----- 00109 00110 00111 00112 00118 00139 00140 00146 00161 00162 00163 00200 00220
$take                     ----- 00434 00435
$where                    ----- 00034 00042 00113 00118 00141 00146
0                         ----- 00028 00048 00071 00073 00077 00084 00085 00086 00088 00096 00098 00110 00112 00140 
                                00162 00175 00179 00180 00185 00186 00214 00233 00265 00267 00294 00296 00388 00409 
                                00443 00455 00472 00474 00495 00497 00614 00638 00661 00663 00670 00675 00687 00691 
                                00700 00712 00724 00738 00766 00772 00774 00779 00781 00788 00794 00804 00806 00811 
                                00813 00820 00824 00828 00838 00842 00846 00850 00854 00858 00862 00866 00903 00925 
                                00964 00988 00990 00997 01023
1                         ----- 00033 00073 00077 00084 00085 00086 00088 00091 00096 00098 00175 00179 00182 00185 
                                00186 00187 00188 00189 00191 00194 00214 00266 00284 00296 00303 00306 00309 00388 
                                00409 00434 00463 00474 00481 00484 00487 00497 00504 00507 00510 00576 00584 00621 
                                00645 00663 00670 00674 00675 00679 00687 00691 00700 00704 00712 00724 00730 00738 
                                00749 00750 00760 00761 00774 00776 00781 00783 00799 00800 00806 00808 00813 00815 
                                00823 00891 00920 00924 00980 00990 00996 01023
2                         ----- 00065 00075 00083 00112 00173 00294 00472 00495 00655 00669 00699 00700 00794
3                         ----- 00686
4                         ----- 00042 00118 00146 00200 00220 00621 00645 00920
@error                    ----- 00028 00048 00110 00140 00162 00267 00766 00788 00820 00824 00828 00838 00842 00846 
                                00850 00854 00858 00862 00866 00925 00997
ACTION                    00228 00316 00358 00518 00874 00933 01005
And                       ----- 00691
ByRef                     ----- 00056
C1                        00288 00466 00489
C2                        00288 00466 00489
C3                        00288 00466 00489
C4                        00288 00466 00489
C5                        00288 00466 00489
C6                        00288 00466 00489
C7                        00288 00466 00489
C8                        00288 00466 00489
C9                        00288 00466 00489
COLM                      00056 00159 00228 00288 00358 00466 00489 00649 00764 00768 00786 00790 00818 00822 00826 
                                00836 00840 00844 00848 00852 00856 00860 00864 00874 00923 00933 00983
Case                      ----- 00071 00075 00083 00243 00259 00321 00328 00379 00385 00406 00428 00557 00564 00573 
                                00581 00589 00602 00626 00661 00669 00686 00710 00771 00778 00793 00803 00810 00889 
                                00896 00948 00958 01010 01017 01028
ContinueLoop              ----- 00693
Count                     ----- 00265 00443 00455 00614 00638 00903 00964
Default                   ----- 00056 00094 00159 00228 00288 00306 00316 00358 00466 00484 00489 00507 00518 00649 
                                00679 00704 00722 00736 00749 00760 00764 00768 00776 00783 00786 00790 00799 00815 
                                00818 00822 00823 00836 00840 00844 00848 00852 00856 00874 00933 01004 01019 01037
Else                      ----- 00087 00093 00100 00190 00216 00252 00399 00420 00436 00569 00577 00585 00594 00710 
                                00751
EndFunc                   ----- 00049 00124 00152 00222 00287 00310 00350 00465 00488 00511 00648 00763 00767 00785 
                                00789 00817 00821 00825 00829 00839 00843 00847 00851 00855 00859 00863 00867 00922 
                                00926 00982 00998 01034 01038 01046
EndIf                     ----- 00089 00097 00102 00103 00176 00192 00206 00218 00254 00269 00297 00298 00325 00343 
                                00389 00401 00410 00422 00438 00475 00476 00498 00499 00545 00551 00571 00579 00587 
                                00596 00694 00714 00725 00739 00762 00775 00782 00801 00807 00814 00991 01021
EndSelect                 ----- 00092 00713 00784 00816
EndSwitch                 ----- 00286 00349 00423 00464 00597 00647 00921 00981 01033
#### FO                   00650
For                       ----- 00084 00179 00185 00249 00273 00305 00396 00417 00448 00483 00506 00566 00591 00615 
                                00639 00670 00687 00795 00908 00969
Func                      ----- 00019 00056 00131 00159 00228 00288 00316 00358 00466 00489 00518 00649 00764 00768 
                                00786 00790 00818 00822 00826 00836 00840 00844 00848 00852 00856 00860 00864 00874 
                                00923 00933 00983 01004 01035 01044
If                        ----- 00028 00064 00094 00110 00140 00162 00168 00173 00233 00234 00248 00250 00253 00265 
                                00267 00293 00294 00306 00322 00329 00363 00369 00386 00395 00397 00400 00407 00416 
                                00418 00421 00433 00443 00471 00472 00484 00494 00495 00507 00533 00534 00535 00536 
                                00541 00547 00565 00567 00570 00574 00575 00582 00583 00590 00592 00595 00614 00638 
                                00654 00722 00736 00772 00779 00794 00804 00811 00879 00890 00903 00938 00953 00964 
                                00988 01011 01012 01018 01029
In                        ----- 00249 00273 00305 00396 00417 00448 00483 00506 00566 00591 00615 00639 00795 00908 
                                00969
Local                     ----- 00021 00058 00059 00133 00134 00161 00232 00304 00318 00331 00362 00364 00434 00435 
                                00437 00482 00505 00523 00524 00525 00526 00527 00528 00650 00878 00898 00937 01006 
                                01007
METHODE                   00358 00518 00649 00768 00790 00822
Next                      ----- 00090 00181 00193 00251 00275 00307 00398 00419 00450 00485 00508 00568 00593 00617 
                                00641 00680 00705 00798 00910 00971
Not                       ----- 01011 01012 01018 01029
Null                      ----- 00021 00058 00133 00318 00329 00364 00369 00458 00525 00526 00527 00528 00574 00582 
                                00619 00620 00643 00644
Or                        ----- 00730
#### P_TABLE              01005
#### P_TKEY               01005
Return                    ----- 00028 00048 00073 00077 00096 00110 00123 00140 00151 00162 00175 00205 00221 00267 
                                00268 00284 00296 00309 00324 00329 00335 00342 00348 00388 00409 00443 00463 00474 
                                00487 00497 00510 00614 00621 00638 00645 00663 00712 00724 00738 00750 00761 00766 
                                00774 00781 00788 00800 00806 00813 00820 00824 00828 00838 00842 00846 00850 00854 
                                00858 00862 00866 00891 00903 00920 00925 00964 00980 00990 00997 01020 01023 01029 
                                01031
SET_QUE                   00518 00649 00768 00790 00822
SQL                       00021 00058 00133 00898 01045
#### SQL_OPERATOR         00518
Select                    ----- 00066 00656 00770 00792
Static                    ----- 00161 00232 00318 00362 00364 00523 00524 00525 00526 00527 00528 00878 00937 01006 
                                01007
#### Static$HAVING_QUEUE  00524
#### Static$LIMIT         00318
Static$QUEUE              00232 00362 00878 00937
#### Static$S_tKey        01008
#### Static$S_table       01007
#### Static$WHERE_QUEUE   00523
#### Static$bHavingBetween  00526
#### Static$bHavingIn     00528
#### Static$bWhereBetween  00525
#### Static$bWhereIn      00527
#### Static$isMethode     00364
#### Static$table         00161
String                    00059 00134 00435 00437
Switch                    ----- 00239 00320 00374 00380 00556 00562 00884 00943 01009
Then                      ----- 00028 00064 00085 00094 00098 00110 00140 00162 00168 00173 00186 00214 00233 00234 
                                00248 00250 00253 00265 00267 00293 00294 00306 00322 00329 00335 00340 00363 00369 
                                00386 00395 00397 00400 00407 00416 00418 00421 00433 00443 00471 00472 00484 00494 
                                00495 00507 00533 00534 00535 00536 00541 00547 00565 00567 00570 00574 00575 00582 
                                00583 00590 00592 00595 00614 00638 00654 00691 00722 00730 00736 00772 00779 00794 
                                00804 00811 00879 00890 00903 00938 00953 00964 00988 01011 01012 01018 01029
To                        ----- 00084 00179 00185 00670 00687
V1                        00159 00649 00764 00768 00786 00790 00818 00836 00840 00844 00848 00852 00856 00983
V2                        00649 00764 00768 00786 00790 00818 00836 00840 00844 00848 00852 00856
#### VAL                  00056
WEnd                      ----- 00457
While                     ----- 00455
__4ern_SQL_Connection     ----- 00433
aC                        00304 00482 00505
#### aVALUE               00518
au3                       ----- 00004
clear                     ----- 00279 00456 00618 00642 00915 00976
#### defDatabase          00331
#### key                  01036
#### pLIMIT               00316
queryBuilder              ----- 00004
#### take                 00434
== Sort Func Names Within #regions =====================================================================
 --------------- Current sequence  ----------------------------------------------------------- 
0000000019   Func __4ern_SQL_QueryBuilder_get()
0000000049   EndFunc   ;==>__4ern_SQL_QueryBuilder_get
0000000056   Func __4ern_SQL_QueryBuilder_Update(ByRef $COLM, $VAL = Default)
0000000124   EndFunc   ;==>__4ern_SQL_QueryBuilder_Update
0000000131   Func __4ern_SQL_QueryBuilder_Delete()
0000000152   EndFunc   ;==>__4ern_SQL_QueryBuilder_Delete
0000000159   Func __4ern_SQL_Query_insert($COLM, $V1 = Default)
0000000222   EndFunc   ;==>__4ern_SQL_Query_insert
0000000228   Func __4ern_SQL__QueryBuilder__table($ACTION = Default, $COLM = Default)
0000000287   EndFunc   ;==>__4ern_SQL__QueryBuilder__table
0000000288   Func __4ern_SQL_Query_table($COLM = Default, $C1 = Default, $C2 = Default, $C3 = Default, $C4 = Default, $C5 = Default, $C6 = Default, $C7 = Default, $C8 = Default, $C9 = Default)
0000000310   EndFunc   ;==>__4ern_SQL_Query_table
0000000316   Func __4ern_SQL__QueryBuilder__limit($pLIMIT = Default, $ACTION = 'set')
0000000350   EndFunc   ;==>__4ern_SQL__QueryBuilder__limit
0000000358   Func __4ern_SQL__QueryBuilder__select($ACTION = Default, $COLM = Default, $METHODE = 'SELECT')
0000000465   EndFunc   ;==>__4ern_SQL__QueryBuilder__select
0000000466   Func __4ern_SQL_Query_select($COLM, $C1 = Default, $C2 = Default, $C3 = Default, $C4 = Default, $C5 = Default, $C6 = Default, $C7 = Default, $C8 = Default, $C9 = Default)
0000000488   EndFunc   ;==>__4ern_SQL_Query_select
0000000489   Func __4ern_SQL_Query_distinct($COLM, $C1 = Default, $C2 = Default, $C3 = Default, $C4 = Default, $C5 = Default, $C6 = Default, $C7 = Default, $C8 = Default, $C9 = Default)
0000000511   EndFunc   ;==>__4ern_SQL_Query_distinct
0000000518   Func __4ern_SQL__QueryBuilder__where($ACTION = Default, $aVALUE = Default, $METHODE = Default, $SQL_OPERATOR = Default, $SET_QUE = Default)
0000000648   EndFunc   ;==>__4ern_SQL__QueryBuilder__where
0000000649   Func __4ern_SQL_Query_where($COLM, $V1 = Default, $V2 = Default, $METHODE = 'AND', $SET_QUE = Default)
0000000763   EndFunc   ;==>__4ern_SQL_Query_where
0000000764   Func __4ern_SQL_Query_orWhere($COLM, $V1 = Default, $V2 = Default)
0000000767   EndFunc   ;==>__4ern_SQL_Query_orWhere
0000000768   Func __4ern_SQL_Query_whereBetween($COLM, $V1 = Default, $V2 = Default, $METHODE = 'BETWEEN', $SET_QUE = Default)
0000000785   EndFunc   ;==>__4ern_SQL_Query_whereBetween
0000000786   Func __4ern_SQL_Query_whereNotBetween($COLM, $V1 = Default, $V2 = Default)
0000000789   EndFunc   ;==>__4ern_SQL_Query_whereNotBetween
0000000790   Func __4ern_SQL_Query_whereIn($COLM, $V1 = Default, $V2 = Default, $METHODE = 'IN', $SET_QUE = Default)
0000000817   EndFunc   ;==>__4ern_SQL_Query_whereIn
0000000818   Func __4ern_SQL_Query_whereNotIn($COLM, $V1 = Default, $V2 = Default)
0000000821   EndFunc   ;==>__4ern_SQL_Query_whereNotIn
0000000822   Func __4ern_SQL_Query_whereNull($COLM, $METHODE = 'IS NULL', $SET_QUE = Default)
0000000825   EndFunc   ;==>__4ern_SQL_Query_whereNull
0000000826   Func __4ern_SQL_Query_whereNotNull($COLM)
0000000829   EndFunc   ;==>__4ern_SQL_Query_whereNotNull
0000000836   Func __4ern_SQL_Query_having($COLM, $V1 = Default, $V2 = Default)
0000000839   EndFunc   ;==>__4ern_SQL_Query_having
0000000840   Func __4ern_SQL_Query_orHaving($COLM, $V1 = Default, $V2 = Default)
0000000843   EndFunc   ;==>__4ern_SQL_Query_orHaving
0000000844   Func __4ern_SQL_Query_havingBetween($COLM, $V1 = Default, $V2 = Default)
0000000847   EndFunc   ;==>__4ern_SQL_Query_havingBetween
0000000848   Func __4ern_SQL_Query_havingNotBetween($COLM, $V1 = Default, $V2 = Default)
0000000851   EndFunc   ;==>__4ern_SQL_Query_havingNotBetween
0000000852   Func __4ern_SQL_Query_havingIn($COLM, $V1 = Default, $V2 = Default)
0000000855   EndFunc   ;==>__4ern_SQL_Query_havingIn
0000000856   Func __4ern_SQL_Query_havingNotIn($COLM, $V1 = Default, $V2 = Default)
0000000859   EndFunc   ;==>__4ern_SQL_Query_havingNotIn
0000000860   Func __4ern_SQL_Query_havingNull($COLM)
0000000863   EndFunc   ;==>__4ern_SQL_Query_havingNull
0000000864   Func __4ern_SQL_Query_havingNotNull($COLM)
0000000867   EndFunc   ;==>__4ern_SQL_Query_havingNotNull
0000000874   Func __4ern_SQL__QueryBuilder__groupBy($ACTION = Default, $COLM = Default)
0000000922   EndFunc   ;==>__4ern_SQL__QueryBuilder__groupBy
0000000923   Func __4ern_SQL_Query_groupBy($COLM)
0000000926   EndFunc   ;==>__4ern_SQL_Query_groupBy
0000000933   Func __4ern_SQL__QueryBuilder__Orderby($ACTION = Default, $COLM = Default)
0000000982   EndFunc   ;==>__4ern_SQL__QueryBuilder__Orderby
0000000983   Func __4ern_SQL_Query_orderBy($COLM, $V1 = 'asc')
0000000998   EndFunc   ;==>__4ern_SQL_Query_orderBy
0000001004   Func __4ern_SQL__QueryBuilder__setTable($P_TABLE = Default, $P_TKEY = Default, $ACTION = 'set')
0000001034   EndFunc   ;==>__4ern_SQL__QueryBuilder__setTable
0000001035   Func __4ern_SQL__QueryBuilder__setkey($key)
0000001038   EndFunc   ;==>__4ern_SQL__QueryBuilder__setkey
0000001044   Func __4ern_SQL_rawQueryExpr($SQL)
0000001046   EndFunc   ;==>__4ern_SQL_rawQueryExpr
 --------------- New Sequence      ----------------------------------------------------------- 
0000000011   Func __4ern_SQL__QueryBuilder__groupBy($ACTION = Default, $COLM = Default)
0000000059   EndFunc   ;==>__4ern_SQL__QueryBuilder__groupBy
0000000065   Func __4ern_SQL__QueryBuilder__limit($pLIMIT = Default, $ACTION = 'set')
0000000099   EndFunc   ;==>__4ern_SQL__QueryBuilder__limit
0000000106   Func __4ern_SQL__QueryBuilder__Orderby($ACTION = Default, $COLM = Default)
0000000155   EndFunc   ;==>__4ern_SQL__QueryBuilder__Orderby
0000000163   Func __4ern_SQL__QueryBuilder__select($ACTION = Default, $COLM = Default, $METHODE = 'SELECT')
0000000270   EndFunc   ;==>__4ern_SQL__QueryBuilder__select
0000000271   Func __4ern_SQL__QueryBuilder__setkey($key)
0000000274   EndFunc   ;==>__4ern_SQL__QueryBuilder__setkey
0000000280   Func __4ern_SQL__QueryBuilder__setTable($P_TABLE = Default, $P_TKEY = Default, $ACTION = 'set')
0000000310   EndFunc   ;==>__4ern_SQL__QueryBuilder__setTable
0000000316   Func __4ern_SQL__QueryBuilder__table($ACTION = Default, $COLM = Default)
0000000375   EndFunc   ;==>__4ern_SQL__QueryBuilder__table
0000000382   Func __4ern_SQL__QueryBuilder__where($ACTION = Default, $aVALUE = Default, $METHODE = Default, $SQL_OPERATOR = Default, $SET_QUE = Default)
0000000512   EndFunc   ;==>__4ern_SQL__QueryBuilder__where
0000000513   Func __4ern_SQL_Query_distinct($COLM, $C1 = Default, $C2 = Default, $C3 = Default, $C4 = Default, $C5 = Default, $C6 = Default, $C7 = Default, $C8 = Default, $C9 = Default)
0000000535   EndFunc   ;==>__4ern_SQL_Query_distinct
0000000536   Func __4ern_SQL_Query_groupBy($COLM)
0000000539   EndFunc   ;==>__4ern_SQL_Query_groupBy
0000000546   Func __4ern_SQL_Query_having($COLM, $V1 = Default, $V2 = Default)
0000000549   EndFunc   ;==>__4ern_SQL_Query_having
0000000550   Func __4ern_SQL_Query_havingBetween($COLM, $V1 = Default, $V2 = Default)
0000000553   EndFunc   ;==>__4ern_SQL_Query_havingBetween
0000000554   Func __4ern_SQL_Query_havingIn($COLM, $V1 = Default, $V2 = Default)
0000000557   EndFunc   ;==>__4ern_SQL_Query_havingIn
0000000558   Func __4ern_SQL_Query_havingNotBetween($COLM, $V1 = Default, $V2 = Default)
0000000561   EndFunc   ;==>__4ern_SQL_Query_havingNotBetween
0000000562   Func __4ern_SQL_Query_havingNotIn($COLM, $V1 = Default, $V2 = Default)
0000000565   EndFunc   ;==>__4ern_SQL_Query_havingNotIn
0000000566   Func __4ern_SQL_Query_havingNotNull($COLM)
0000000569   EndFunc   ;==>__4ern_SQL_Query_havingNotNull
0000000570   Func __4ern_SQL_Query_havingNull($COLM)
0000000573   EndFunc   ;==>__4ern_SQL_Query_havingNull
0000000580   Func __4ern_SQL_Query_insert($COLM, $V1 = Default)
0000000643   EndFunc   ;==>__4ern_SQL_Query_insert
0000000644   Func __4ern_SQL_Query_orderBy($COLM, $V1 = 'asc')
0000000659   EndFunc   ;==>__4ern_SQL_Query_orderBy
0000000660   Func __4ern_SQL_Query_orHaving($COLM, $V1 = Default, $V2 = Default)
0000000663   EndFunc   ;==>__4ern_SQL_Query_orHaving
0000000664   Func __4ern_SQL_Query_orWhere($COLM, $V1 = Default, $V2 = Default)
0000000667   EndFunc   ;==>__4ern_SQL_Query_orWhere
0000000668   Func __4ern_SQL_Query_select($COLM, $C1 = Default, $C2 = Default, $C3 = Default, $C4 = Default, $C5 = Default, $C6 = Default, $C7 = Default, $C8 = Default, $C9 = Default)
0000000690   EndFunc   ;==>__4ern_SQL_Query_select
0000000691   Func __4ern_SQL_Query_table($COLM = Default, $C1 = Default, $C2 = Default, $C3 = Default, $C4 = Default, $C5 = Default, $C6 = Default, $C7 = Default, $C8 = Default, $C9 = Default)
0000000713   EndFunc   ;==>__4ern_SQL_Query_table
0000000714   Func __4ern_SQL_Query_where($COLM, $V1 = Default, $V2 = Default, $METHODE = 'AND', $SET_QUE = Default)
0000000828   EndFunc   ;==>__4ern_SQL_Query_where
0000000829   Func __4ern_SQL_Query_whereBetween($COLM, $V1 = Default, $V2 = Default, $METHODE = 'BETWEEN', $SET_QUE = Default)
0000000846   EndFunc   ;==>__4ern_SQL_Query_whereBetween
0000000847   Func __4ern_SQL_Query_whereIn($COLM, $V1 = Default, $V2 = Default, $METHODE = 'IN', $SET_QUE = Default)
0000000874   EndFunc   ;==>__4ern_SQL_Query_whereIn
0000000875   Func __4ern_SQL_Query_whereNotBetween($COLM, $V1 = Default, $V2 = Default)
0000000878   EndFunc   ;==>__4ern_SQL_Query_whereNotBetween
0000000879   Func __4ern_SQL_Query_whereNotIn($COLM, $V1 = Default, $V2 = Default)
0000000882   EndFunc   ;==>__4ern_SQL_Query_whereNotIn
0000000883   Func __4ern_SQL_Query_whereNotNull($COLM)
0000000886   EndFunc   ;==>__4ern_SQL_Query_whereNotNull
0000000887   Func __4ern_SQL_Query_whereNull($COLM, $METHODE = 'IS NULL', $SET_QUE = Default)
0000000890   EndFunc   ;==>__4ern_SQL_Query_whereNull
0000000897   Func __4ern_SQL_QueryBuilder_Delete()
0000000918   EndFunc   ;==>__4ern_SQL_QueryBuilder_Delete
0000000933   Func __4ern_SQL_QueryBuilder_get()
0000000963   EndFunc   ;==>__4ern_SQL_QueryBuilder_get
0000000970   Func __4ern_SQL_QueryBuilder_Update(ByRef $COLM, $VAL = Default)
0000001038   EndFunc   ;==>__4ern_SQL_QueryBuilder_Update
0000001044   Func __4ern_SQL_rawQueryExpr($SQL)
0000001046   EndFunc   ;==>__4ern_SQL_rawQueryExpr
== END Sort Func Names Within #Region - #EndRegion =====================================================

