├── .github
    ├── ISSUE_TEMPLATE
    │   ├── bug_report.md
    │   └── feature_request.md
    ├── install_mssql.sh
    └── workflows
    │   ├── ezsql-linux.yml
    │   ├── ezsql-macos.yml
    │   └── ezsql-windows.yml
├── CHANGELOG.md
├── CONTRIBUTORS.md
├── LICENSE
├── README.md
├── WIKI.md
├── _config.yml
├── cacert.pem
├── composer.json
├── lib
    ├── Config.php
    ├── ConfigAbstract.php
    ├── ConfigInterface.php
    ├── Constants.php
    ├── DInjector.php
    ├── Database.php
    ├── Database
    │   ├── ez_mysqli.php
    │   ├── ez_pdo.php
    │   ├── ez_pgsql.php
    │   ├── ez_sqlite3.php
    │   └── ez_sqlsrv.php
    ├── DatabaseInterface.php
    ├── Db.php
    ├── Exception
    │   ├── ContainerException.php
    │   └── NotFoundException.php
    ├── ezFunctions.php
    ├── ezQuery.php
    ├── ezQueryInterface.php
    ├── ezResultset.php
    ├── ezSchema.php
    ├── ezsqlModel.php
    └── ezsqlModelInterface.php
├── openssl.cnf
└── unsupported
    ├── .travis.yml
    ├── appveyor.yml
    ├── ez_sql_loader.php
    ├── lib
        ├── ez_sql_cubrid.php
        ├── ez_sql_oracle8_9.php
        └── ez_sql_oracleTNS.php
    └── tests
        ├── cubrid
            └── ezSQL_cubridTest.php
        └── oracle8_9
            ├── ezSQL_oracle8_9Test.php
            └── ezSQL_oracleTNSTest_.php


/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: ''
 5 | labels: error-bug, warning-bug
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Describe the bug**
11 | A clear and concise description of what the bug is.
12 | 
13 | **To Reproduce**
14 | Steps to reproduce the behavior:
15 | 
16 | **Expected behavior**
17 | A clear and concise description of what you expected to happen.
18 | 
19 | > *Warning*: Failing to provide necessary information may cause the issue to be closed without consideration
20 | 
21 | **Environment (please complete the following information):**
22 |  - EZSQL Version : 
23 |  - PHP Version:
24 |  - SQL Driver:[ mysql, pgsql, sqlserver, sqlite3]
25 | 
26 | **PHP code snippet used**
27 | 
28 | ```php
29 | <?php
30 | 
31 | 
32 | ```
33 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Feature request
 3 | about: Suggest an idea for this project
 4 | title: ''
 5 | labels: Enhancements
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | **Is your feature request related to a problem? Please describe.**
11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
12 | 
13 | **Describe the solution you'd like**
14 | A clear and concise description of what you want to happen.
15 | 
16 | **Describe alternatives you've considered**
17 | A clear and concise description of any alternative solutions or features you've considered.
18 | 
19 | **Additional context**
20 | Add any other context or screenshots about the feature request here.
21 | 


--------------------------------------------------------------------------------
/.github/install_mssql.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash -e
 2 | 
 3 | # Use the following variables to control your install:
 4 | 
 5 | # Password for the SA user (required)
 6 | MSSQL_SA_PASSWORD='!Passw0rd'
 7 | 
 8 | # Product ID of the version of SQL server you're installing
 9 | # Must be evaluation, developer, express, web, standard, enterprise, or your 25 digit product key
10 | # Defaults to developer
11 | MSSQL_PID='evaluation'
12 | 
13 | # Install SQL Server Agent (recommended)
14 | SQL_INSTALL_AGENT='y'
15 | 
16 | # Install SQL Server Full Text Search (optional)
17 | # SQL_INSTALL_FULLTEXT='y'
18 | 
19 | # Create an additional user with sysadmin privileges (optional)
20 | SQL_INSTALL_USER='ez_test'
21 | SQL_INSTALL_USER_PASSWORD='ezTest'
22 | SQL_INSTALL_DATABASE='ez_test'
23 | 
24 | if [ -z $MSSQL_SA_PASSWORD ]
25 | then
26 |   echo Environment variable MSSQL_SA_PASSWORD must be set for unattended install
27 |   exit 1
28 | fi
29 | 
30 | echo Adding Microsoft repositories...
31 | sudo curl https://packages.microsoft.com/keys/microsoft.asc | sudo apt-key add -
32 | sudo curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
33 | repoargs="$(curl https://packages.microsoft.com/config/ubuntu/18.04/mssql-server-2019.list)"
34 | sudo add-apt-repository "${repoargs}"
35 | 
36 | echo Running apt-get update -y...
37 | sudo apt-get update -y
38 | 
39 | echo Installing SQL Server...
40 | sudo apt-get install -y mssql-server
41 | 
42 | echo Running mssql-conf setup...
43 | sudo MSSQL_SA_PASSWORD=$MSSQL_SA_PASSWORD \
44 |      MSSQL_PID=$MSSQL_PID \
45 |      /opt/mssql/bin/mssql-conf -n setup accept-eula
46 | 
47 | # Configure firewall to allow TCP port 1433:
48 | echo Configuring UFW to allow traffic on port 1433...
49 | sudo ufw allow 1433/tcp
50 | sudo ufw reload
51 | 
52 | # Restart SQL Server after installing:
53 | echo Restarting SQL Server...
54 | sudo systemctl restart mssql-server
55 | 
56 | # Optional new user creation:
57 | if [ ! -z $SQL_INSTALL_USER ] && [ ! -z $SQL_INSTALL_USER_PASSWORD ]
58 | then
59 |   echo Creating user $SQL_INSTALL_USER
60 |   sqlcmd \
61 |     -S localhost \
62 |     -U SA \
63 |     -P $MSSQL_SA_PASSWORD \
64 |     -Q "CREATE DATABASE ez_test"
65 |   sqlcmd \
66 |     -S localhost \
67 |     -U SA \
68 |     -P $MSSQL_SA_PASSWORD \
69 |     -Q "CREATE LOGIN [$SQL_INSTALL_USER] WITH PASSWORD=N'$SQL_INSTALL_USER_PASSWORD', DEFAULT_DATABASE=[$SQL_INSTALL_DATABASE], CHECK_EXPIRATION=OFF, CHECK_POLICY=OFF; ALTER SERVER ROLE [sysadmin] ADD MEMBER [$SQL_INSTALL_USER]"
70 | fi
71 | 
72 | echo Done!
73 | 


--------------------------------------------------------------------------------
/.github/workflows/ezsql-linux.yml:
--------------------------------------------------------------------------------
 1 | # GitHub Action for PHP with extensions
 2 | name: Linux
 3 | 
 4 | on:
 5 |   push:
 6 |     branches:
 7 |     - master
 8 |   pull_request:
 9 |     branches:
10 |     - master
11 | 
12 | jobs:
13 |   linux:
14 |     name: Linux (PHP ${{ matrix.php-versions }} CI)
15 |     runs-on: ubuntu-18.04
16 |     strategy:
17 |       fail-fast: false
18 |       matrix:
19 |         operating-system: [ubuntu-18.04]
20 |         php-versions: ['7.4', '8.0', '8.1']
21 | 
22 |     steps:
23 |       - name: Checkout
24 |         uses: actions/checkout@v2
25 |       - name: Setup PHP, with composer and extensions
26 |         uses: shivammathur/setup-php@v2 #https://github.com/shivammathur/setup-php
27 |         with:
28 |           php-version: ${{ matrix.php-versions }}
29 |           extensions: mbstring, fileinfo, mysqli, pdo_mysql, pgsql, pdo_pgsql, sqlite3, pdo_sqlite, sqlsrv, pdo_sqlsrv, xdebug
30 |           coverage: xdebug
31 |       - name: Start MySQL
32 |         run: sudo systemctl start mysql.service
33 |       - name: Setup MySQL Database
34 |         run: |
35 |           mysql -uroot -h127.0.0.1 -proot -e "CREATE DATABASE IF NOT EXISTS ez_test;"
36 |           mysql -uroot -h127.0.0.1 -proot -e "CREATE USER ez_test@localhost IDENTIFIED BY 'ezTest'; GRANT ALL ON ez_test.* TO ez_test@localhost; FLUSH PRIVILEGES;"
37 |       - name: Start PostgreSql
38 |         run: |
39 |           sudo systemctl start postgresql.service
40 |           pg_isready
41 |       - name: Create additional user
42 |         run: |
43 |           sudo -u postgres psql --command="CREATE USER ez_test PASSWORD 'ezTest'" --command="\du"
44 |       - name: Setup PostgreSql Database
45 |         run: |
46 |           sudo -u postgres createdb --owner=ez_test ez_test
47 |       - name: Setup SQLServer Database
48 |         run: |
49 |           chmod +x "${GITHUB_WORKSPACE}/.github/install_mssql.sh"
50 |           "${GITHUB_WORKSPACE}/.github/install_mssql.sh"
51 |       - name: Install dependencies
52 |         run: composer update
53 |       - name: Test with phpunit
54 |         run: vendor/bin/phpunit --coverage-clover=coverage.xml
55 |       - name: Submit code coverage
56 |         run: bash <(curl -s https://codecov.io/bash)
57 | 


--------------------------------------------------------------------------------
/.github/workflows/ezsql-macos.yml:
--------------------------------------------------------------------------------
 1 | # GitHub Action for PHP with extensions
 2 | name: macOS
 3 | 
 4 | on:
 5 |   push:
 6 |     branches:
 7 |     - master
 8 |   pull_request:
 9 |     branches:
10 |     - master
11 | 
12 | jobs:
13 |   windows:
14 |     name: macOS (PHP ${{ matrix.php-versions }} CI)
15 |     runs-on: macos-latest
16 |     continue-on-error: true
17 |     strategy:
18 |       fail-fast: false
19 |       matrix:
20 |         operating-system: [macos-latest]
21 |         php-versions: ['7.3']
22 | 
23 |     steps:
24 |       - name: Checkout
25 |         uses: actions/checkout@v2
26 |       - name: Setup PHP, with composer and extensions
27 |         uses: shivammathur/setup-php@v2 #https://github.com/shivammathur/setup-php
28 |         with:
29 |           php-version: ${{ matrix.php-versions }}
30 |           extensions: mbstring, fileinfo, mysqli, pdo_mysql, pgsql, pdo_pgsql, sqlite3, pdo_sqlite, xdebug
31 |           coverage: xdebug
32 |       - name: Brew Install MySQL
33 |         run: |
34 |           brew install mysql@5.7
35 |       - name: Brew Start MySQL
36 |         run: |
37 |           brew link mysql@5.7 --force
38 |           sudo rm -rf /usr/local/var/mysql
39 |           sudo rm /usr/local/etc/my.cnf
40 |           mysqld --initialize-insecure --explicit_defaults_for_timestamp
41 |           mysql.server start
42 |       - name: Setup MySQL Database
43 |         run: |
44 |           mysql -u root -e "CREATE DATABASE IF NOT EXISTS ez_test;"
45 |           mysql -u root -e "CREATE USER ez_test@localhost IDENTIFIED BY 'ezTest'; GRANT ALL ON ez_test.* TO ez_test@localhost; FLUSH PRIVILEGES;"
46 |       - name: Brew Start PostgreSql
47 |         run: |
48 |           sudo mkdir /var/pgsql_socket/
49 |           sudo ln -s /private/tmp/.s.PGSQL.5432 /var/pgsql_socket/
50 |           pg_ctl -D /usr/local/var/postgres -l /usr/local/var/postgres/server.log start
51 |           brew services restart postgresql
52 |       - name: Setup PostgreSql Database
53 |         run: |
54 |           createuser -s postgres
55 |           psql -U postgres --command="CREATE USER ez_test PASSWORD 'ezTest'" --command="\du"
56 |           createdb --owner=ez_test ez_test
57 |       - name: Install dependencies
58 |         run: |
59 |           composer self-update
60 |           composer update
61 |       - name: Test with phpunit
62 |         run: ./vendor/bin/phpunit --coverage-clover=coverage.xml
63 |       - name: Submit code coverage
64 |         if: ${{ success() }} || ${{ failure() }}
65 |         uses: codecov/codecov-action@v1
66 |         with:
67 |           file: ./coverage.xml # optional
68 | 


--------------------------------------------------------------------------------
/.github/workflows/ezsql-windows.yml:
--------------------------------------------------------------------------------
 1 | # GitHub Action for PHP with extensions
 2 | name: Windows
 3 | 
 4 | on:
 5 |   push:
 6 |     branches:
 7 |     - master
 8 |   pull_request:
 9 |     branches:
10 |     - master
11 | 
12 | jobs:
13 |   windows:
14 |     name: Windows (PHP ${{ matrix.php-versions }} CI)
15 |     runs-on: windows-latest
16 |     strategy:
17 |       fail-fast: false
18 |       matrix:
19 |         operating-system: [windows-latest]
20 |         php-versions: ['7.1', '7.2']
21 | 
22 |     steps:
23 |       - name: Checkout
24 |         uses: actions/checkout@v2
25 |       - name: Setup PHP, with composer and extensions
26 |         uses: shivammathur/setup-php@v2 #https://github.com/shivammathur/setup-php
27 |         with:
28 |           php-version: ${{ matrix.php-versions }}
29 |           extensions: mbstring, fileinfo, mysqli, pdo_mysql, pgsql, pdo_pgsql, sqlite3, pdo_sqlite, sqlsrv, pdo_sqlsrv, xdebug
30 |           coverage: xdebug
31 |       - name: Chocolatey Install MySQL
32 |         run: choco install mysql --version=5.7.18 -y -f
33 |       - name: Setup MySQL Database
34 |         run: |
35 |           mysql -u root -e "CREATE DATABASE IF NOT EXISTS ez_test;"
36 |           mysql -u root -e "CREATE USER ez_test@localhost IDENTIFIED BY 'ezTest'; GRANT ALL ON ez_test.* TO ez_test@localhost; FLUSH PRIVILEGES;"
37 |       - name: Chocolatey Uninstall PostgreSql 13
38 |         run: choco uninstall postgresql13 -y -f
39 |       - name: Chocolatey Install PostgreSql 9
40 |         run: choco install postgresql9 --params '/Password:root' -y -f
41 |       - name: Setup PostgreSql Database
42 |         run: |
43 |           $env:Path += ";C:\Program Files\PostgreSQL\9.6\bin"
44 |           $env:PGPASSWORD = "root"
45 |           psql -U postgres --command="\conninfo"
46 |           psql -U postgres -c "CREATE USER ez_test WITH PASSWORD 'ezTest';" --command="\du"
47 |           createdb --owner=ez_test ez_test
48 |           [Environment]::SetEnvironmentVariable("Path", $env:Path, [EnvironmentVariableTarget]::Machine)
49 |       - name: Chocolatey Install SQLServer
50 |         run: choco install sql-server-express -ia "/IACCEPTSQLSERVERLICENSETERMS /Q /ACTION=install /INSTANCEID=MSSQLSERVER /INSTANCENAME=MSSQLSERVER /UPDATEENABLED=FALSE /TCPENABLED=1 /SECURITYMODE=SQL /SAPWD=Password12!" -o -y -f
51 |       - name: Setup SQLServer Database
52 |         run: |
53 |           sqlcmd -L
54 |           New-NetFirewallRule -DisplayName "SQLServer default instance" -Direction Inbound -LocalPort 1433 -Protocol TCP -Action Allow
55 |           New-NetFirewallRule -DisplayName "SQLServer Browser service" -Direction Inbound -LocalPort 1434 -Protocol UDP -Action Allow
56 |           sqlcmd -S localhost,1433 -U sa -P Password12! -Q "CREATE DATABASE ez_test"
57 |           sqlcmd -S localhost,1433 -U sa -P Password12! -d ez_test -Q "CREATE LOGIN ez_test WITH PASSWORD=N'ezTest', DEFAULT_DATABASE=ez_test, CHECK_EXPIRATION=OFF, CHECK_POLICY=OFF; ALTER SERVER ROLE [sysadmin] ADD MEMBER ez_test"
58 |       - name: Install dependencies
59 |         run: composer update
60 |       - name: Test with phpunit
61 |         run: vendor\bin\phpunit --coverage-clover=coverage.xml
62 |       - name: Submit code coverage
63 |         uses: codecov/codecov-action@v1
64 |         with:
65 |           file: ./coverage.xml # optional
66 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | Change Log
  2 | ====
  3 | 
  4 | 3.0.9 - 3.1.4
  5 | 
  6 | - added SQL Join shortcut methods `innerJoin`, `leftJoin`, `rightJoin`, `fullJoin`, and an `limit` shortcut method.
  7 | - added SQL table creation shortcut methods `create`, `drop`, `alter`, and an `column` method to handle the schema
  8 | - added support for secure database connections.
  9 | - changed most of the public properties to protected.
 10 | 
 11 | 3.08 - Merged fork https://github.com/sjstoelting/ezSQL3 to be current with this repo.
 12 | 
 13 | - Added/Updated PHPunit tests, some marked as incomplete or not fully implemented, SQL drivers not loaded will be skipped.
 14 | - Refactor class code to use `spl_autoload_register`. 
 15 |   Simply using `require_once "ez_sql_loader.php";` then `$database = new ez_driver_class;`. This will allow multi SQLdb to be loaded if need be. 
 16 | - Added methods `create_select`, `insert_select`, `update`, `insert`, `replace`, `delete`, and `selecting` an alias for select.
 17 |   These are part of the new ezQuery SQL builder class. They are shortcut calls, these new methods will create proper SQL statements, from supplied arguments variable or array, prevent injections, then execute guery, in case of `selecting` execute get_results. 
 18 | - Added many additional functions to support ezQuery builder and to easily process SQL prepare statements. Supplied arguments will be replace with necessary placeholder and values added to parameter array.
 19 | - All new methods has been fully PHPunit tested under current supported database systems, and should be able to handle most use cases as is.
 20 | 
 21 | ```md
 22 | ezSQL3 - From Author: Stefanie Janine Stoelting - http://stefanie-stoelting.de
 23 | 
 24 | News about ezSQL3 are available at http://stefanie-stoelting.de/ezsql3-news.html
 25 | 
 26 | * 3.07 - Added the new class ezSQL_mysql to use mysqli. To update existing projects, just change the class you are using from ezSQL_mysql to ezSQL_mysqli. This class is downward compatible to ezSQL_mysql, but is able to use prepared statements.
 27 | * 3.06 - Extended ezSQL_mysql method quick_connect with a charset parameter
 28 | * 3.05 - Extended ez_sql_oracleTNS class, that does now support client site connection pooling
 29 | * 3.04 - Added a new class for Oracle database connection to get rid of TNSNAMES.ORA configuration files
 30 | * 3.03 - Changed error messages, wrong classname used in a messages
 31 | * 3.02 - Improved ezSQL_recordset, array results of rows are faster
 32 | * 3.01 - Added a class for query result handling. The ezSQL_recordset contains methods that behave like fetch_assoc, fetch_row, and fetch_object
 33 | * 3.00 - Changed the code to PHP5, added PHPDoc tags, and added unit tests
 34 | ```
 35 | 
 36 | 2.17 - Updates to ezSQL_postgresql (thx Stefanie Janine Stoelting)
 37 | 
 38 | 2.16 - Added profiling functions to mySQL version & added fix to stop mySQL hanging on very long runnign scripts
 39 | 
 40 | 2.15 - Fixed long standing bug with $db->rows_affected (thx Pere Pasqual)
 41 | 
 42 | 2.14 - Added sybase connector by Muhammad Iyas
 43 | 
 44 | 2.13 - Support for transactions. See: http://stackoverflow.com/questions/8754215/ezsql-with-multiple-queries/8781798
 45 | 
 46 | 2.12 - Added $db->get_set() - Creates a SET nvp sql string from an associative array (and escapes all values)
 47 | 
 48 | 2.11 - Fixed $db->insert_id in postgres version
 49 | 
 50 | 2.10 - Added isset($this->dbh) check to oracle version
 51 | 
 52 | 2.09 - Fixed issues with mysql_real_escape_string not working if no connection 
 53 |        (Thanks to Nicolas Vannier)
 54 | 
 55 | 2.08 - Re-added timer functions that seemed to have disappeared
 56 | 
 57 | 2.07 - Used mysql_real_escape_string instead of mysql_escape_string
 58 | 
 59 | 2.02 - Please note, this change log is no longer being used
 60 |        please see change_log.htm for changes later than
 61 |        2.02
 62 | 
 63 | 2.01 - Added Disk Caching & Multiple DB connection support
 64 | 
 65 | 2.00 - Re-factored **ezsql** for Oracle, mySQL & SQLite
 66 | 
 67 |         - DB Object is no longer initialized by default
 68 |           (makes it easier to use multiple connections)
 69 | 
 70 |         - Core **ezsql** functions have been separated from DB
 71 |           specific functions (makes it easier to add new databases)
 72 | 
 73 |         - Errors are being piped through trigger_error
 74 |           (using standard PHP error logging)
 75 | 
 76 |         - Abstracted error messages (enabling future translation)
 77 | 
 78 |         - Upgraded $db->query error return functionality
 79 | 
 80 |         - Added $db->systdate function to abstract mySQL NOW()
 81 |           and Oracle SYSDATE
 82 | 
 83 |         Note: For other DB Types please use version 1.26
 84 | 
 85 | 1.26 - Update (All)
 86 | 
 87 |         - Fixed the pesky regular expression that tests for
 88 |           an insert/update etc. Now it works even for the most
 89 |           weirdly formatted queries! (thx dille)
 90 | 
 91 | 1.25 - Update (mySQL/Oracle)
 92 | 
 93 |         - Optimise $db->query function in both mySQL and Oracle versions.
 94 |           Now the return value is working 'as expected' in ALL cases so you
 95 |           are always safe using:
 96 | 
 97 |           if ( $db->query("some query") )
 98 | 
 99 |           No matter if an insert or a select.
100 | 
101 |           In the case of insert/update the return value is based on the
102 |           number of rows affected (used to be insert id which is
103 |           not valid for an update)
104 | 
105 |           In the case of select the return value is based on number of
106 |           rows returned.
107 | 
108 |           Thx Bill Bruggemeyer :)
109 | 
110 | 1.24 - Update (Docs)
111 | 
112 |         - Now includes tutorial for using EZ Results with Smarty
113 |           templating engine - thx Steve Warwick
114 | 
115 | 1.23 - Update (All PHP versions)
116 | 
117 |         - Fixed the age old problem of returning false on
118 |           successful insert. $db->query()now returns the insert_id
119 |           if there was a successful insert or false if not. Sorry
120 |           that this took so long to fix!
121 | 
122 |           Version Affected: mySQL/Porgress/ms-sql/sqlite
123 | 
124 |         - Added new variable $db->debug_all
125 | 
126 |           By default it is set to false but if you change it
127 |           to true. i.e.
128 | 
129 |           include_once "ez_sql.php";
130 |           $db->debug_all = true;
131 | 
132 |           Then it will print out each and every query and all
133 |           of the results that your script creates.
134 | 
135 |           Very useful if you want to follow the entire logic
136 |           path of what ALL your queries are doing, but can't
137 |           be bothered to put $db->debug() statements all over
138 |           the place!
139 | 
140 |         Update (Postgress SQL Version)
141 | 
142 |          - Our old friend Tom De Bruyne as updated the postgress
143 |            version.
144 | 
145 |            1) It now works without throwing errors (also thanks Geert Nijpels)
146 | 
147 |            2) It now, in theory, returns $this->insert_id after an insert.
148 | 
149 | 
150 | 1.22 - Update (All PHP versions)
151 | 
152 |           - Added new variable $db->num_queries it keeps track
153 |             of exactly how many 'real' (not cached) queries were
154 |             executed (using **ezsql**) during the lifetime of one script.
155 |             Useful for debugging and optimizing.
156 | 
157 |           - Put a white table behind the vardump output so that
158 |             it doesn't get lost on dark websites.
159 | 
160 | 1.21 - Update (All Versions)
161 | 
162 |         - Now 'replace' really does return an insert id..
163 |           (the 1.19 fix did not complete the job. Doh!)
164 | 
165 | 1.20 - Update (New Version)
166 | 
167 |         - C++ SQLite version added. Look at ez_demo.cpp.
168 |           (thanks Brennan Falkner)
169 | 
170 | 1.19 - Update (All Versions)
171 | 
172 | - Fixed bug where any string containing the word 'insert',
173 |   'delete' or 'update' (where those words were not the actual
174 |   query) was causing unexpected results (thx Simon Willison).
175 | 
176 |   The fix was to alter the regular expression to only match
177 |   queries containing those words at the beginning of the query
178 |   (with optional whitespace allowed before the words)
179 | 
180 |   i.e.
181 | 
182 |   THIS:    preg_match("/$word /", strtolower($query))
183 |   TO THIS: preg_match("/^\\s*$word /", strtolower($query))
184 | 
185 |   - Added new sql word 'replace' to the above match pattern
186 |     so that the $db->insert_id would be also be populated
187 |     on 'replace' queries (thx Rolf Dahl)
188 | 
189 | 1.18 - Update (All Versions)
190 | 
191 | - Added new SQLite version (thanks Brennan Falkner)
192 | 
193 | - Fixed new bug that was introduced with bug fix 1.14
194 |   false was being returned on successful insert update etc.
195 |   now it is true
196 | 
197 | 1.17 - Update (All Versions)
198 | 
199 | - New MS-SQL version added (thanks to Tom De Bruyne)
200 | - Made the donation request 'less annoying' by making it more subtle!
201 | 
202 | 1.16 - Update (All Versions)
203 | 
204 | - Added new function $db->escape()
205 |   Formats a string correctly to stop accidental
206 |   mal formed queries under all PHP conditions
207 | 
208 | 1.15 - Bug fixes
209 | 
210 | - (Postgres)
211 |   $this->result = false; was in the wrong place.
212 |   Fixed! Thanks (Carlos Camiña García)
213 | 
214 | - (all versions)
215 |   Pesky get_var was still returning null instead of 0 in
216 |   certain cases. Bug fix of !== suggested by Osman
217 | 
218 | 1.14 - Bug fixes
219 | 
220 | - (all versions)
221 |   Added !='' into the conditional return of get_var.
222 |   because if the result was the number 0 it was not returning anything
223 | 
224 | - (mySQL / Interbase / Postgres)
225 |   Added $this->result = false; if insert / update / delete
226 |   because it was causing mysql retrieval errors that no one
227 |   knew about due to the @ signs.
228 | 
229 | 1.13 - Update (All Versions)
230 | 
231 | - Swapped 2nd and 3rd argument order.
232 | - From.. get_row(query, int row offset, output type)
233 | - To.... get_row(query, output type, int row offset)
234 | 
235 | 1.12 - Update (All Versions)
236 | 
237 | - Tweaked the new hide/show error code
238 | - Made sure the $this->show_errors was always initialized
239 | - $db->query() function now returns false if there was an SQL error.
240 |   So that you can now do the following when you hide errors.
241 | 
242 |   if ( $db->query("BAD SYNTAX") )
243 |   {
244 |   	echo "Bad Query";
245 |   }
246 | 
247 | 1.11 - Update (All Versions)
248 | 
249 | - added $db->hide_errors();
250 | - added $db->show_errors();
251 | - added global array $EZSQL_ERROR;
252 | 
253 | 1.10 - Fix (mySQL)
254 | 
255 | - Insist that mysql_insert_id(); uses $this->dbh.
256 | 
257 | 1.09 - Bug Fix
258 | 
259 | - Oracle version had the wrong number of parameters in the
260 |   $db = new db(etc,etc,etc,etc) part.
261 | 
262 | - Also added var $vardump_called; to all versions.
263 | 
264 | 1.08 - Bug Fix
265 | 
266 | - Michael fixed the select function in PostgreSQL version.
267 | 
268 | 1.07 - Bug Fix
269 | 
270 | - Added var $debug_called; to all versions.
271 | 
272 | 1.06 - Update
273 | 
274 | - Fixed Bug In Oracle Version where an insert was
275 |   causing an error with OCIFetch
276 | - New PostgreSQL Version Added by Michael Paesold (mpaesold@gmx.at)
277 | 
278 | 1.05 - Bug Fix (mySQL)
279 | 
280 | - Removed repeated piece of code.
281 | 
282 | 1.04 - Update
283 | 
284 | - $db->num_rows - variable added (All Versions)
285 | - $db->rows_affected - variable added ( mySQL / Oracle )
286 | - New InterBase/FireBase Version Added by LLCedar (llceder@wxs.nl)
287 | 
288 | 1.03 - Update (All Versions)
289 | 
290 | Enhancements to vardump..
291 | 
292 | - Added display variable type
293 | - If no value display No Value / False
294 | - Added this readme file
295 | 
296 | 1.02 - Update (mySQL version)
297 | 
298 | - Added $db->insert_id to
299 | 
300 | 1.01 - New Version
301 | 
302 | - Oracle 8 Version as below
303 | 
304 | 1.00 - Initial Release
305 | 
306 | Functions..
307 | 
308 | - $db->get_results - get multiple row result set from the database (or previously cached results)
309 | - $db->get_row -- get one row from the database (or previously cached results)
310 | - $db->get_col - get one column from query (or previously cached results) based on column offset
311 | - $db->get_var -- get one variable, from one row, from the database (or previously cached results)
312 | - $db->query -- send a query to the database (and if any results, cache them)
313 | - $db->debug - print last sql query and returned results (if any)
314 | - $db->vardump - print the contents and structure of any variable
315 | - $db->select -- select a new database to work with
316 | - $db->get_col_info - get information about one or all columns such as column name or type
317 | - $db = new db -- Initiate new db object.


--------------------------------------------------------------------------------
/CONTRIBUTORS.md:
--------------------------------------------------------------------------------
 1 | **ezsql** *Contributors*
 2 | ============================================
 3 | 
 4 | * **[Justin Vincent](http://twitter.com/justinvincent)**
 5 |   > jv@jvmultimedia.com
 6 |   * Author: ezsql class - *ez_SQL_core, mySQL, PDO, PostgreSQL, Cubrid, Oracle8_9*
 7 |     Contact Info :
 8 |     * Follow me on twitter:
 9 |         http://twitter.com/justinvincent
10 |     * Check out my podcast TechZing where we talk about tech and tech startups:
11 |         http://techzinglive.com
12 | 
13 | * **[Stefanie Janine Stoelting](https://stefanie-stoelting.de)**
14 |   > mail@stefanie-stoelting.de
15 |   * Author: 
16 |     * *ezsql version 3.00*
17 |     * *oracleTNS*
18 |     * *phpunit tests*
19 |     * *RecordSet - for working with query results*
20 | 
21 | * **davisjw**
22 |   > davisjw@gmail.com
23 |   * Author: ezsql class - *Sqlserver*
24 | 
25 | * **Silvio Wanka**
26 |   * Author: ezsql class - *sqlite3*
27 | 
28 | ----
29 | 
30 | ____L. Stubbs____
31 | 
32 |   > lstubbs@techno.express
33 | 
34 | * Author/Maintainer:  
35 |   * ezsql version 3
36 |   * In Development version *4.0*
37 |   * *ezQuery, ezFunctions, ezSchema*
38 | 
39 | ----
40 | 
41 | **[Full contributors list.](https://github.com/ezsql/ezsql/contributors)**
42 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                    GNU LESSER GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 | 
  9 |   This version of the GNU Lesser General Public License incorporates
 10 | the terms and conditions of version 3 of the GNU General Public
 11 | License, supplemented by the additional permissions listed below.
 12 | 
 13 |   0. Additional Definitions.
 14 | 
 15 |   As used herein, "this License" refers to version 3 of the GNU Lesser
 16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU
 17 | General Public License.
 18 | 
 19 |   "The Library" refers to a covered work governed by this License,
 20 | other than an Application or a Combined Work as defined below.
 21 | 
 22 |   An "Application" is any work that makes use of an interface provided
 23 | by the Library, but which is not otherwise based on the Library.
 24 | Defining a subclass of a class defined by the Library is deemed a mode
 25 | of using an interface provided by the Library.
 26 | 
 27 |   A "Combined Work" is a work produced by combining or linking an
 28 | Application with the Library.  The particular version of the Library
 29 | with which the Combined Work was made is also called the "Linked
 30 | Version".
 31 | 
 32 |   The "Minimal Corresponding Source" for a Combined Work means the
 33 | Corresponding Source for the Combined Work, excluding any source code
 34 | for portions of the Combined Work that, considered in isolation, are
 35 | based on the Application, and not on the Linked Version.
 36 | 
 37 |   The "Corresponding Application Code" for a Combined Work means the
 38 | object code and/or source code for the Application, including any data
 39 | and utility programs needed for reproducing the Combined Work from the
 40 | Application, but excluding the System Libraries of the Combined Work.
 41 | 
 42 |   1. Exception to Section 3 of the GNU GPL.
 43 | 
 44 |   You may convey a covered work under sections 3 and 4 of this License
 45 | without being bound by section 3 of the GNU GPL.
 46 | 
 47 |   2. Conveying Modified Versions.
 48 | 
 49 |   If you modify a copy of the Library, and, in your modifications, a
 50 | facility refers to a function or data to be supplied by an Application
 51 | that uses the facility (other than as an argument passed when the
 52 | facility is invoked), then you may convey a copy of the modified
 53 | version:
 54 | 
 55 |    a) under this License, provided that you make a good faith effort to
 56 |    ensure that, in the event an Application does not supply the
 57 |    function or data, the facility still operates, and performs
 58 |    whatever part of its purpose remains meaningful, or
 59 | 
 60 |    b) under the GNU GPL, with none of the additional permissions of
 61 |    this License applicable to that copy.
 62 | 
 63 |   3. Object Code Incorporating Material from Library Header Files.
 64 | 
 65 |   The object code form of an Application may incorporate material from
 66 | a header file that is part of the Library.  You may convey such object
 67 | code under terms of your choice, provided that, if the incorporated
 68 | material is not limited to numerical parameters, data structure
 69 | layouts and accessors, or small macros, inline functions and templates
 70 | (ten or fewer lines in length), you do both of the following:
 71 | 
 72 |    a) Give prominent notice with each copy of the object code that the
 73 |    Library is used in it and that the Library and its use are
 74 |    covered by this License.
 75 | 
 76 |    b) Accompany the object code with a copy of the GNU GPL and this license
 77 |    document.
 78 | 
 79 |   4. Combined Works.
 80 | 
 81 |   You may convey a Combined Work under terms of your choice that,
 82 | taken together, effectively do not restrict modification of the
 83 | portions of the Library contained in the Combined Work and reverse
 84 | engineering for debugging such modifications, if you also do each of
 85 | the following:
 86 | 
 87 |    a) Give prominent notice with each copy of the Combined Work that
 88 |    the Library is used in it and that the Library and its use are
 89 |    covered by this License.
 90 | 
 91 |    b) Accompany the Combined Work with a copy of the GNU GPL and this license
 92 |    document.
 93 | 
 94 |    c) For a Combined Work that displays copyright notices during
 95 |    execution, include the copyright notice for the Library among
 96 |    these notices, as well as a reference directing the user to the
 97 |    copies of the GNU GPL and this license document.
 98 | 
 99 |    d) Do one of the following:
100 | 
101 |        0) Convey the Minimal Corresponding Source under the terms of this
102 |        License, and the Corresponding Application Code in a form
103 |        suitable for, and under terms that permit, the user to
104 |        recombine or relink the Application with a modified version of
105 |        the Linked Version to produce a modified Combined Work, in the
106 |        manner specified by section 6 of the GNU GPL for conveying
107 |        Corresponding Source.
108 | 
109 |        1) Use a suitable shared library mechanism for linking with the
110 |        Library.  A suitable mechanism is one that (a) uses at run time
111 |        a copy of the Library already present on the user's computer
112 |        system, and (b) will operate properly with a modified version
113 |        of the Library that is interface-compatible with the Linked
114 |        Version.
115 | 
116 |    e) Provide Installation Information, but only if you would otherwise
117 |    be required to provide such information under section 6 of the
118 |    GNU GPL, and only to the extent that such information is
119 |    necessary to install and execute a modified version of the
120 |    Combined Work produced by recombining or relinking the
121 |    Application with a modified version of the Linked Version. (If
122 |    you use option 4d0, the Installation Information must accompany
123 |    the Minimal Corresponding Source and Corresponding Application
124 |    Code. If you use option 4d1, you must provide the Installation
125 |    Information in the manner specified by section 6 of the GNU GPL
126 |    for conveying Corresponding Source.)
127 | 
128 |   5. Combined Libraries.
129 | 
130 |   You may place library facilities that are a work based on the
131 | Library side by side in a single library together with other library
132 | facilities that are not Applications and are not covered by this
133 | License, and convey such a combined library under terms of your
134 | choice, if you do both of the following:
135 | 
136 |    a) Accompany the combined library with a copy of the same work based
137 |    on the Library, uncombined with any other library facilities,
138 |    conveyed under the terms of this License.
139 | 
140 |    b) Give prominent notice with the combined library that part of it
141 |    is a work based on the Library, and explaining where to find the
142 |    accompanying uncombined form of the same work.
143 | 
144 |   6. Revised Versions of the GNU Lesser General Public License.
145 | 
146 |   The Free Software Foundation may publish revised and/or new versions
147 | of the GNU Lesser General Public License from time to time. Such new
148 | versions will be similar in spirit to the present version, but may
149 | differ in detail to address new problems or concerns.
150 | 
151 |   Each version is given a distinguishing version number. If the
152 | Library as you received it specifies that a certain numbered version
153 | of the GNU Lesser General Public License "or any later version"
154 | applies to it, you have the option of following the terms and
155 | conditions either of that published version or of any later version
156 | published by the Free Software Foundation. If the Library as you
157 | received it does not specify a version number of the GNU Lesser
158 | General Public License, you may choose any version of the GNU Lesser
159 | General Public License ever published by the Free Software Foundation.
160 | 
161 |   If the Library as you received it specifies that a proxy can decide
162 | whether future versions of the GNU Lesser General Public License shall
163 | apply, that proxy's public statement of acceptance of any version is
164 | permanent authorization for you to choose that version for the
165 | Library.
166 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # **ezsql**
  2 | 
  3 | [![Windows](https://github.com/ezSQL/ezsql/workflows/Windows/badge.svg)](https://github.com/ezSQL/ezsql/actions?query=workflow%3AWindows)
  4 | [![Linux](https://github.com/ezSQL/ezsql/workflows/Linux/badge.svg)](https://github.com/ezSQL/ezsql/actions?query=workflow%3ALinux)
  5 | [![macOS](https://github.com/ezSQL/ezsql/workflows/macOS/badge.svg)](https://github.com/ezSQL/ezsql/actions?query=workflow%3AmacOS)
  6 | [![codecov](https://codecov.io/gh/ezSQL/ezSQL/branch/master/graph/badge.svg)](https://codecov.io/gh/ezSQL/ezSQL)
  7 | [![Codacy Badge](https://api.codacy.com/project/badge/Grade/aad1f6aaaaa14f60933e75615da900b8)](https://www.codacy.com/app/techno-express/ezsql?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=ezSQL/ezsql&amp;utm_campaign=Badge_Grade)
  8 | [![Maintainability](https://api.codeclimate.com/v1/badges/6f6107f25e9de7bf4272/maintainability)](https://codeclimate.com/github/ezSQL/ezsql/maintainability)
  9 | [![Total Downloads](https://poser.pugx.org/ezsql/ezsql/downloads)](https://packagist.org/packages/ezsql/ezsql)
 10 | 
 11 | ***A class to make it very easy to deal with database connections.***
 12 | *An universal interchangeable **CRUD** system.*
 13 | 
 14 | This is [__Version 5__](https://github.com/ezSQL/ezsql/tree/v5) which will break users of **version 4**.
 15 | 
 16 | Mainly by:
 17 | 
 18 | - The use of `namespace` in the `global` functions **ezFunctions.php** file.
 19 |     Usage of the **global** functions will require the user to begin a `.php` file something like:
 20 | 
 21 |     ```php
 22 |     use function ezsql\functions\where;
 23 |     // Or
 24 |     use function ezsql\functions\{
 25 |         getInstance,
 26 |         selecting,
 27 |         inserting,
 28 |     };
 29 |     ```
 30 | 
 31 | - Class properties that was accessible by magic methods `get/set`, now PSR 1 camelCase.
 32 | - Renamed `select` of `ez_mysqli` to `dbSelect`.
 33 | - Renamed class method and behavior of `selecting` to `select`.
 34 | - `selecting`, and new `inserting` methods, can be called without table name, only the other necessary parameters:
 35 |     - The table *name* with *prefix*, can be preset/stored with methods `tableSetup(name, prefix), or setTable(name), setPrefix(append)`, if called without presetting, `false` is returned.
 36 |     - This **feature** will be added to **all** database *CRUD* access methods , each method name will have an `ing` ending added.
 37 | - Removed global functions where `table` name passed in, use functions using preset table names ending with `ing`.
 38 | - renamed cleanInput to clean_string
 39 | - renamed createCertificate to create_certificate
 40 | - added global get_results to return result sets in different formats
 41 | 
 42 | [__Version 4__](https://github.com/ezSQL/ezsql/tree/v4) has many modern programming practices in which will break users of version 3.
 43 | 
 44 | [__Version 3__](https://github.com/ezSQL/ezsql/tree/v3) broke version 2.1.7 in one major way, it required *PHP 5.6*. Which drop mysql extension support, other than that, nothing as far using the library was changed, only additional features.
 45 | 
 46 | This library has an `Database` class, an combination of the [Factory](https://en.wikipedia.org/wiki/Factory_method_pattern) pattern with an [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection) container hosting. This library now is following many OOP principles, one in which, the methods properties public access has been removed. This library also following PSR-2, PSR-4, PSR-11 conventions, and mostly PSR-1, that's still an work in progress.
 47 | 
 48 | * More Todo...
 49 | 
 50 | For an full overview see [documentation Wiki](https://github.com/ezSQL/ezsql/wiki/Documentation), which is not completely finish.
 51 | 
 52 | ## Installation
 53 | 
 54 |     composer require ezsql/ezsql
 55 | 
 56 | ## Usage
 57 | 
 58 | ```php
 59 | require 'vendor/autoload.php';
 60 | 
 61 | // **** is one of mysqli, pgsql, sqlsrv, sqlite3, or Pdo.
 62 | use ezsql\Database;
 63 | 
 64 | $db = Database::initialize('****', [$dsn_path_user, $password, $database, $other_settings], $optional_tag);
 65 | 
 66 | // Is same as:
 67 | use ezsql\Config;
 68 | use ezsql\Database\ez_****;
 69 | 
 70 | $settings = new Config('****', [$dsn_path_user, $password, $database, $other_settings]);
 71 | 
 72 | $db = new ez_****($settings);
 73 | ```
 74 | 
 75 | This library will assume the developer is using some sort of IDE with intellisense enabled. The comments/doc-block area will hold any missing documentations. For additional examples see __phpunit__ tests, The tests are fully functional integration tests, meaning the are live database tests, no mocks.
 76 | 
 77 | The following has been added since version 2.1.7.
 78 | 
 79 | ___General Methods___
 80 | 
 81 |     to_string($arrays, $separation = ',');
 82 |     clean($string);
 83 |     create_cache(string $path = null);
 84 |     secureSetup(string $key = 'certificate.key',
 85 |         string $cert = 'certificate.crt',
 86 |         string $ca = 'cacert.pem',
 87 |         string $path = '.'._DS
 88 |     );
 89 |     secureReset();
 90 |     create_certificate(string $privatekeyFile = certificate.key,
 91 |         string $certificateFile = certificate.crt,
 92 |         string $signingFile = certificate.csr,
 93 |         string $ssl_path = null, array $details = [commonName => localhost]
 94 |     );
 95 | 
 96 | ___Shortcut Table Methods___
 97 | 
 98 |     create(string $table = null, ...$schemas);// $schemas requires... column()
 99 |     column(string $column = null, string $type = null, ...$args);
100 |     primary(string $primaryName, ...$primaryKeys);
101 |     index(string $indexName, ...$indexKeys);
102 |     drop(string $table);
103 | 
104 | Example
105 | 
106 | ```php
107 | // Creates an database table
108 | create('profile',
109 |     // and with database column name, datatype
110 |     // data types are global CONSTANTS
111 |     // SEQUENCE|AUTO is placeholder tag, to be replaced with the proper SQL drivers auto number sequencer word.
112 |     column('id', INTR, 11, AUTO, PRIMARY), // mysqli
113 |     column('name', VARCHAR, 50, notNULL),
114 |     column('email', CHAR, 25, NULLS),
115 |     column('phone', TINYINT)
116 | );
117 | ```
118 | 
119 | ---
120 | 
121 |     innerJoin(string $leftTable = null, string $rightTable = null,
122 |         string $leftColumn = null, string $rightColumn = null, string $tableAs = null, $condition = EQ);
123 | 
124 |     leftJoin(string $leftTable = null, string $rightTable = null,
125 |         string $leftColumn = null, string $rightColumn = null, string $tableAs = null, $condition = EQ);
126 | 
127 |     rightJoin(string $leftTable = null, string $rightTable = null,
128 |         string $leftColumn = null, string $rightColumn = null, string $tableAs = null, $condition = EQ);
129 | 
130 |     fullJoin(string $leftTable = null, string $rightTable = null,
131 |         string $leftColumn = null, string $rightColumn = null, string $tableAs = null, $condition = EQ);
132 | ---
133 | 
134 | ```php
135 | prepareOn(); // When activated will use prepare statements for all shortcut SQL Methods calls.
136 | prepareOff(); // When off shortcut SQL Methods calls will use vendors escape routine instead. This is the default behavior.
137 | ```
138 | 
139 | ### Shortcut SQL Methods
140 | 
141 | * `having(...$having);`
142 | * `groupBy($groupBy);`
143 | * `union(string $table = null, $columnFields = '*', ...$conditions);`
144 | * `unionAll(string $table = null, $columnFields = '*', ...$conditions);`
145 | * `orderBy($orderBy, $order);`
146 | * `limit($numberOf, $offset = null)`
147 | * `where( ...$whereConditions);`
148 | * `select(string $table = null, $columnFields = '*', ...$conditions);`
149 | * `create_select(string $newTable, $fromColumns, $oldTable = null, ...$conditions);`
150 | * `select_into(string $newTable, $fromColumns, $oldTable = null, ...$conditions);`
151 | * `update(string $table = null, $keyAndValue, ...$whereConditions);`
152 | * `delete(string $table = null, ...$whereConditions);`
153 | * `replace(string $table = null, $keyAndValue);`
154 | * `insert(string $table = null, $keyAndValue);`
155 | * `create(string $table = null, ...$schemas);`
156 | * `drop(string $table = null);`
157 | * `alter(string $table = null, ...$alteringSchema);`
158 | * `insert_select(string $toTable = null, $toColumns = '*', $fromTable = null, $fromColumns = '*', ...$conditions);`
159 | 
160 | ```php
161 | // The variadic ...$whereConditions, and ...$conditions parameters,
162 | //  represent the following global functions.
163 | // They are comparison expressions returning an array with the given arguments,
164 | //  the last arguments of _AND, _OR, _NOT, _andNOT will combine expressions
165 | eq('column', $value, _AND), // combine next expression
166 | neq('column', $value, _OR), // will combine next expression again
167 | ne('column', $value), // the default is _AND so will combine next expression
168 | lt('column', $value)
169 | lte('column', $value)
170 | gt('column', $value)
171 | gte('column', $value)
172 | isNull('column')
173 | isNotNull('column')
174 | like('column', '_%?')
175 | notLike('column', '_%?')
176 | in('column', ...$value)
177 | notIn('column', ...$value)
178 | between('column', $value, $value2)
179 | notBetween('column', $value, $value2)
180 | // The above should be used within the where( ...$whereConditions) clause
181 | // $value will protected by either using escape or prepare statement
182 | ```
183 | 
184 | ```php
185 | // To allow simple grouping of basic $whereConditions,
186 | // wrap the following around a group of the above comparison
187 | // expressions within the where( ...$whereConditions) clause
188 | grouping( eq(key, value, combiner ), eq(key, value, combiner ) )
189 | // The above will wrap beginning and end grouping in a where statement
190 | // where required to break down your where clause.
191 | ```
192 | 
193 | ```php
194 | // Note: The usage of this method will require the user/developer to check
195 | // if `query_string` or `param_array` is valid.
196 | //
197 | // This is really an `private` internal method for other shortcut methods,
198 | // it's made public for `class development` usage only.
199 | //
200 | //
201 | // Supply the the whole `query` string, and placing '?' within, with the same number of arguments in an array.
202 | // It will then determine arguments type, execute, and return results.
203 | query_prepared(string $query_string, array $param_array);
204 | // You will need to call this method to get last successful query result.
205 | // It wll return an object array.
206 | queryResult();
207 | ```
208 | 
209 | #### Example for using prepare statements indirectly, with above shortcut SQL methods
210 | 
211 | ```php
212 | // To get all shortcut SQL methods calls to use prepare statements
213 | $db->prepareOn(); // This needs to be called at least once at instance creation
214 | 
215 | $values = [];
216 | $values['name'] = $user;
217 | $values['email'] = $address;
218 | $values['phone'] = $number;
219 | $db->insert('profile', $values);
220 | $db->insert('profile', ['name' => 'john john', 'email' => 'john@email', 'phone' => 123456]);
221 | 
222 | // returns result set given the table name, column fields, and ...conditions
223 | $result = $db->select('profile', 'phone', eq('email', $email), between('id', 1, $values));
224 | 
225 | foreach ($result as $row) {
226 |     echo $row->phone;
227 | }
228 | 
229 | $result = $db->select('profile', 'name, email',
230 |     // Conditionals can also be called, stacked with other functions like:
231 |     //  innerJoin(), leftJoin(), rightJoin(), fullJoin()
232 |     //      as (leftTable, rightTable, leftColumn, rightColumn, tableAs, equal condition),
233 |     //  where( eq( columns, values, _AND ), like( columns, _d ) ),
234 |     //  groupBy( columns ),
235 |     //  having( between( columns, values1, values2 ) ),
236 |     //  orderBy( columns, desc ),
237 |     //  limit( numberOfRecords, offset ),
238 |     //  union(table, columnFields, conditions),
239 |     //  unionAll(table, columnFields, conditions)
240 |     $db->where( eq('phone', $number, _OR), neq('id', 5) ),
241 |     //  another way: where( array(key, operator, value, combine, combineShifted) );
242 |     //  or as strings double spaced: where( "key  operator  value  combine  combineShifted" );
243 |     $db->orderBy('name'),
244 |     $db->limit(1)
245 | );
246 | 
247 | foreach ($result as $row) {
248 |     echo $row->name.' '.$row->email;
249 | }
250 | 
251 | // To get results in `JSON` format
252 | $json = get_results(JSON, $db);
253 | ```
254 | 
255 | #### Example for using prepare statements directly, no shortcut SQL methods used
256 | 
257 | ```php
258 | $db->query_prepared('INSERT INTO profile( name, email, phone) VALUES( ?, ?, ? );', [$user, $address, $number]);
259 | 
260 | $db->query_prepared('SELECT name, email FROM profile WHERE phone = ? OR id != ?', [$number, 5]);
261 | $result = $db->queryResult(); // the last query that has results are stored in `lastResult` protected property
262 | // Or for results in other formats use the global function, will use global database instance if no `$db` supplied
263 | $result = get_results(/* OBJECT|ARRAY_A|ARRAY_N|JSON */, $db); // Defaults to `OBJECT`
264 | 
265 | foreach ($result as $row) {
266 |     echo $row->name.' '.$row->email;
267 | }
268 | ```
269 | 
270 | Most of shortcut methods have counter **global** _functions_ available.
271 | They can only be access by beginning your `.php` file like:
272 | 
273 | ```php
274 | use function ezsql\functions\functionBelow;
275 | // Or as here, a complete list.
276 | use function ezsql\functions\{
277 |     database,
278 |     mysqlInstance,
279 |     pgsqlInstance,
280 |     mssqlInstance,
281 |     sqliteInstance,
282 |     pdoInstance,
283 |     tagInstance,
284 |     setInstance,
285 |     getInstance,
286 |     clearInstance,
287 |     get_vendor,
288 | ///
289 |     to_string,
290 |     clean_string,
291 |     is_traversal,
292 |     sanitize_path,
293 |     create_certificate,
294 | ///
295 |     column,
296 |     primary,
297 |     foreign,
298 |     unique,
299 |     index,
300 |     addColumn,
301 |     dropColumn,
302 |     changingColumn,
303 | ///
304 |     eq,
305 |     neq,
306 |     ne,
307 |     lt,
308 |     lte,
309 |     gt,
310 |     gte,
311 |     isNull,
312 |     isNotNull,
313 |     like,
314 |     in,
315 |     notLike,
316 |     notIn,
317 |     between,
318 |     notBetween,
319 | ///
320 |     where,
321 |     grouping,
322 |     groupBy,
323 |     having,
324 |     orderBy,
325 |     limit,
326 |     innerJoin,
327 |     leftJoin,
328 |     rightJoin,
329 |     fullJoin,
330 |     union,
331 |     unionAll,
332 | ///
333 |     creating,
334 |     deleting,
335 |     dropping,
336 |     replacing,
337 |     selecting,
338 |     inserting,
339 |     altering,
340 |     get_results,
341 |     table_setup,
342 |     set_table,
343 |     set_prefix,
344 |     select_into,
345 |     insert_select,
346 |     create_select,
347 | };
348 | ```
349 | 
350 | For the functions **usage/docs** see [ezFunctions.php](https://github.com/ezSQL/ezsql/blob/v5/lib/ezFunctions.php).
351 | 
352 | ## For Authors and **[Contributors](https://github.com/ezSQL/ezsql/blob/master/CONTRIBUTORS.md)**
353 | 
354 | ## Contributing
355 | 
356 | Contributions are encouraged and welcome; I am always happy to get feedback or pull requests on Github :) Create [Github Issues](https://github.com/ezSQL/ezsql/issues) for bugs and new features and comment on the ones you are interested in.
357 | 
358 | ## License
359 | 
360 | **ezsql** is open-sourced software licensed originally under (LGPL-3.0), and the addon parts under (MIT).
361 | 


--------------------------------------------------------------------------------
/_config.yml:
--------------------------------------------------------------------------------
 1 | plugins:
 2 |   - jekyll-relative-links
 3 | relative_links:
 4 |   enabled: true
 5 |   collections: true
 6 | include:
 7 |   - WIKI.md
 8 |   - README.md
 9 |   - CONTRIBUTORS.md
10 |   - LICENSE.md
11 |   - CODE_OF_CONDUCT.md
12 |   - ISSUE_TEMPLATE.md
13 |   - PULL_REQUEST_TEMPLATE.md
14 | 
15 | theme: jekyll-theme-architect


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "ezsql/ezsql",
 3 |     "description": "Advance database access library. Make interacting with a database ridiculously easy. An universal interchangeable CRUD system.",
 4 |     "keywords": [
 5 |         "crud",
 6 |         "dba",
 7 |         "mysql",
 8 |         "mysqli",
 9 |         "postgresql",
10 |         "mssql",
11 |         "sqlsrv",
12 |         "sqlserver",
13 |         "pdo",
14 |         "sqlite",
15 |         "sqlite3",
16 |         "database",
17 |         "abstraction",
18 |         "sql"
19 |     ],
20 |     "license": [
21 |         "LGPL-3.0-or-later",
22 |         "MIT"
23 |     ],
24 |     "authors": [
25 |         {
26 |             "name": "Justin Vincent",
27 |             "email": "webmaster@justinvincent.com"
28 |         },
29 |         {
30 |             "name": "Stefanie Janine Stoelting",
31 |             "email": "mail@stefanie-stoelting.de"
32 |         },
33 |         {
34 |             "name": "l. stubbs",
35 |             "email": "lstubbs@techno.express"
36 |         }
37 |     ],
38 |     "support": {
39 |         "issues": "https://github.com/ezSQL/ezSQL/issues"
40 |     },
41 |     "require": {
42 |         "php": ">7.1",
43 |         "psr/container": "^1.0"
44 |     },
45 |     "provide": {
46 |         "psr/container-implementation": "1.0"
47 |     },
48 |     "autoload": {
49 |         "files": [
50 |             "lib/Constants.php",
51 |             "lib/ezFunctions.php"
52 |         ],
53 |         "psr-4": {
54 |             "ezsql\\": "lib/"
55 |         }
56 |     },
57 |     "require-dev": {
58 |         "phpunit/phpunit": "^6 | ^7 | ^8"
59 |     },
60 |     "autoload-dev": {
61 |         "psr-4": {
62 |             "ezsql\\Tests\\": "tests/"
63 |         }
64 |     },
65 |     "scripts": {
66 |         "test": "phpunit --bootstrap vendor/autoload.php tests"
67 |     },
68 |     "minimum-stability": "stable"
69 | }
70 | 


--------------------------------------------------------------------------------
/lib/Config.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ezsql;
  6 | 
  7 | use Exception;
  8 | use ezsql\ConfigAbstract;
  9 | use ezsql\ConfigInterface;
 10 | 
 11 | class Config extends ConfigAbstract implements ConfigInterface
 12 | {
 13 |     public function __construct(string $driver = '', array $arguments = null)
 14 |     {
 15 |         $sql = \strtolower($driver);
 16 |         if (!\array_key_exists($sql, \VENDOR) || empty($arguments)) {
 17 |             throw new Exception(\MISSING_CONFIGURATION);
 18 |         } else {
 19 |             $this->setDriver($sql);
 20 |             if ($sql == \Pdo) {
 21 |                 $this->setupPdo($arguments);
 22 |             } elseif ($sql == \POSTGRESQL) {
 23 |                 $this->setupPgsql($arguments);
 24 |             } elseif ($sql == \SQLSRV) {
 25 |                 $this->setupSqlsrv($arguments);
 26 |             } elseif ($sql == \MYSQLI) {
 27 |                 $this->setupMysqli($arguments);
 28 |             } elseif ($sql == \SQLITE3) {
 29 |                 $this->setupSqlite3($arguments);
 30 |             }
 31 |         }
 32 |     }
 33 | 
 34 |     public static function initialize(string $driver = '',  array $arguments = null)
 35 |     {
 36 |         return new self($driver, $arguments);
 37 |     }
 38 | 
 39 |     private function setupMysqli($args)
 40 |     {
 41 |         if (!\function_exists('mysqli_connect'))
 42 |             throw new Exception('<b>Fatal Error:</b> ez_mysql requires mySQLi Lib to be compiled and or linked in to the PHP engine');
 43 | 
 44 |         if (\count($args) >= 3) {
 45 |             $this->setUser($args[0]);
 46 |             $this->setPassword($args[1]);
 47 |             $this->setName($args[2]);
 48 |             $this->setHost(empty($args[3]) ? $this->getHost() : $args[3]);
 49 |             $this->setPort(empty($args[4]) ? '3306' : $args[4]);
 50 |             $charset = !empty($args[5]) ? $args[5] : '';
 51 |             $this->setCharset(empty($charset) ? $this->getCharset() : \strtolower(\str_replace('-', '', $charset)));
 52 |         } else
 53 |             throw new Exception(\MISSING_CONFIGURATION);
 54 |     }
 55 | 
 56 |     private function setupPdo($args)
 57 |     {
 58 |         if (!\class_exists('PDO'))
 59 |             throw new Exception('<b>Fatal Error:</b> ez_pdo requires PDO Lib to be compiled and or linked in to the PHP engine');
 60 |         if (\count($args) >= 3) {
 61 |             $this->setDsn($args[0]);
 62 |             $this->setUser($args[1]);
 63 |             $this->setPassword($args[2]);
 64 |             $this->setOptions(empty($args[3]) ? $this->getOptions() : $args[3]);
 65 |             $this->setIsFile(empty($args[4]) ? $this->getIsFile() : $args[4]);
 66 |         } else
 67 |             throw new Exception(\MISSING_CONFIGURATION);
 68 |     }
 69 | 
 70 |     private function setupSqlsrv($args)
 71 |     {
 72 |         if (!\function_exists('sqlsrv_connect'))
 73 |             throw new Exception('<b>Fatal Error:</b> ez_sqlsrv requires the php_sqlsrv.dll or php_pdo_sqlsrv.dll to be installed. Also enable MS-SQL extension in PHP.ini file ');
 74 | 
 75 |         if (\count($args) >= 3) {
 76 |             $this->setUser($args[0]);
 77 |             $this->setPassword($args[1]);
 78 |             $this->setName($args[2]);
 79 |             $this->setHost(empty($args[3]) ? $this->getHost() : $args[3]);
 80 |             $this->setToMssql(empty($args[4]) ? $this->getToMssql() : $args[4]);
 81 |         } else
 82 |             throw new Exception(\MISSING_CONFIGURATION);
 83 |     }
 84 | 
 85 |     private function setupPgsql($args)
 86 |     {
 87 |         if (!\function_exists('pg_connect'))
 88 |             throw new Exception('<b>Fatal Error:</b> ez_pgsql requires PostgreSQL Lib to be compiled and or linked in to the PHP engine');
 89 | 
 90 |         if (count($args) >= 3) {
 91 |             $this->setUser($args[0]);
 92 |             $this->setPassword($args[1]);
 93 |             $this->setName($args[2]);
 94 |             $this->setHost(empty($args[3]) ? $this->getHost() : $args[3]);
 95 |             $this->setPort(empty($args[4]) ? '5432' : $args[4]);
 96 |         } else
 97 |             throw new Exception(\MISSING_CONFIGURATION);
 98 |     }
 99 | 
100 |     private function setupSqlite3($args)
101 |     {
102 |         if (!\class_exists('SQLite3'))
103 |             throw new Exception('<b>Fatal Error:</b> ez_sqlite3 requires SQLite3 Lib to be compiled and or linked in to the PHP engine');
104 | 
105 |         if (\count($args) == 2) {
106 |             $this->setPath($args[0]);
107 |             $this->setName($args[1]);
108 |         } else
109 |             throw new Exception(\MISSING_CONFIGURATION);
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/lib/ConfigAbstract.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * Author:  Lawrence Stubbs <technoexpressnet@gmail.com>
  5 |  *
  6 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  7 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  8 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  9 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 10 |  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 11 |  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 12 |  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 13 |  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 14 |  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 15 |  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 16 |  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 17 |  *
 18 |  * This software consists of voluntary contributions made by many individuals
 19 |  * and is licensed under the MIT license.
 20 |  */
 21 | 
 22 | declare(strict_types=1);
 23 | 
 24 | namespace ezsql;
 25 | 
 26 | /**
 27 |  *
 28 |  * @method void setDriver($args);
 29 |  * Database Sql driver name
 30 |  * @method void setDsn($args);
 31 |  * The PDO connection parameter string, database server in the DSN parameters
 32 |  * @method void setUser($args);
 33 |  * Database user name
 34 |  * @method void setPassword($args);
 35 |  * Database password for the given user
 36 |  * @method void setName($args);
 37 |  * Database name
 38 |  * @method void setHost($args);
 39 |  * Host name or IP address
 40 |  * @method void setPort($args);
 41 |  * TCP/IP port of PostgreSQL/MySQL
 42 |  * @method void setCharset($args);
 43 |  * Database charset
 44 |  * @method void setOptions($args);
 45 |  * The PDO array for connection options, MySQL connection charset, for example
 46 |  * @method void setIsFile($args);
 47 |  * Check PDO for whether it is a file based database connection, for example to a SQLite
 48 |  * database file, or not
 49 |  * @method void setToMssql($args);
 50 |  * If we want to convert Queries in MySql syntax to MS-SQL syntax.
 51 |  * Yes, there are some differences in query syntax.
 52 |  * @method void setToMysql($args);
 53 |  * If we want to convert Queries in MySql syntax to MS-SQL syntax.
 54 |  * Yes, there are some differences in query syntax.
 55 |  * @method void setPath($args);
 56 |  * The path to open an SQLite database
 57 |  *
 58 |  * @method string getDriver();
 59 |  * Database Sql driver name
 60 |  * @method string getDsn();
 61 |  * The PDO connection parameter string, database server in the DSN parameters
 62 |  * @method string getUser();
 63 |  * Database user name
 64 |  * @method string getPassword()
 65 |  * Database password for the given user
 66 |  * @method string getName();
 67 |  * Database name
 68 |  * @method string getHost();
 69 |  * Host name or IP address
 70 |  * @method string getPort();
 71 |  * TCP/IP port of PostgreSQL/MySQL
 72 |  * @method string getCharset();
 73 |  * Database charset
 74 |  * @method string getOptions();
 75 |  * The PDO array for connection options, MySQL connection charset, for example
 76 |  * @method string getToMysql();
 77 |  * If we want to convert Queries in MySql syntax to MS-SQL syntax.
 78 |  * Yes, there are some differences in query syntax.
 79 |  * @method bool getIsFile();
 80 |  * Check PDO for whether it is a file based database connection, for example to a SQLite
 81 |  * database file, or not
 82 |  * @method bool getToMssql();
 83 |  * If we want to convert Queries in MySql syntax to MS-SQL syntax.
 84 |  * Yes, there are some differences in query syntax.
 85 |  * @method string getPath();
 86 |  * The path to open an SQLite database
 87 |  */
 88 | abstract class ConfigAbstract
 89 | {
 90 |     /**
 91 |      * Database Sql driver name
 92 |      * @var string
 93 |      */
 94 |     private $driver;
 95 | 
 96 |     /**
 97 |      * Database user name
 98 |      * @var string
 99 |      */
100 |     private $user = '';
101 | 
102 |     /**
103 |      * Database password for the given user
104 |      * @var string
105 |      */
106 |     private $password = '';
107 | 
108 |     /**
109 |      * Database name
110 |      * @var string
111 |      */
112 |     private $name = '';
113 | 
114 |     /**
115 |      * Host name or IP address
116 |      * @var string
117 |      */
118 |     private $host = 'localhost';
119 | 
120 |     /**
121 |      * Database charset
122 |      * @var string Default is utf8
123 |      */
124 |     private $charset = 'utf8';
125 | 
126 |     /**
127 |      * The PDO connection parameter string, database server in the DSN parameters
128 |      * @var string Default is empty string
129 |      */
130 |     private $dsn = '';
131 | 
132 |     /**
133 |      * The PDO array for connection options, MySQL connection charset, for example
134 |      * @var array
135 |      */
136 |     private $options = array();
137 | 
138 |     /**
139 |      * Check PDO for whether it is a file based database connection, for example to a SQLite
140 |      * database file, or not
141 |      * @var boolean Default is false
142 |      */
143 |     private $isfile = false;
144 | 
145 |     /**
146 |      * TCP/IP port of PostgreSQL
147 |      * @var string Default is port 5432
148 |      */
149 |     private $port = '5432';
150 | 
151 |     /**
152 |      * If we want to convert Queries in MySql syntax to MS-SQL syntax.
153 |      * Yes, there are some differences in query syntax.
154 |      */
155 |     private $tomssql = true;
156 | 
157 |     /**
158 |      * The path to open an SQLite database
159 |      */
160 |     private $path = '';
161 | 
162 |     /**
163 |      * Use for Calling Non-Existent Functions, handling Getters and Setters
164 |      * @property-read function
165 |      * @property-write args
166 |      *
167 |      * @return mixed
168 |      */
169 |     public function __call($function, $args)
170 |     {
171 |         $prefix = \substr($function, 0, 3);
172 |         $property = \strtolower(substr($function, 3, \strlen($function)));
173 |         if (($prefix == 'set') && \property_exists($this, $property)) {
174 |             $this->$property = $args[0];
175 |         } elseif (($prefix == 'get') && \property_exists($this, $property)) {
176 |             return $this->$property;
177 |         } else {
178 |             throw new \Exception("$function does not exist");
179 |         }
180 |     }
181 | }
182 | 


--------------------------------------------------------------------------------
/lib/ConfigInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ezsql;
  4 | 
  5 | /**
  6 |  * @method void setDriver($args);
  7 |  * Database Sql driver name
  8 |  * @method void setDsn($args);
  9 |  * The PDO connection parameter string, database server in the DSN parameters
 10 |  * @method void setUser($args);
 11 |  * Database user name
 12 |  * @method void setPassword($args);
 13 |  * Database password for the given user
 14 |  * @method void setName($args);
 15 |  * Database name
 16 |  * @method void setHost($args);
 17 |  * Host name or IP address
 18 |  * @method void setPort($args);
 19 |  * TCP/IP port of PostgreSQL/MySQL
 20 |  * @method void setCharset($args);
 21 |  * Database charset
 22 |  * @method void setOptions($args);
 23 |  * The PDO array for connection options, MySQL connection charset, for example
 24 |  * @method void setIsFile($args);
 25 |  * Check PDO for whether it is a file based database connection, for example to a SQLite
 26 |  * database file, or not
 27 |  * @method void setToMssql($args);
 28 |  * If we want to convert Queries in MySql syntax to MS-SQL syntax.
 29 |  * Yes, there are some differences in query syntax.
 30 |  * @method void setToMysql($args);
 31 |  * If we want to convert Queries in MySql syntax to MS-SQL syntax.
 32 |  * Yes, there are some differences in query syntax.
 33 |  * @method void setPath($args);
 34 |  * The path to open an SQLite database
 35 |  *
 36 |  * @method string getDriver();
 37 |  * Database Sql driver name
 38 |  * @method string getDsn();
 39 |  * The PDO connection parameter string, database server in the DSN parameters
 40 |  * @method string getUser();
 41 |  * Database user name
 42 |  * @method string getPassword()
 43 |  * Database password for the given user
 44 |  * @method string getName();
 45 |  * Database name
 46 |  * @method string getHost();
 47 |  * Host name or IP address
 48 |  * @method string getPort();
 49 |  * TCP/IP port of PostgreSQL/MySQL
 50 |  * @method string getCharset();
 51 |  * Database charset
 52 |  * @method string getOptions();
 53 |  * The PDO array for connection options, MySQL connection charset, for example
 54 |  * @method bool getIsFile();
 55 |  * Check PDO for whether it is a file based database connection, for example to a SQLite
 56 |  * database file, or not
 57 |  * @method bool getToMssql();
 58 |  * If we want to convert Queries in MySql syntax to MS-SQL syntax.
 59 |  * Yes, there are some differences in query syntax.
 60 |  * @method bool getToMysql();
 61 |  * If we want to convert Queries in MySql syntax to MS-SQL syntax.
 62 |  * Yes, there are some differences in query syntax.
 63 |  * @method string getPath();
 64 |  * The path to open an SQLite database
 65 |  */
 66 | interface ConfigInterface
 67 | {
 68 |     /**
 69 |      * Setup Connections for each SQL database class
 70 |      *
 71 |      * @param string $driver - The vendor's SQL database driver name
 72 |      * @param array $arguments SQL connection parameters, in the following:
 73 |      *```js
 74 |      * [
 75 |      *  user,  // The database user name.
 76 |      *  password, // The database users password.
 77 |      *  database, // The name of the database.
 78 |      *  host,   // The host name or IP address of the database server. Default is localhost
 79 |      *  port    // The  database TCP/IP port. Default is: 5432 - PostgreSQL, 3306 - MySQL
 80 |      * ]
 81 |      *```
 82 |      *  for: **mysqli** - (`username`, `password`, `database`, `host`, `port`, `charset`)
 83 |      * - `charset` // The database charset,
 84 |      *      Default is empty string
 85 |      *
 86 |      *  for: **postgresql** - (`username`, `password`, `database`, `host`, `port`)
 87 |      *
 88 |      *  for: **sqlserver** - (`username`, `password`, `database`, `host`, `convertMysqlToMssqlQuery`)
 89 |      * - `convertMysqlToMssqlQuery` // convert Queries in MySql syntax to MS-SQL syntax
 90 |      *      Default is false
 91 |      *
 92 |      *  for: **pdo** - (`dsn`, `username`, `password`, `options`, `isFile`?)
 93 |      * - `dsn`  // The PDO DSN connection parameter string
 94 |      * - `options` // Array for setting connection options as MySQL
 95 |      * - `isFile` // File based databases like SQLite don't need
 96 |      *      user and password, they work with path in the dsn parameter
 97 |      *      Default is false
 98 |      *
 99 |      *  for: **sqlite3** - (`filePath`, `database`)
100 |      * - `filePath` // The path to open an SQLite database
101 |      */
102 |     public static function initialize(string $driver = '', array $arguments = null);
103 | }
104 | 


--------------------------------------------------------------------------------
/lib/Constants.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | if (!\defined('CONSTANTS')) {
  4 | 
  5 |     /**
  6 |      * ezsqlModel Constants
  7 |      */
  8 |     \defined('EZSQL_VERSION') or \define('EZSQL_VERSION', '5.1.2');
  9 |     \defined('OBJECT') or \define('OBJECT', 'OBJECT');
 10 |     \defined('ARRAY_A') or \define('ARRAY_A', 'ARRAY_A');
 11 |     \defined('ARRAY_N') or \define('ARRAY_N', 'ARRAY_N');
 12 |     // Use to set get_result output as json
 13 |     \define('JSON', 'json');
 14 | 
 15 |     // Error messages
 16 |     \define('MISSING_CONFIGURATION', '<b>Fatal Error:</b> Missing configuration details to connect to database');
 17 |     \define('CONFIGURATION_REQUIRES', '<b>Fatal Error:</b> This configuration requires ezsqlModel (ezsqlModel.php) to be included/loaded before it can be used');
 18 |     \define('FAILED_CONNECTION', 'Failed to make connection to database');
 19 | 
 20 |     // ezQuery prepare placeholder/positional tag
 21 |     \define('_TAG', '__ez__');
 22 | 
 23 |     /**
 24 |      * Operator boolean expressions.
 25 |      */
 26 |     \define('EQ', '=');
 27 |     \define('NEQ', '<>');
 28 |     \define('NE', '!=');
 29 |     \define('LT', '<');
 30 |     \define('LTE', '<=');
 31 |     \define('GT', '>');
 32 |     \define('GTE', '>=');
 33 |     \define('_BOOLEAN', ['<', '>', '=', '!=', '>=', '<=', '<>']);
 34 | 
 35 |     \define('_IN', 'IN');
 36 |     \define('_notIN', 'NOT IN');
 37 |     \define('_LIKE', 'LIKE');
 38 |     \define('_notLIKE', 'NOT LIKE');
 39 |     \define('_BETWEEN', 'BETWEEN');
 40 |     \define('_notBETWEEN', 'NOT BETWEEN');
 41 | 
 42 |     \define('_isNULL', 'IS NULL');
 43 |     \define('_notNULL', 'IS NOT NULL');
 44 |     \define('_BOOLEAN_OPERATORS', [
 45 |         '<', '>', '=', '!=', '>=', '<=', '<>',
 46 |         'IN', 'LIKE', 'NOT LIKE', 'BETWEEN', 'NOT BETWEEN', 'IS', 'IS NOT'
 47 |     ]);
 48 | 
 49 |     /**
 50 |      * Combine operators.
 51 |      */
 52 |     \define('_AND', 'AND');
 53 |     \define('_OR', 'OR');
 54 |     \define('_NOT', 'NOT');
 55 |     \define('_andNOT', 'AND NOT');
 56 |     \define('_COMBINERS', ['AND', 'OR', 'NOT', 'AND NOT']);
 57 | 
 58 |     /*
 59 |     * for joining shortcut methods.
 60 |     */
 61 |     \define('_INNER', 'INNER');
 62 |     \define('_LEFT', 'LEFT');
 63 |     \define('_RIGHT', 'RIGHT');
 64 |     \define('_FULL', 'FULL');
 65 |     \define('_JOINERS', ['INNER', 'LEFT', 'RIGHT', 'FULL']);
 66 | 
 67 |     /**
 68 |      * Associative array of supported SQL Drivers, and library
 69 |      * @define(array)
 70 |      */
 71 |     \define('VENDOR', [
 72 |         'mysql' => 'ezsql\Database\ez_mysqli',
 73 |         'mysqli' => 'ezsql\Database\ez_mysqli',
 74 |         'pdo' => 'ezsql\Database\ez_pdo',
 75 |         'postgresql' => 'ezsql\Database\ez_pgsql',
 76 |         'pgsql' => 'ezsql\Database\ez_pgsql',
 77 |         'sqlite' => 'ezsql\Database\ez_sqlite3',
 78 |         'sqlite3' => 'ezsql\Database\ez_sqlite3',
 79 |         'sqlserver' => 'ezsql\Database\ez_sqlsrv',
 80 |         'mssql' => 'ezsql\Database\ez_sqlsrv',
 81 |         'sqlsrv' => 'ezsql\Database\ez_sqlsrv'
 82 |     ]);
 83 | 
 84 |     \define('MYSQL', 'mysqli');
 85 |     \define('MYSQLI', 'mysqli');
 86 |     \define('Pdo', 'pdo');
 87 |     \define('PGSQL', 'pgsql');
 88 |     \define('POSTGRESQL', 'pgsql');
 89 |     \define('SQLITE', 'sqlite3');
 90 |     \define('SQLITE3', 'sqlite3');
 91 |     \define('SQLSRV', 'sqlsrv');
 92 |     \define('SQLSERVER', 'sqlsrv');
 93 |     \define('MSSQL', 'sqlsrv');
 94 | 
 95 |     // String SQL data types
 96 |     \define('CHAR', 'CHAR');
 97 |     \define('VARCHAR', 'VARCHAR');
 98 |     \define('CHARACTER', 'CHARACTER');
 99 |     \define('TEXT', 'TEXT');
100 |     \define('TINY', 'TINYTEXT');
101 |     \define('TINYTEXT', 'TINYTEXT');
102 |     \define('MEDIUM', 'MEDIUMTEXT');
103 |     \define('MEDIUMTEXT', 'MEDIUMTEXT');
104 |     \define('LONGTEXT', 'LONGTEXT');
105 |     \define('BINARY', 'BINARY');
106 |     \define('VARBINARY', 'VARBINARY');
107 |     \define('NCHAR', 'NCHAR');
108 |     \define('NVAR', 'NVARCHAR');
109 |     \define('NVARCHAR', 'NVARCHAR');
110 |     \define('NTEXT', 'NTEXT');
111 |     \define('IMAGE', 'IMAGE');
112 |     \define('CLOB', 'CLOB');
113 | 
114 |     // Numeric SQL data types
115 |     \define('INTR', 'INT');
116 |     \define('INT0', 'INT');
117 |     \define('INT2', 'INT2');
118 |     \define('INT4', 'INT4');
119 |     \define('INT8', 'INT8');
120 |     \define('NUMERIC', 'NUMERIC');
121 |     \define('DECIMAL', 'DECIMAL');
122 |     \define('BIT', 'BIT');
123 |     \define('VARBIT', 'VARBIT');
124 |     \define('INTEGERS', 'INTEGER');
125 |     \define('TINYINT', 'TINYINT');
126 |     \define('SMALLINT', 'SMALLINT');
127 |     \define('MEDIUMINT', 'MEDIUMINT');
128 |     \define('BIGINT', 'BIGINT');
129 |     \define('DEC', 'DEC');
130 |     \define('FIXED', 'FIXED');
131 |     \define('FLOATS', 'FLOAT');
132 |     \define('DOUBLES', 'DOUBLE');
133 |     \define('REALS', 'REAL');
134 |     \define('BOOLS', 'BOOL');
135 |     \define('BOOLEANS', 'BOOLEAN');
136 |     \define('SMALLMONEY', 'SMALLMONEY');
137 |     \define('MONEY', 'MONEY');
138 | 
139 |     // Date/Time SQL data types
140 |     \define('DATES', 'DATE');
141 |     \define('TIMESTAMP', 'TIMESTAMP');
142 |     \define('TIMES', 'TIME');
143 |     \define('DATETIME', 'DATETIME');
144 |     \define('YEAR', 'YEAR');
145 |     \define('DATETIME2', 'DATETIME2');
146 |     \define('SMALLDATETIME', 'SMALLDATETIME');
147 |     \define('DATETIMEOFFSET', 'DATETIMEOFFSET');
148 | 
149 |     // Large Object SQL data types
150 |     \define('TINYBLOB', 'TINYBLOB');
151 |     \define('BLOB', 'BLOB');
152 |     \define('MEDIUMBLOB', 'MEDIUMBLOB');
153 | 
154 |     \define('NULLS', 'NULL');
155 |     \define('notNULL', 'NOT NULL');
156 | 
157 |     \define('CONSTRAINT', 'CONSTRAINT');
158 |     \define('PRIMARY', 'PRIMARY KEY');
159 |     \define('FOREIGN', 'FOREIGN KEY');
160 |     \define('UNIQUE', 'UNIQUE');
161 |     \define('INDEX', 'INDEX');
162 |     \define('REFERENCES', 'REFERENCES');
163 | 
164 |     \define('AUTO', '__autoNumbers__');
165 |     \define('SEQUENCE', '__autoNumbers__');
166 |     \define('AUTO_INCREMENT', 'AUTO_INCREMENT');
167 |     \define('AUTOINCREMENT', 'AUTOINCREMENT');
168 |     \define('IDENTITY', 'IDENTITY');
169 |     \define('SERIAL', 'SERIAL');
170 |     \define('SMALLSERIAL', 'SMALLSERIAL');
171 |     \define('BIGSERIAL', 'BIGSERIAL');
172 | 
173 |     \define('ADD', 'ADD');
174 |     \define('DROP', 'DROP COLUMN');
175 |     \define('CHANGE', 'CHANGE COLUMN');
176 |     \define('ALTER', 'ALTER COLUMN');
177 |     \define('MODIFY', 'MODIFY COLUMN');
178 |     \define('RENAME', 'RENAME TO');
179 |     \define('CHANGER', '__modifyingColumns__');
180 | 
181 |     if (!\defined('_DS'))
182 |         \define('_DS', \DIRECTORY_SEPARATOR);
183 | 
184 |     \define('CONSTANTS', true);
185 | }
186 | 


--------------------------------------------------------------------------------
/lib/DInjector.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ezsql;
  6 | 
  7 | use Psr\Container\ContainerInterface;
  8 | use ezsql\Exception\ContainerException;
  9 | use ezsql\Exception\NotFoundException;
 10 | 
 11 | /**
 12 |  * Dependency Injection Container
 13 |  *
 14 |  * @see https://gist.github.com/MustafaMagdi/2bb27aebf6ab078b1f3e5635c0282fac
 15 |  */
 16 | class DInjector implements ContainerInterface
 17 | {
 18 | 	/**
 19 | 	 * @var array
 20 | 	 */
 21 | 	protected $instances = [];
 22 | 
 23 | 	/**
 24 | 	 * Register a service with the container.
 25 | 	 *
 26 | 	 * @param string $abstract - className
 27 | 	 * @param string $concrete - friendlyName
 28 | 	 */
 29 | 	public function set($abstract, $concrete = NULL)
 30 | 	{
 31 | 		if ($concrete === NULL) {
 32 | 			$concrete = $abstract;
 33 | 		}
 34 | 
 35 | 		$this->instances[$abstract] = $concrete;
 36 | 	}
 37 | 
 38 | 	/**
 39 | 	 * @param $abstract
 40 | 	 *
 41 | 	 * @return null|object
 42 | 	 * @throws NotFoundException
 43 | 	 */
 44 | 	public function get($abstract, $values = [])
 45 | 	{
 46 | 		if (!$this->has($abstract)) {
 47 | 			throw new NotFoundException("{$abstract} does not exists");
 48 | 		}
 49 | 
 50 | 		return $this->resolve($this->instances[$abstract], $values);
 51 | 	}
 52 | 
 53 | 	/**
 54 | 	 * Auto setup, execute, or resolve any dependencies.
 55 | 	 *
 56 | 	 * @param $abstract
 57 | 	 * @param array $values
 58 | 	 *
 59 | 	 * @return mixed|null|object
 60 | 	 * @throws ContainerException
 61 | 	 */
 62 | 	public function autoWire($abstract, $values = [])
 63 | 	{
 64 | 		// if we don't have it, just register it
 65 | 		if (!$this->has($abstract)) {
 66 | 			$this->set($abstract);
 67 | 		}
 68 | 
 69 | 		return $this->resolve($this->instances[$abstract], $values);
 70 | 	}
 71 | 
 72 | 	/**
 73 | 	 * Do we have dependence
 74 | 	 * @param $abstract
 75 | 	 * @return bool
 76 | 	 */
 77 | 	public function has($abstract): bool
 78 | 	{
 79 | 		return isset($this->instances[$abstract]);
 80 | 	}
 81 | 
 82 | 	/**
 83 | 	 * resolve single dependence
 84 | 	 *
 85 | 	 * @param $concrete
 86 | 	 * @param $values
 87 | 	 *
 88 | 	 * @return mixed|object
 89 | 	 * @throws ContainerException
 90 | 	 */
 91 | 	protected function resolve($concrete, $values = [])
 92 | 	{
 93 | 		if ($concrete instanceof \Closure) {
 94 | 			return $concrete($this, $values);
 95 | 		}
 96 | 
 97 | 		$reflector = new \ReflectionClass($concrete);
 98 | 		// check if class is instantiable
 99 | 		if (!$reflector->isInstantiable()) {
100 | 			throw new ContainerException("Class {$concrete} is not instantiable");
101 | 		}
102 | 
103 | 		// get class constructor
104 | 		$constructor = $reflector->getConstructor();
105 | 		if (\is_null($constructor)) {
106 | 			// get new instance from class
107 | 			return $reflector->newInstance();
108 | 		}
109 | 
110 | 		// get constructor params
111 | 		$parameters = $constructor->getParameters();
112 | 		$dependencies = $this->getDependencies($parameters, $values);
113 | 
114 | 		// get new instance with dependencies resolved
115 | 		return $reflector->newInstanceArgs($dependencies);
116 | 	}
117 | 
118 | 	/**
119 | 	 * get all dependencies resolved
120 | 	 *
121 | 	 * @param $parameters
122 | 	 *
123 | 	 * @return array
124 | 	 * @throws ContainerException
125 | 	 */
126 | 	protected function getDependencies($parameters, $values = null)
127 | 	{
128 | 		$dependencies = [];
129 | 		if (\is_array($parameters)) {
130 | 			foreach ($parameters as $parameter) {
131 | 				// get the type hinted class
132 | 				$dependency = $parameter->getType() && !$parameter->getType()->isBuiltin()
133 | 					? new \ReflectionClass($parameter->getType()->getName())
134 | 					: NULL;
135 | 				if ($dependency === NULL) {
136 | 					// check if the constructor parameter name exists as a key in the values array
137 | 					if (\array_key_exists($parameter->getName(), $values)) {
138 | 						// get default value of parameter
139 | 						$dependencies[] = $values[$parameter->getName()];
140 | 					} else {
141 | 						// check if default value for a parameter is available
142 | 						if ($parameter->isDefaultValueAvailable()) {
143 | 							// get default value of parameter
144 | 							$dependencies[] = $parameter->getDefaultValue();
145 | 						} else {
146 | 							throw new ContainerException("Can not resolve class dependency {$parameter->name}");
147 | 						}
148 | 					}
149 | 				} else {
150 | 					// get dependency resolved
151 | 					$dependencies[] = $this->autoWire($dependency->name, $values);
152 | 				}
153 | 			}
154 | 		}
155 | 
156 | 		return $dependencies;
157 | 	}
158 | }
159 | 


--------------------------------------------------------------------------------
/lib/Database.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ezsql;
  6 | 
  7 | use ezsql\Db;
  8 | use ezsql\DInjector;
  9 | 
 10 | class Database
 11 | {
 12 |     /**
 13 |      * Timestamp for benchmark.
 14 |      *
 15 |      * @var float
 16 |      */
 17 |     private static $_ts = null;
 18 | 
 19 |     /**
 20 |      * @var ezQueryInterface[]
 21 |      */
 22 |     private static $instances = [];
 23 | 
 24 |     // @codeCoverageIgnoreStart
 25 |     private function __construct()
 26 |     {
 27 |     }
 28 |     private function __clone()
 29 |     {
 30 |     }
 31 |     public function __wakeup()
 32 |     {
 33 |     }
 34 |     // @codeCoverageIgnoreEnd
 35 | 
 36 |     /**
 37 |      * Initialize and connect a vendor database.
 38 |      *
 39 |      * @param string $vendor SQL driver
 40 |      * @param array $setting SQL connection parameters, in the following:
 41 |      *```js
 42 |      * [
 43 |      *  user,  // The database user name.
 44 |      *  password, // The database users password.
 45 |      *  database, // The name of the database.
 46 |      *  host,   // The host name or IP address of the database server. Default is localhost
 47 |      *  port    // The  database TCP/IP port. Default is: 5432 - PostgreSQL, 3306 - MySQL
 48 |      * ]
 49 |      *```
 50 |      *  for: **mysqli** - (`username`, `password`, `database`, `host`, `port`, `charset`)
 51 |      * - `charset` // The database charset,
 52 |      *      Default is empty string
 53 |      *
 54 |      *  for: **postgresql** - (`username`, `password`, `database`, `host`, `port`)
 55 |      *
 56 |      *  for: **sqlserver** - (`username`, `password`, `database`, `host`, `convertMysqlToMssqlQuery`)
 57 |      * - `convertMysqlToMssqlQuery` // convert Queries in MySql syntax to MS-SQL syntax
 58 |      *      Default is false
 59 |      *
 60 |      *  for: **pdo** - (`dsn`, `username`, `password`, `options`, `isFile`?)
 61 |      * - `dsn`  // The PDO DSN connection parameter string
 62 |      * - `options` // Array for setting connection options as MySQL
 63 |      * - `isFile` // File based databases like SQLite don't need
 64 |      *      user and password, they work with path in the dsn parameter
 65 |      *      Default is false
 66 |      *
 67 |      *  for: **sqlite3** - (`filePath`, `database`)
 68 |      * - `filePath` // The path to open an SQLite database
 69 |      *
 70 |      * @param string $tag Store the instance for later use
 71 |      * @return Database\ez_pdo|Database\ez_pgsql|Database\ez_sqlsrv|Database\ez_sqlite3|Database\ez_mysqli
 72 |      */
 73 |     public static function initialize(?string $vendor = null, ?array $setting = null, ?string $tag = null): ezQueryInterface
 74 |     {
 75 |         if (isset(self::$instances[$vendor]) && empty($setting) && empty($tag))
 76 |             return self::$instances[$vendor];
 77 | 
 78 |         if (empty($vendor) || empty($setting)) {
 79 |             throw new \Exception(\MISSING_CONFIGURATION);
 80 |         } else {
 81 |             self::$_ts = \microtime(true);
 82 |             $key = $vendor;
 83 |             $value = \VENDOR[$key];
 84 | 
 85 |             if (!Db::has('ez' . $key) || !empty($tag)) {
 86 |                 $di = new DInjector();
 87 |                 $di->set($key, $value);
 88 |                 $di->set('ezsql\ConfigInterface', 'ezsql\Config');
 89 |                 $instance = $di->get($key, ['driver' => $key, 'arguments' => $setting]);
 90 |                 if (!empty($tag)) {
 91 |                     self::$instances[$tag] = $instance;
 92 |                     return $instance;
 93 |                 }
 94 |             }
 95 | 
 96 |             $db = Db::get('ez' . $key);
 97 |             Db::set('global', $db);
 98 |             return $db;
 99 |         }
100 |     }
101 | 
102 |     /**
103 |      * Print-out a memory used benchmark.
104 |      *
105 |      * @return array|float time elapsed, memory usage.
106 |      */
107 |     public static function benchmark()
108 |     {
109 |         return [
110 |             'start'  => self::$_ts,
111 |             'elapse' => \microtime(true) - self::$_ts,
112 |             'memory' => \memory_get_usage(true),
113 |         ];
114 |     }
115 | }
116 | 


--------------------------------------------------------------------------------
/lib/Database/ez_pdo.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ezsql\Database;
  6 | 
  7 | use Exception;
  8 | use ezsql\Db;
  9 | use ezsql\ezsqlModel;
 10 | use ezsql\ConfigInterface;
 11 | use ezsql\DatabaseInterface;
 12 | 
 13 | class ez_pdo extends ezsqlModel implements DatabaseInterface
 14 | {
 15 |     private $return_val = 0;
 16 |     private $is_insert = false;
 17 |     private $shortcutUsed = false;
 18 |     private $isTransactional = false;
 19 | 
 20 |     /**
 21 |      * Database connection handle
 22 |      * @var \PDO
 23 |      */
 24 |     private $dbh;
 25 | 
 26 |     /**
 27 |      * Query result
 28 |      * @var mixed
 29 |      */
 30 |     private $result;
 31 | 
 32 |     /**
 33 |      * Database configuration setting
 34 |      * @var ConfigInterface
 35 |      */
 36 |     private $database;
 37 | 
 38 |     public function __construct(ConfigInterface $settings = null)
 39 |     {
 40 |         if (empty($settings)) {
 41 |             throw new Exception(\MISSING_CONFIGURATION);
 42 |         }
 43 | 
 44 |         parent::__construct();
 45 |         $this->database = $settings;
 46 | 
 47 |         // Turn on track errors
 48 |         ini_set('track_errors', '1');
 49 | 
 50 |         if (!Db::has('ez' . \Pdo))
 51 |             Db::set('ez' . \Pdo, $this);
 52 |         Db::set('global', $this);
 53 |     } // __construct
 54 | 
 55 |     public function settings()
 56 |     {
 57 |         return $this->database;
 58 |     }
 59 | 
 60 |     /**
 61 |      * Try to connect to the database server in the DSN parameters
 62 |      *
 63 |      * @param string $dsn The connection parameter string
 64 |      *                  Default is empty string
 65 |      * @param string $user The database user name
 66 |      *                  Default is empty string
 67 |      * @param string $password The database password
 68 |      *                  Default is empty string
 69 |      * @param array $options Array for setting connection options
 70 |      *                  Default is an empty array
 71 |      * @param boolean $isFileBased File based databases like SQLite don't need user and password,
 72 |      *                  Default is false
 73 |      * @return boolean
 74 |      */
 75 |     public function connect(
 76 |         $dsn = '',
 77 |         $user = '',
 78 |         $password = '',
 79 |         $options = array(),
 80 |         $isFile = false
 81 |     ) {
 82 |         $this->_connected = false;
 83 |         $key = $this->sslKey;
 84 |         $cert = $this->sslCert;
 85 |         $ca = $this->sslCa;
 86 |         $path = $this->sslPath;
 87 | 
 88 |         $vendor = $this->database->getDsn();
 89 |         if ($this->isSecure) {
 90 |             if (\strpos($vendor, \PGSQL) !== false) {
 91 |                 $this->secureOptions = 'sslmode=require;sslcert=' . $path . $cert . ';sslkey=' . $path . $key . ';sslrootcert=' . $path . $ca . ';';
 92 |             } elseif (\strpos($vendor, 'mysql') !== false) {
 93 |                 $this->secureOptions = array(
 94 |                     \PDO::MYSQL_ATTR_SSL_KEY => $path . $key,
 95 |                     \PDO::MYSQL_ATTR_SSL_CERT => $path . $cert,
 96 |                     \PDO::MYSQL_ATTR_SSL_CA => $path . $ca,
 97 |                     \PDO::MYSQL_ATTR_SSL_CAPATH => $path,
 98 |                     \PDO::MYSQL_ATTR_SSL_CIPHER => 'DHE-RSA-AES256-SHA',
 99 |                     \PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => false
100 |                 );
101 |             } elseif (\strpos($vendor, \MSSQL) !== false) {
102 |                 $this->secureOptions = ';Encrypt=true;TrustServerCertificate=true';
103 |             }
104 |         }
105 | 
106 |         if ($this->isSecure && \is_string($this->secureOptions))
107 |             $dsn = empty($dsn) ? $vendor . $this->secureOptions : $dsn . $this->secureOptions;
108 |         else
109 |             $dsn = empty($dsn) ? $vendor : $dsn;
110 | 
111 |         if ($this->isSecure && \is_array($this->secureOptions))
112 |             $options = $this->secureOptions;
113 |         else
114 |             $options = empty($options) ? $this->database->getOptions() : $options;
115 | 
116 |         $user = empty($user) ? $this->database->getUser() : $user;
117 |         $password = empty($password) ? $this->database->getPassword() : $password;
118 |         $isFile = empty($isFile) ? $this->database->getIsFile() : $isFile;
119 | 
120 |         // Establish PDO connection
121 |         try {
122 |             if ($isFile) {
123 |                 $this->dbh = new \PDO($dsn, null, null, null);
124 |                 $this->_connected = true;
125 |             } else {
126 |                 $this->dbh = new \PDO($dsn, $user, $password, $options);
127 |                 $this->_connected = true;
128 |             }
129 |         } catch (\PDOException $e) {
130 |             $this->register_error($e->getMessage() . '- $dsn: ' . $dsn);
131 |         }
132 | 
133 |         return $this->_connected;
134 |     } // connect
135 | 
136 |     /**
137 |      * With PDO it is only an alias for the connect method
138 |      *
139 |      * @param string $dsn The connection parameter string
140 |      *   - Default is empty string
141 |      * @param string $user The database user name
142 |      *   - Default is empty string
143 |      * @param string $password The database password
144 |      *   - Default is empty string
145 |      * @param array $options Array for setting connection options
146 |      *   - Default is an empty array
147 |      * @param boolean $isFileBased File based databases
148 |      * like SQLite don't need user and password, they work with path in the dsn parameter
149 |      *   - Default is false
150 |      * @return boolean
151 |      */
152 |     public function quick_connect(
153 |         $dsn = '',
154 |         $user = '',
155 |         $password = '',
156 |         $options = array(),
157 |         $isFileBased = false
158 |     ) {
159 |         return $this->connect($dsn, $user, $password, $options, $isFileBased);
160 |     } // quick_connect
161 | 
162 |     /**
163 |      *  Format a SQLite string correctly for safe SQLite insert
164 |      *  (no mater if magic quotes are on or not)
165 |      */
166 | 
167 |     /**
168 |      * Escape a string with the PDO method
169 |      *
170 |      * @param string $str
171 |      * @return string
172 |      */
173 |     public function escape(string $str)
174 |     {
175 |         // If there is no existing database connection then try to connect
176 |         if (!isset($this->dbh) || !$this->dbh) {
177 |             $this->connect(
178 |                 $this->database->getDsn(),
179 |                 $this->database->getUser(),
180 |                 $this->database->getPassword(),
181 |                 $this->database->getOptions(),
182 |                 $this->database->getIsFile()
183 |             );
184 |         }
185 | 
186 |         // pdo quote adds ' at the beginning and at the end, remove them for standard behavior
187 |         $return_val = \substr($this->dbh->quote($str), 1, -1);
188 | 
189 |         return $return_val;
190 |     } // escape
191 | 
192 |     /**
193 |      * Return SQLite specific system date syntax
194 |      * i.e. Oracle: SYSDATE Mysql: NOW()
195 |      *
196 |      * @return string
197 |      */
198 |     public function sysDate()
199 |     {
200 |         return "datetime('now')";
201 |     }
202 | 
203 |     /**
204 |      * Hooks into PDO error system and reports it to user
205 |      *
206 |      * @return string
207 |      */
208 |     public function catch_error()
209 |     {
210 |         $error_str = 'No error info';
211 | 
212 |         $err_array = $this->dbh->errorInfo();
213 | 
214 |         // Note: Ignoring error - bind or column index out of range
215 |         if (isset($err_array[1]) && $err_array[1] != 25) {
216 | 
217 |             $error_str = '';
218 |             foreach ($err_array as $entry) {
219 |                 $error_str .= $entry . ', ';
220 |             }
221 | 
222 |             $error_str = \substr($error_str, 0, -2);
223 | 
224 |             $this->register_error($error_str . ' ' . $this->lastQuery);
225 | 
226 |             return true;
227 |         }
228 |     } // catch_error
229 | 
230 |     /**
231 |      * Creates a prepared query, binds the given parameters and returns the result of the executed
232 |      *
233 |      * @param string $query
234 |      * @param array $param
235 |      * @param boolean $isSelect - return \PDOStatement, if SELECT SQL statement, otherwise int
236 |      * @return bool|int|\PDOStatement
237 |      */
238 |     public function query_prepared(string $query, array $param = null, $isSelect = false)
239 |     {
240 |         $stmt = $this->dbh->prepare($query);
241 |         $result = false;
242 |         if ($stmt && $stmt->execute(\array_values($param))) {
243 |             $result = $stmt->rowCount();
244 |             // Store Query Results
245 |             $num_rows = 0;
246 |             try {
247 |                 while ($row = @$stmt->fetch(\PDO::FETCH_ASSOC)) {
248 |                     // Store results as an objects within main array
249 |                     $this->lastResult[$num_rows] = (object) $row;
250 |                     $num_rows++;
251 |                 }
252 |             } catch (\Throwable $ex) {
253 |                 //
254 |             }
255 | 
256 |             $this->numRows = $num_rows;
257 |         }
258 | 
259 |         $return = ($isSelect) ? $stmt : $result;
260 |         if ($this->shortcutUsed)
261 |             return $return;
262 | 
263 |         $status = ((\strpos($query, 'SELECT ') !== false) || (\strpos($query, 'select ') !== false));
264 |         $prepareOnly = ($status) ? $stmt : $result;
265 |         return $this->processResult($query, $prepareOnly, $status);
266 |     }
267 | 
268 |     /**
269 |      * Perform post processing on SQL query call
270 |      *
271 |      * @param string $query
272 |      * @param mixed $result
273 |      * @param bool $isSelect
274 |      * @return bool|void
275 |      */
276 |     private function processResult(string $query, $result = null, bool $isSelect = false)
277 |     {
278 |         $this->shortcutUsed = false;
279 | 
280 |         // If there is an error then take note of it..
281 |         if ($this->catch_error()) {
282 |             return false;
283 |         }
284 | 
285 |         if ($isSelect) {
286 |             $this->is_insert = false;
287 | 
288 |             if (!empty($result)) {
289 |                 $col_count = $result->columnCount();
290 |                 for ($i = 0; $i < $col_count; $i++) {
291 |                     // Start DEBUG by psc!
292 |                     $this->colInfo[$i] = new \stdClass();
293 |                     // End DEBUG by psc
294 |                     if ($meta = $result->getColumnMeta($i)) {
295 |                         $this->colInfo[$i]->name =  $meta['name'];
296 |                         $this->colInfo[$i]->type =  $meta['native_type'];
297 |                         $this->colInfo[$i]->max_length =  '';
298 |                     } else {
299 |                         $this->colInfo[$i]->name =  'undefined';
300 |                         $this->colInfo[$i]->type =  'undefined';
301 |                         $this->colInfo[$i]->max_length = '';
302 |                     }
303 |                 }
304 | 
305 |                 // Store Query Results
306 |                 $num_rows = 0;
307 |                 try {
308 |                     while ($row = @$result->fetch(\PDO::FETCH_ASSOC)) {
309 |                         // Store results as an objects within main array
310 |                         $this->lastResult[$num_rows] = (object) $row;
311 |                         $num_rows++;
312 |                     }
313 |                 } catch (\Throwable $ex) {
314 |                     //
315 |                 }
316 | 
317 |                 // Log number of rows the query returned
318 |                 $this->numRows = empty($num_rows) ? $this->numRows : $num_rows;
319 | 
320 |                 // Return number of rows selected
321 |                 $this->return_val = $this->numRows;
322 |             }
323 |         } else {
324 |             $this->is_insert = true;
325 | 
326 |             if (!empty($result))
327 |                 $this->_affectedRows = $result;
328 | 
329 |             try {
330 |                 // Take note of the insert_id
331 |                 if (\preg_match("/^(insert|replace)\s+/i", $query)) {
332 |                     $this->insertId = @$this->dbh->lastInsertId();
333 |                 }
334 |             } catch (\Throwable $ex) {
335 |                 //
336 |             }
337 | 
338 |             // Return number of rows affected
339 |             $this->return_val = $this->_affectedRows;
340 |         }
341 | 
342 |         return $this->return_val;
343 |     }
344 | 
345 |     /**
346 |      * Perform SQL query
347 |      *
348 |      * @param string $query
349 |      * @param array $param
350 |      * @return bool|void
351 |      */
352 |     private function processQuery(string $query, array $param = null)
353 |     {
354 |         // Query was an insert, delete, update, replace
355 |         if (\preg_match("/^(insert|delete|update|replace|drop|create)\s+/i", $query)) {
356 |             // Perform the query and log number of affected rows
357 |             // Perform the query via std PDO query or PDO prepare function..
358 |             if (!empty($param) && \is_array($param) && $this->isPrepareOn()) {
359 |                 $this->shortcutUsed = true;
360 |                 $this->_affectedRows = $this->query_prepared($query, $param, false);
361 |             } else {
362 |                 try {
363 |                     $this->_affectedRows = $this->dbh->exec($query);
364 |                 } catch (\Throwable $ex) {
365 |                     //
366 |                 }
367 |             }
368 | 
369 |             if ($this->processResult($query) === false)
370 |                 return false;
371 |         } else {
372 |             // Query was an select
373 | 
374 |             // Perform the query and log number of affected rows
375 |             // Perform the query via std PDO query or PDO prepare function..
376 |             if (!empty($param) && \is_array($param) && $this->isPrepareOn()) {
377 |                 $this->shortcutUsed = true;
378 |                 $sth = $this->query_prepared($query, $param, true);
379 |             } else
380 |                 try {
381 |                     $sth = $this->dbh->query($query);
382 |                 } catch (\Throwable $ex) {
383 |                     //
384 |                 }
385 | 
386 |             if ($this->processResult($query, $sth, true) === false)
387 |                 return false;
388 |         }
389 |     }
390 | 
391 |     /**
392 |      * Basic Query	- see docs for more detail
393 |      *
394 |      * @param string $query
395 |      * @param bool $use_prepare
396 |      * @return object
397 |      */
398 |     public function query(string $query, bool $use_prepare = false)
399 |     {
400 |         $param = [];
401 |         if ($use_prepare)
402 |             $param = $this->prepareValues();
403 | 
404 |         // check for ezQuery placeholder tag and replace tags with proper prepare tag
405 |         $query = \str_replace(_TAG, '?', $query);
406 | 
407 |         // For reg expressions
408 |         $query = \str_replace("/[\n\r]/", '', \trim($query));
409 | 
410 |         // Initialize return
411 |         $this->return_val = 0;
412 | 
413 |         // Flush cached values..
414 |         $this->flush();
415 | 
416 |         // Log how the function was called
417 |         $this->log_query("\$db->query(\"$query\")");
418 | 
419 |         // Keep track of the last query for debug..
420 |         $this->lastQuery = $query;
421 | 
422 |         $this->numQueries++;
423 | 
424 |         // Start timer
425 |         $this->timer_start($this->numQueries);
426 | 
427 |         // Use core file cache function
428 |         if ($cache = $this->get_cache($query)) {
429 |             // Keep tack of how long all queries have taken
430 |             $this->timer_update_global($this->numQueries);
431 | 
432 |             // Trace all queries
433 |             if ($this->useTraceLog) {
434 |                 $this->traceLog[] = $this->debug(false);
435 |             }
436 | 
437 |             return $cache;
438 |         }
439 | 
440 |         // If there is no existing database connection then try to connect
441 |         if (!isset($this->dbh) || !$this->dbh) {
442 |             $this->connect(
443 |                 $this->database->getDsn(),
444 |                 $this->database->getUser(),
445 |                 $this->database->getPassword(),
446 |                 $this->database->getOptions(),
447 |                 $this->database->getIsFile()
448 |             );
449 |         }
450 | 
451 |         if ($this->processQuery($query, $param) === false) {
452 |             if ($this->isTransactional)
453 |                 throw new \PDOException($this->getLastError());
454 | 
455 |             return false;
456 |         }
457 | 
458 |         // disk caching of queries
459 |         $this->store_cache($query, $this->is_insert);
460 | 
461 |         // If debug ALL queries
462 |         $this->trace || $this->debugAll ? $this->debug() : null;
463 | 
464 |         // Keep tack of how long all queries have taken
465 |         $this->timer_update_global($this->numQueries);
466 | 
467 |         // Trace all queries
468 |         if ($this->useTraceLog) {
469 |             $this->traceLog[] = $this->debug(false);
470 |         }
471 | 
472 |         return $this->return_val;
473 |     } // query
474 | 
475 |     /**
476 |      * Close the database connection
477 |      */
478 |     public function disconnect()
479 |     {
480 |         if ($this->dbh) {
481 |             $this->dbh = null;
482 |             $this->_connected = false;
483 |         }
484 |     }
485 | 
486 |     /**
487 |      * Reset database handle
488 |      */
489 |     public function reset()
490 |     {
491 |         $this->dbh = null;
492 |     }
493 | 
494 |     /**
495 |      * Get connection handle
496 |      */
497 |     public function handle()
498 |     {
499 |         return $this->dbh;
500 |     }
501 | 
502 |     /**
503 |      * Begin PDO Transaction
504 |      */
505 |     public function beginTransaction()
506 |     {
507 |         $this->dbh->beginTransaction();
508 |         $this->isTransactional = true;
509 |     }
510 | 
511 |     public function commit()
512 |     {
513 |         $this->dbh->commit();
514 |         $this->isTransactional = false;
515 |     }
516 | 
517 |     public function rollback()
518 |     {
519 |         $this->dbh->rollback();
520 |         $this->isTransactional = false;
521 |     }
522 | } // ez_pdo
523 | 


--------------------------------------------------------------------------------
/lib/Database/ez_pgsql.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ezsql\Database;
  6 | 
  7 | use Exception;
  8 | use ezsql\Db;
  9 | use ezsql\ezsqlModel;
 10 | use ezsql\ConfigInterface;
 11 | use ezsql\DatabaseInterface;
 12 | 
 13 | class ez_pgsql extends ezsqlModel implements DatabaseInterface
 14 | {
 15 |     private $return_val = 0;
 16 |     private $is_insert = false;
 17 |     private $shortcutUsed = false;
 18 |     private $isTransactional = false;
 19 | 
 20 |     /**
 21 |      * Database connection handle
 22 |      * @var resource
 23 |      */
 24 |     private $dbh;
 25 | 
 26 |     /**
 27 |      * Query result
 28 |      * @var mixed
 29 |      */
 30 |     private $result;
 31 | 
 32 |     /**
 33 |      * Database configuration setting
 34 |      * @var ConfigInterface
 35 |      */
 36 |     private $database;
 37 | 
 38 |     public function __construct(ConfigInterface $settings = null)
 39 |     {
 40 |         if (empty($settings)) {
 41 |             throw new Exception(\MISSING_CONFIGURATION);
 42 |         }
 43 | 
 44 |         parent::__construct();
 45 |         $this->database = $settings;
 46 | 
 47 |         if (!Db::has('ez' . \PGSQL))
 48 |             Db::set('ez' . \PGSQL, $this);
 49 |         Db::set('global', $this);
 50 |     } // __construct
 51 | 
 52 |     public function settings()
 53 |     {
 54 |         return $this->database;
 55 |     }
 56 | 
 57 |     /**
 58 |      * In the case of PostgreSQL quick_connect is not really needed because std.
 59 |      * connect already does what quick connect does - but for the sake of
 60 |      * consistency it has been included
 61 |      *
 62 |      * @param string $user The database user name
 63 |      * @param string $password The database users password
 64 |      * @param string $name The name of the database
 65 |      * @param string $host The host name or IP address of the database server.
 66 |      *            Default is localhost
 67 |      * @param string $port The database TCP/IP port
 68 |      *          Default is PostgreSQL default port 5432
 69 |      * @return boolean
 70 |      */
 71 |     public function quick_connect($user = '', $password = '', $name = '', $host = 'localhost', $port = '5432')
 72 |     {
 73 |         if (!$this->connect($user, $password, $name, $host, $port));
 74 |         return $this->_connected;
 75 |     } // quick_connect
 76 | 
 77 |     /**
 78 |      * Try to connect to PostgreSQL database server
 79 |      *
 80 |      * @param string $user The database user name
 81 |      * @param string $password The database users password
 82 |      * @param string $name The name of the database
 83 |      * @param string $host The host name or IP address of the database server.
 84 |      *            Default is localhost
 85 |      * @param string $port The database TCP/IP port
 86 |      *                        Default is PostgreSQL default port 5432
 87 |      * @return boolean
 88 |      */
 89 |     public function connect(
 90 |         string $user = '',
 91 |         string $password = '',
 92 |         string $name = '',
 93 |         string $host = 'localhost',
 94 |         string $port = '5432'
 95 |     ) {
 96 |         $this->_connected = false;
 97 | 
 98 |         $user = empty($user) ? $this->database->getUser() : $user;
 99 |         $password = empty($password) ? $this->database->getPassword() : $password;
100 |         $name = empty($name) ? $this->database->getName() : $name;
101 |         $host = ($host != 'localhost') ? $host : $this->database->getHost();
102 |         $port = ($port != '5432') ? $port : $this->database->getPort();
103 | 
104 |         $connect_string = "host=" . $host . " port=" . $port . " dbname=" . $name . " user=" . $user . " password=" . $password;
105 | 
106 |         // Try to establish the server database handle
107 |         if (!$this->dbh = \pg_connect($connect_string, \PGSQL_CONNECT_FORCE_NEW)) {
108 |             $this->register_error(\FAILED_CONNECTION . ' in ' . __FILE__ . ' on line ' . __LINE__);
109 |         } else {
110 |             $this->_connected = true;
111 |         }
112 | 
113 |         return $this->_connected;
114 |     } // connect
115 | 
116 |     /**
117 |      * Format a mySQL string correctly for safe mySQL insert
118 |      * (no matter if magic quotes are on or not)
119 |      *
120 |      * @param string $str
121 |      * @return string
122 |      */
123 |     public function escape(string $str)
124 |     {
125 |         return \pg_escape_string(\stripslashes($str));
126 |     } // escape
127 | 
128 |     /**
129 |      * Return PostgreSQL specific system date syntax
130 |      * i.e. Oracle: SYSDATE Mysql: NOW()
131 |      *
132 |      * @return string
133 |      */
134 |     public function sysDate()
135 |     {
136 |         return 'NOW()';
137 |     }
138 | 
139 |     /**
140 |      * Creates a prepared query, binds the given parameters and returns the result of the executed
141 |      *
142 |      * @param string $query
143 |      * @param array $param
144 |      * @return bool|mixed
145 |      */
146 |     public function query_prepared(string $query, array $param = null)
147 |     {
148 |         $result = @\pg_query_params($this->dbh, $query, $param);
149 |         return ($this->shortcutUsed) ? $result : $this->processQueryResult($query, $result);
150 |     }
151 | 
152 |     /**
153 |      * Perform post processing on SQL query call
154 |      *
155 |      * @param string $query
156 |      * @param mixed $result
157 |      * @return bool|void
158 |      */
159 |     private function processQueryResult(string $query, $result = null)
160 |     {
161 |         $this->shortcutUsed = false;
162 | 
163 |         if (!empty($result))
164 |             $this->result = $result;
165 | 
166 |         try {
167 |             // If there is an error then take note of it..
168 |             if ($str = @\pg_last_error($this->dbh)) {
169 |                 return $this->register_error($str);
170 |             }
171 |         } catch (\Throwable $ex) {
172 |             return $this->register_error($ex->getMessage());
173 |         }
174 | 
175 |         // Query was an insert, delete, update, replace
176 |         $this->is_insert = false;
177 |         if (\preg_match("/^(insert|delete|update|replace)\s+/i", $query)) {
178 |             $this->is_insert = true;
179 | 
180 |             if (\is_bool($this->result))
181 |                 return false;
182 | 
183 |             $this->_affectedRows = @\pg_affected_rows($this->result);
184 | 
185 |             // Take note of the insert_id
186 |             if (\preg_match("/^(insert|replace)\s+/i", $query)) {
187 |                 //$this->insert_id = @postgresql_insert_id($this->dbh);
188 |                 //$this->insert_id = pg_last_oid($this->result);
189 | 
190 |                 // Thx. Rafael Bernal
191 |                 $insert_query = \pg_query("SELECT lastval();");
192 |                 $insert_row = \pg_fetch_row($insert_query);
193 |                 $this->insertId = $insert_row[0];
194 |             }
195 | 
196 |             // Return number for rows affected
197 |             $this->return_val = $this->_affectedRows;
198 | 
199 |             if (\preg_match("/returning/smi", $query)) {
200 |                 while ($row = @\pg_fetch_object($this->result)) {
201 |                     $return_affected[] = $row;
202 |                 }
203 |                 $this->return_val = $return_affected;
204 |             }
205 |         } else {
206 |             // Query was a select
207 |             $num_rows = 0;
208 |             //may be needed but my tests did not
209 |             if ($this->result) {
210 |                 // Take note of column info
211 |                 $i = 0;
212 |                 while ($i < @\pg_num_fields($this->result)) {
213 |                     $this->colInfo[$i] = new \stdClass();
214 |                     $this->colInfo[$i]->name = \pg_field_name($this->result, $i);
215 |                     $this->colInfo[$i]->type = \pg_field_type($this->result, $i);
216 |                     $this->colInfo[$i]->size = \pg_field_size($this->result, $i);
217 |                     $i++;
218 |                 }
219 | 
220 |                 /**
221 |                  * Store Query Results
222 |                  * while ( $row = @pg_fetch_object($this->result, $i, PGSQL_ASSOC) ) doesn't work? donno
223 |                  * while ( $row = @pg_fetch_object($this->result,$num_rows) ) does work
224 |                  */
225 |                 while ($row = @\pg_fetch_object($this->result)) {
226 |                     // Store results as an objects within main array
227 |                     $this->lastResult[$num_rows] = $row;
228 |                     $num_rows++;
229 |                 }
230 | 
231 |                 @\pg_free_result($this->result);
232 |             }
233 |             // Log number of rows the query returned
234 |             $this->numRows = $num_rows;
235 | 
236 |             // Return number of rows selected
237 |             $this->return_val = $this->numRows;
238 |         }
239 |     }
240 | 
241 |     /**
242 |      * Perform PostgreSQL query and try to determine result value
243 |      *
244 |      * @param string
245 |      * @param bool
246 |      * @return bool|mixed
247 |      */
248 |     public function query(string $query, bool $use_prepare = false)
249 |     {
250 |         $param = [];
251 |         if ($use_prepare) {
252 |             $param = $this->prepareValues();
253 |         }
254 | 
255 |         // check for ezQuery placeholder tag and replace tags with proper prepare tag
256 |         if (!empty($param) && \is_array($param) && ($this->isPrepareOn()) && (\strpos($query, \_TAG) !== false)) {
257 |             foreach ($param as $i => $value) {
258 |                 $parameterized = $i + 1;
259 |                 $needle = \_TAG;
260 |                 $pos = \strpos($query, $needle);
261 |                 if ($pos !== false) {
262 |                     $query = \substr_replace($query, '$' . $parameterized, $pos, \strlen($needle));
263 |                 }
264 |             }
265 |         }
266 | 
267 |         // Initialize return
268 |         $this->return_val = 0;
269 | 
270 |         // Flush cached values..
271 |         $this->flush();
272 | 
273 |         // For reg expressions
274 |         $query = \trim($query);
275 | 
276 |         // Log how the function was called
277 |         $this->log_query("\$db->query(\"$query\")");
278 | 
279 |         // Keep track of the last query for debug..
280 |         $this->lastQuery = $query;
281 | 
282 |         // Count how many queries there have been
283 |         $this->count(true, true);
284 | 
285 |         // Use core file cache function
286 |         if ($cache = $this->get_cache($query)) {
287 |             return $cache;
288 |         }
289 | 
290 |         // If there is no existing database connection then try to connect
291 |         if (!isset($this->dbh) || !$this->dbh) {
292 |             $this->connect(
293 |                 $this->database->getUser(),
294 |                 $this->database->getPassword(),
295 |                 $this->database->getName(),
296 |                 $this->database->getHost(),
297 |                 $this->database->getPort()
298 |             );
299 |         }
300 | 
301 |         // Perform the query via std postgresql_query function..
302 |         if (!empty($param) && \is_array($param) && ($this->isPrepareOn())) {
303 |             $this->shortcutUsed = true;
304 |             $this->result = $this->query_prepared($query, $param);
305 |         } else {
306 |             try {
307 |                 $this->result = @\pg_query($this->dbh, $query);
308 |             } catch (\Throwable $ex) {
309 |                 //
310 |             }
311 |         }
312 | 
313 |         if ($this->processQueryResult($query) === false) {
314 |             if ($this->isTransactional)
315 |                 throw new \Exception($this->getLastError());
316 | 
317 |             return false;
318 |         }
319 | 
320 |         // disk caching of queries
321 |         $this->store_cache($query, $this->is_insert);
322 | 
323 |         // If debug ALL queries
324 |         $this->trace || $this->debugAll ? $this->debug() : null;
325 | 
326 |         return $this->return_val;
327 |     } // query
328 | 
329 |     /**
330 |      * Close the database connection
331 |      */
332 |     public function disconnect()
333 |     {
334 |         if ($this->dbh) {
335 |             \pg_close($this->dbh);
336 |             $this->_connected = false;
337 |         }
338 |     }
339 | 
340 |     /**
341 |      * Reset database handle
342 |      */
343 |     public function reset()
344 |     {
345 |         $this->dbh = null;
346 |     }
347 | 
348 |     /**
349 |      * Get connection handle
350 |      */
351 |     public function handle()
352 |     {
353 |         return $this->dbh;
354 |     }
355 | 
356 |     /**
357 |      * Returns the current database server host
358 |      *
359 |      * @return string
360 |      */
361 |     public function getHost()
362 |     {
363 |         return $this->database->getHost();
364 |     } // getDBHost
365 | 
366 |     /**
367 |      * Returns the current TCP/IP port
368 |      *
369 |      * @return string
370 |      */
371 |     public function getPort()
372 |     {
373 |         return $this->database->getPort();
374 |     } // getPort
375 | 
376 |     /**
377 |      * Begin Postgresql Transaction
378 |      */
379 |     public function beginTransaction()
380 |     {
381 |         @\pg_query($this->dbh, "BEGIN");
382 |         $this->isTransactional = true;
383 |     }
384 | 
385 |     public function commit()
386 |     {
387 |         @\pg_query($this->dbh, "COMMIT");
388 |         $this->isTransactional = false;
389 |     }
390 | 
391 |     public function rollback()
392 |     {
393 |         @\pg_query($this->dbh, "ROLLBACK");
394 |         $this->isTransactional = false;
395 |     }
396 | } // ez_pgsql
397 | 


--------------------------------------------------------------------------------
/lib/Database/ez_sqlite3.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ezsql\Database;
  6 | 
  7 | use Exception;
  8 | use ezsql\Db;
  9 | use ezsql\ezsqlModel;
 10 | use ezsql\ConfigInterface;
 11 | use ezsql\DatabaseInterface;
 12 | 
 13 | class ez_sqlite3 extends ezsqlModel implements DatabaseInterface
 14 | {
 15 |     protected $is_insert = false;
 16 |     private $return_val = 0;
 17 |     private $shortcutUsed = false;
 18 |     private $isTransactional = false;
 19 | 
 20 |     /**
 21 |      * Database connection handle
 22 |      * @var \SQLite3
 23 |      */
 24 |     private $dbh;
 25 | 
 26 |     /**
 27 |      * Query result
 28 |      * @var mixed
 29 |      */
 30 |     private $result;
 31 | 
 32 |     /**
 33 |      * Database configuration setting
 34 |      * @var ConfigInterface
 35 |      */
 36 |     private $database;
 37 | 
 38 |     /**
 39 |      *  Constructor - allow the user to perform a quick connect at the
 40 |      *  same time as initializing the ez_sqlite3 class
 41 |      */
 42 |     public function __construct(ConfigInterface $settings = null)
 43 |     {
 44 |         if (empty($settings)) {
 45 |             throw new Exception(\MISSING_CONFIGURATION);
 46 |         }
 47 | 
 48 |         parent::__construct();
 49 |         $this->database = $settings;
 50 | 
 51 |         // Turn on track errors
 52 |         ini_set('track_errors', '1');
 53 | 
 54 |         if (!Db::has('ez' . \SQLITE3))
 55 |             Db::set('ez' . \SQLITE3, $this);
 56 |         Db::set('global', $this);
 57 |     }
 58 | 
 59 |     public function settings()
 60 |     {
 61 |         return $this->database;
 62 |     }
 63 | 
 64 |     /**
 65 |      *  Try to connect to SQLite database server
 66 |      */
 67 |     public function connect($path = '', $name = '')
 68 |     {
 69 |         $this->_connected = false;
 70 | 
 71 |         $path = empty($path) ? $this->database->getPath() : $path;
 72 |         $name = empty($name) ? $this->database->getName() : $name;
 73 | 
 74 |         // Try to establish the server database handle
 75 |         if (!$this->dbh = @new \SQLite3($path . $name)) {
 76 |             //$this->register_error(\FAILED_CONNECTION);
 77 |             //$this->show_errors ? \trigger_error(\FAILED_CONNECTION, \E_USER_WARNING) : null;
 78 |         } else {
 79 |             $this->connQueries = 0;
 80 |             $this->_connected = true;
 81 |         }
 82 | 
 83 |         return $this->_connected;
 84 |     }
 85 | 
 86 |     /**
 87 |      *  In the case of SQLite quick_connect is not really needed
 88 |      *  because std. connect already does what quick connect does -
 89 |      *  but for the sake of consistency it has been included
 90 |      */
 91 |     public function quick_connect($path = '', $name = '')
 92 |     {
 93 |         return $this->connect($path, $name);
 94 |     }
 95 | 
 96 |     /**
 97 |      *  Format a SQLite string correctly for safe SQLite insert
 98 |      *  (no mater if magic quotes are on or not)
 99 |      * @param string $str
100 |      * @return string
101 |      */
102 |     public function escape(string $str)
103 |     {
104 |         return $this->dbh->escapeString(\stripslashes(\preg_replace("/[\r\n]/", '', $str)));
105 |     }
106 | 
107 |     /**
108 |      *  Return SQLite specific system date syntax
109 |      *  i.e. Oracle: SYSDATE Mysql: NOW()
110 |      */
111 |     public function sysDate()
112 |     {
113 |         return 'now';
114 |     }
115 | 
116 |     // Get the data type of the value to bind.
117 |     public function getArgType($arg)
118 |     {
119 |         switch (\gettype($arg)) {
120 |             case 'double':
121 |                 return \SQLITE3_FLOAT;
122 |             case 'integer':
123 |                 return \SQLITE3_INTEGER;
124 |             case 'boolean':
125 |                 return \SQLITE3_INTEGER;
126 |             case 'NULL':
127 |                 return \SQLITE3_NULL;
128 |             case 'string':
129 |                 return \SQLITE3_TEXT;
130 |             case 'string':
131 |                 return \SQLITE3_TEXT;
132 |             default:
133 |                 $type_error = 'Argument is of invalid type ' . \gettype($arg);
134 |                 return $this->register_error($type_error);
135 |         }
136 |     }
137 | 
138 |     /**
139 |      * Creates a prepared query, binds the given parameters and returns the result of the executed
140 |      *
141 |      * @param string $query
142 |      * @param array $param
143 |      * @return bool \SQLite3Result
144 |      */
145 |     public function query_prepared(string $query, array $param = null)
146 |     {
147 |         $stmt = $this->dbh->prepare($query);
148 |         if (!$stmt instanceof \SQLite3Stmt) {
149 |             if ($this->isTransactional)
150 |                 throw new \Exception($this->getLastError());
151 | 
152 |             return false;
153 |         }
154 | 
155 |         foreach ($param as $index => $val) {
156 |             // indexing start from 1 in Sqlite3 statement
157 |             if (\is_array($val)) {
158 |                 $ok = $stmt->bindParam($index + 1, $val);
159 |             } else {
160 |                 $ok = $stmt->bindValue($index + 1, $val, $this->getArgType($val));
161 |             }
162 | 
163 |             if (!$ok) {
164 |                 $type_error = "Unable to bind param: $val";
165 |                 return $this->register_error($type_error);
166 |             }
167 |         }
168 | 
169 |         $result = $stmt->execute();
170 |         if ($this->shortcutUsed)
171 |             return $result;
172 | 
173 |         $this->processQueryResult($query, $result);
174 |         if ((\strpos($query, 'SELECT ') !== false) || (\strpos($query, 'select ') !== false))
175 |             $this->result->finalize();
176 | 
177 |         return $this->return_val;
178 |     }
179 | 
180 |     /**
181 |      * Perform post processing on SQL query call
182 |      *
183 |      * @param string $query
184 |      * @param mixed $result
185 |      * @param array $param
186 |      * @return bool|void
187 |      */
188 |     private function processQueryResult(string $query, $result = null)
189 |     {
190 |         $this->shortcutUsed = false;
191 | 
192 |         if (!empty($result))
193 |             $this->result = $result;
194 | 
195 |         $this->count(true, true);
196 | 
197 |         // If there is an error then take note of it..
198 |         if (@$this->dbh->lastErrorCode()) {
199 |             $err_str = $this->dbh->lastErrorMsg();
200 |             return $this->register_error($err_str);
201 |         }
202 | 
203 |         // Query was an insert, delete, update, replace
204 |         if (\preg_match("/^(insert|delete|update|replace)\s+/i", $query)) {
205 |             $this->_affectedRows = @$this->dbh->changes();
206 | 
207 |             // Take note of the insert id
208 |             if (\preg_match("/^(insert|replace)\s+/i", $query)) {
209 |                 $this->insertId = @$this->dbh->lastInsertRowID();
210 |             }
211 | 
212 |             // Return number of rows affected
213 |             $this->return_val = $this->_affectedRows;
214 | 
215 |             // Query was an select
216 |         } else {
217 |             // Take note of column info
218 |             $i = 0;
219 |             $this->colInfo = array();
220 |             while ($i < @$this->result->numColumns()) {
221 |                 $this->colInfo[$i] = new \stdClass;
222 |                 $this->colInfo[$i]->name = $this->result->columnName($i);
223 |                 $this->colInfo[$i]->type = null;
224 |                 $this->colInfo[$i]->max_length = null;
225 |                 $i++;
226 |             }
227 | 
228 |             // Store Query Results
229 |             $num_rows = 0;
230 |             while ($row = @$this->result->fetchArray(\SQLITE3_ASSOC)) {
231 |                 // Store result as an objects within main array
232 |                 $obj = (object) $row; //convert to object
233 |                 $this->lastResult[$num_rows] = $obj;
234 |                 $num_rows++;
235 |             }
236 | 
237 |             // Log number of rows the query returned
238 |             $this->numRows = $num_rows;
239 | 
240 |             // Return number of rows selected
241 |             $this->return_val = $this->numRows;
242 |         }
243 |     }
244 | 
245 |     /**
246 |      * Perform SQLite query and try to determine result value
247 |      * Basic Query    - see docs for more detail
248 |      * @param string
249 |      * @param bool
250 |      * @return bool|mixed
251 |      */
252 |     public function query(string $query, bool $use_prepare = false)
253 |     {
254 |         $param = [];
255 |         if ($use_prepare) {
256 |             $param = $this->prepareValues();
257 |         }
258 | 
259 |         // check for ezQuery placeholder tag and replace tags with proper prepare tag
260 |         $query = \str_replace(\_TAG, '?', $query);
261 | 
262 |         // For reg expressions
263 |         $query = \str_replace("/[\n\r]/", '', \trim($query));
264 | 
265 |         // initialize return
266 |         $this->return_val = 0;
267 | 
268 |         // Flush cached values..
269 |         $this->flush();
270 | 
271 |         // Log how the function was called
272 |         $this->log_query("\$db->query(\"$query\")");
273 | 
274 |         // Keep track of the last query for debug..
275 |         $this->lastQuery = $query;
276 | 
277 |         // If there is no existing database connection then try to connect
278 |         if (!isset($this->dbh) || !$this->dbh) {
279 |             $this->connect($this->database->getPath(), $this->database->getName());
280 |         }
281 | 
282 |         // Perform the query via std SQLite3 query or SQLite3 prepare function..
283 |         if (!empty($param) && \is_array($param) && ($this->isPrepareOn())) {
284 |             $this->shortcutUsed = true;
285 |             $this->result = $this->query_prepared($query, $param);
286 |         } else {
287 |             $this->result = $this->dbh->query($query);
288 |         }
289 | 
290 |         if ($this->processQueryResult($query) === false) {
291 |             if ($this->isTransactional)
292 |                 throw new \Exception($this->getLastError());
293 | 
294 |             return false;
295 |         }
296 | 
297 |         if (!empty($param) && \is_array($param) && $this->isPrepareOn())
298 |             $this->result->finalize();
299 | 
300 |         // If debug ALL queries
301 |         $this->trace || $this->debugAll ? $this->debug() : null;
302 | 
303 |         return $this->return_val;
304 |     }
305 | 
306 |     /**
307 |      * Close the database connection
308 |      */
309 |     public function disconnect()
310 |     {
311 |         if ($this->dbh) {
312 |             $this->dbh = null;
313 |             $this->_connected = false;
314 |         }
315 |     }
316 | 
317 |     /**
318 |      * Reset database handle
319 |      */
320 |     public function reset()
321 |     {
322 |         $this->dbh = null;
323 |     }
324 | 
325 |     /**
326 |      * Get connection handle
327 |      */
328 |     public function handle()
329 |     {
330 |         return $this->dbh;
331 |     }
332 | 
333 |     /**
334 |      * Begin sqlite3 Transaction
335 |      */
336 |     public function beginTransaction()
337 |     {
338 |         $this->dbh->exec('BEGIN;');
339 |         $this->isTransactional = true;
340 |     }
341 | 
342 |     public function commit()
343 |     {
344 |         $this->dbh->exec('COMMIT;');
345 |         $this->isTransactional = false;
346 |     }
347 | 
348 |     public function rollback()
349 |     {
350 |         $this->dbh->exec('ROLLBACK;');
351 |         $this->isTransactional = false;
352 |     }
353 | }
354 | 


--------------------------------------------------------------------------------
/lib/Database/ez_sqlsrv.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace ezsql\Database;
  6 | 
  7 | use Exception;
  8 | use ezsql\Db;
  9 | use ezsql\ezsqlModel;
 10 | use ezsql\ConfigInterface;
 11 | use ezsql\DatabaseInterface;
 12 | 
 13 | class ez_sqlsrv extends ezsqlModel implements DatabaseInterface
 14 | {
 15 |     private $return_val = 0;
 16 |     private $is_insert = false;
 17 |     private $shortcutUsed = false;
 18 |     private $isTransactional = false;
 19 | 
 20 |     /**
 21 |      * ezSQL non duplicating data type id's; converting type ids to str
 22 |      */
 23 |     private $ezsql_sqlsrv_type2str_non_dup = array(
 24 |         -5 => 'bigint', -7 => 'bit', 1 => 'char', 91 => 'date', -155 => 'datetimeoffset', 6 => 'float', -4 => 'image', 4 => 'int', -8 => 'nchar',
 25 |         -10 => 'ntext', 2 => 'numeric', -9 => 'nvarchar', 7 => 'real', 5 => 'smallint', -1 => 'text', -154 => 'time', -6 => 'tinyint', -151 => 'udt',
 26 |         -11 => 'uniqueidentifier', -3 => 'varbinary', 12 => 'varchar', -152 => 'xml',
 27 |     );
 28 | 
 29 |     /**
 30 |      * Database connection handle
 31 |      * @var resource
 32 |      */
 33 |     private $dbh;
 34 | 
 35 |     /**
 36 |      * Query result
 37 |      * @var mixed
 38 |      */
 39 |     private $result;
 40 | 
 41 |     /**
 42 |      * Database configuration setting
 43 |      * @var ConfigInterface
 44 |      */
 45 |     private $database;
 46 | 
 47 |     public function __construct(ConfigInterface $settings = null)
 48 |     {
 49 |         if (empty($settings)) {
 50 |             throw new Exception(\MISSING_CONFIGURATION);
 51 |         }
 52 | 
 53 |         parent::__construct();
 54 |         $this->database = $settings;
 55 | 
 56 |         if (!Db::has('ez' . \SQLSRV))
 57 |             Db::set('ez' . \SQLSRV, $this);
 58 |         Db::set('global', $this);
 59 |     }
 60 | 
 61 |     public function settings()
 62 |     {
 63 |         return $this->database;
 64 |     }
 65 | 
 66 |     /**
 67 |      *  Short hand way to connect to sqlsrv database server
 68 |      *  and select a sqlsrv database at the same time
 69 |      */
 70 |     public function quick_connect($user = '', $password = '', $name = '', $host = 'localhost')
 71 |     {
 72 |         $return_val = false;
 73 |         $this->_connected = false;
 74 |         if (!$this->connect($user, $password, $name, $host));
 75 |         else {
 76 |             $return_val = true;
 77 |             $this->_connected = true;
 78 |         }
 79 |         return $return_val;
 80 |     }
 81 | 
 82 |     /**
 83 |      *  Try to connect to sqlsrv database server
 84 |      */
 85 |     public function connect($user = '', $password = '', $name = '', $host = 'localhost')
 86 |     {
 87 |         $this->_connected = false;
 88 | 
 89 |         $user = empty($user) ? $this->database->getUser() : $user;
 90 |         $password = empty($password) ? $this->database->getPassword() : $password;
 91 |         $name = empty($name) ? $this->database->getName() : $name;
 92 |         $host = ($host != 'localhost') ? $this->database->getHost() : $host;
 93 | 
 94 |         // Blank user assumes Windows Authentication
 95 |         if ($this->isSecure) {
 96 |             $connectionOptions = array(
 97 |                 "UID" => $user,
 98 |                 "PWD" => $password,
 99 |                 "Database" => $name,
100 |                 "ReturnDatesAsStrings" => true,
101 |                 "Encrypt" => true,
102 |                 "TrustServerCertificate" => true,
103 |             );
104 |         } else {
105 |             $connectionOptions = array(
106 |                 "UID" => $user,
107 |                 "PWD" => $password,
108 |                 "Database" => $name,
109 |                 "ReturnDatesAsStrings" => true,
110 |             );
111 |         }
112 | 
113 |         // Try to establish the server database handle
114 |         if (($this->dbh = @\sqlsrv_connect($host, $connectionOptions)) === false) {
115 |             $this->register_error(\FAILED_CONNECTION . ' in ' . __FILE__ . ' on line ' . __LINE__);
116 |         } else {
117 |             $this->_connected = true;
118 |             $this->connQueries = 0;
119 |         }
120 | 
121 |         return $this->_connected;
122 |     }
123 | 
124 |     /**
125 |      *  Return sqlsrv specific system date syntax
126 |      *  i.e. Oracle: SYSDATE sqlsrv: NOW(), MS-SQL : getDate()
127 |      *
128 |      *  The SQLSRV drivers pull back the data into a Date class.  Converted
129 |      *   it to a string inside of SQL in order to prevent this from occurring
130 |      *  ** make sure to use " AS <label>" after calling this...
131 |      */
132 |     public function sysDate()
133 |     {
134 |         return "GETDATE()";
135 |     }
136 | 
137 |     /**
138 |      * Creates a prepared query, binds the given parameters and returns the result of the executed
139 |      *
140 |      * @param string $query
141 |      * @param array $param
142 |      * @return bool|mixed
143 |      */
144 |     public function query_prepared(string $query, array $param = null)
145 |     {
146 |         $result = @\sqlsrv_query($this->dbh, $query, $param);
147 |         if ($this->shortcutUsed)
148 |             return $result;
149 | 
150 |         $this->return_val = 0;
151 |         return $this->processQueryResult($query, $result);
152 |     }
153 | 
154 |     /**
155 |      * Perform post processing on SQL query call
156 |      *
157 |      * @param string $query
158 |      * @param mixed $result
159 |      * @return bool|void
160 |      */
161 |     private function processQueryResult(string $query, $result = null)
162 |     {
163 |         $this->shortcutUsed = false;
164 | 
165 |         if (!empty($result))
166 |             $this->result = $result;
167 | 
168 |         // If there is an error then take note of it..
169 |         if ($this->result === false) {
170 |             $errors = \sqlsrv_errors();
171 |             if (!empty($errors)) {
172 |                 foreach ($errors as $error) {
173 |                     $sqlError = "ErrorCode: " . $error['code'] . " ### State: " . $error['SQLSTATE'] . " ### Error Message: " . $error['message'] . " ### Query: " . $query;
174 |                     $this->register_error($sqlError);
175 |                 }
176 |             }
177 | 
178 |             return false;
179 |         }
180 | 
181 |         // Query was an insert, delete, update, replace
182 |         $this->is_insert = false;
183 |         try {
184 |             if (\preg_match("/^(insert|delete|update|replace)\s+/i", $query)) {
185 |                 $this->is_insert = true;
186 |                 $this->_affectedRows = @\sqlsrv_rows_affected($this->result);
187 | 
188 |                 // Take note of the insert_id
189 |                 if (\preg_match("/^(insert|replace)\s+/i", $query)) {
190 |                     $identityResultset = @\sqlsrv_query($this->dbh, "select SCOPE_IDENTITY()");
191 | 
192 |                     if ($identityResultset != false) {
193 |                         $identityRow = @\sqlsrv_fetch($identityResultset);
194 |                         $this->insertId = $identityRow[0];
195 |                     }
196 |                 }
197 |                 // Return number of rows affected
198 |                 $this->return_val = $this->_affectedRows;
199 |             } else { // Query was a select
200 |                 // Take note of column info
201 |                 $i = 0;
202 |                 foreach (@\sqlsrv_field_metadata($this->result) as $field) {
203 |                     $col = [];
204 |                     foreach ($field as $name => $value) {
205 |                         $name = \strtolower($name);
206 |                         if ($name == "size") {
207 |                             $name = "max_length";
208 |                         } elseif ($name == "type") {
209 |                             $name = "typeid";
210 |                         }
211 | 
212 |                         //DEFINED FOR E_STRICT
213 |                         $col = new \stdClass();
214 |                         $col->{$name} = $value;
215 |                     }
216 | 
217 |                     $col->type = $this->get_datatype($col);
218 |                     $this->colInfo[$i++] = $col;
219 |                     unset($col);
220 |                 }
221 | 
222 |                 // Store Query Results
223 |                 $num_rows = 0;
224 | 
225 |                 while ($row = @\sqlsrv_fetch_object($this->result)) {
226 | 
227 |                     // Store results as an objects within main array
228 |                     $this->lastResult[$num_rows] = $row;
229 |                     $num_rows++;
230 |                 }
231 | 
232 |                 @\sqlsrv_free_stmt($this->result);
233 | 
234 |                 // Log number of rows the query returned
235 |                 $this->numRows = $num_rows;
236 | 
237 |                 // Return number of rows selected
238 |                 $this->return_val = $this->numRows;
239 |             }
240 |         } catch (\Throwable $ex) {
241 |             return false;
242 |         }
243 | 
244 |         return $this->return_val;
245 |     }
246 | 
247 |     /**
248 |      * Perform sqlsrv query and try to determine result value
249 |      *
250 |      * @param string
251 |      * @param bool
252 |      * @return bool|mixed
253 |      */
254 |     public function query(string $query, bool $use_prepare = false)
255 |     {
256 |         $param = [];
257 |         if ($use_prepare) {
258 |             $param = &$this->prepareValues();
259 |         }
260 | 
261 |         // check for ezQuery placeholder tag and replace tags with proper prepare tag
262 |         $query = \str_replace(\_TAG, '?', $query);
263 | 
264 |         // if flag to convert query from MySql syntax to MS-Sql syntax is true
265 |         // convert the query
266 |         if ($this->database->getToMssql()) {
267 |             $query = $this->convert($query);
268 |         }
269 | 
270 |         // Initialize return
271 |         $this->return_val = 0;
272 | 
273 |         // Flush cached values..
274 |         $this->flush();
275 | 
276 |         // For reg expressions
277 |         $query = \trim($query);
278 | 
279 |         // Log how the function was called
280 |         $this->log_query("\$db->query(\"$query\")");
281 | 
282 |         // Keep track of the last query for debug..
283 |         $this->lastQuery = $query;
284 | 
285 |         // Count how many queries there have been
286 |         $this->count(true, true);
287 | 
288 |         // Use core file cache function
289 |         if ($cache = $this->get_cache($query)) {
290 |             return $cache;
291 |         }
292 | 
293 |         // If there is no existing database connection then try to connect
294 |         if (!isset($this->dbh) || !$this->dbh) {
295 |             $this->connect(
296 |                 $this->database->getUser(),
297 |                 $this->database->getPassword(),
298 |                 $this->database->getName(),
299 |                 $this->database->getHost()
300 |             );
301 |         }
302 | 
303 |         // Perform the query via std sqlsrv_query function..
304 |         if (!empty($param) && \is_array($param) && $this->isPrepareOn()) {
305 |             $this->shortcutUsed = true;
306 |             $this->result = $this->query_prepared($query, $param);
307 |         } else {
308 |             try {
309 |                 $this->result = @\sqlsrv_query($this->dbh, $query);
310 |             } catch (\Throwable $ex) {
311 |                 //
312 |             }
313 |         }
314 | 
315 |         if ($this->processQueryResult($query) === false) {
316 |             if ($this->isTransactional)
317 |                 throw new \Exception($this->getLastError());
318 | 
319 |             return false;
320 |         }
321 | 
322 |         // disk caching of queries
323 |         $this->store_cache($query, $this->is_insert);
324 | 
325 |         // If debug ALL queries
326 |         $this->trace || $this->debugAll ? $this->debug() : null;
327 | 
328 |         return $this->return_val;
329 |     }
330 | 
331 |     /**
332 |      * Convert a Query From MySql Syntax to MS-Sql syntax
333 |      * Following conversions are made:-
334 |      * 1. The '`' character used for MySql queries is not supported - the character is removed.
335 |      * 2. FROM_UNIXTIME method is not supported. The Function is removed.It is replaced with
336 |      *      getDate(). Warning: This logic may not be right.
337 |      * 3. unix_timestamp function is removed.
338 |      * 4. LIMIT keyword is replaced with TOP keyword. Warning: Logic not fully tested.
339 |      * Note: This method is only a small attempt to convert the syntax. There are many aspects which are not covered here.
340 |      *        This method doesn't at all guarantee complete conversion. Certain queries will still
341 |      *        not work. e.g. MS SQL requires all columns in Select Clause to be present in 'group by' clause.
342 |      *        There is no such restriction in MySql.
343 |      */
344 |     public function convert($query)
345 |     {
346 |         //replace the '`' character used for MySql queries, but not
347 |         //supported in MS-Sql
348 |         $query = \str_replace("`", "", $query);
349 | 
350 |         $limit_str = "/LIMIT[^\w]{1,}([0-9]{1,})([\,]{0,})([0-9]{0,})/i";
351 | 
352 |         $patterns = array(
353 |             //replace From UnixTime command in MS-Sql, doesn't work
354 |             0 => "/FROM_UNIXTIME\(([^\/]{0,})\)/i",
355 |             //replace unix_timestamp function. Doesn't work in MS-Sql
356 |             1 => "/unix_timestamp\(([^\/]{0,})\)/i",
357 |             //replace LIMIT keyword. Works only on MySql not on MS-Sql with TOP keyword
358 |             2 => $limit_str,
359 |         );
360 | 
361 |         $replacements = array(
362 |             0 => "getdate()",
363 |             1 => "\\1",
364 |             2 => "",
365 |         );
366 | 
367 |         $regs = null;
368 |         \preg_match($limit_str, $query, $regs);
369 |         $query = \preg_replace($patterns, $replacements, $query);
370 | 
371 |         if (isset($regs[2])) {
372 |             $query = \str_ireplace("SELECT ", "SELECT TOP " . $regs[3] . " ", $query);
373 |         } else if (isset($regs[1])) {
374 |             $query = \str_ireplace("SELECT ", "SELECT TOP " . $regs[1] . " ", $query);
375 |         }
376 | 
377 |         return $query;
378 |     }
379 | 
380 |     public function get_datatype($col)
381 |     {
382 |         $datatype = "dt not defined";
383 |         if (isset($col->typeid)) {
384 |             switch ($col->typeid) {
385 |                 case -2:
386 |                     if ($col->max_length < 8000) {
387 |                         $datatype = \BINARY;
388 |                     } else {
389 |                         $datatype = \TIMESTAMP;
390 |                     }
391 | 
392 |                     break;
393 |                 case 3:
394 |                     if (($col->scale == 4) && ($col->precision == 19)) {
395 |                         $datatype = \MONEY;
396 |                     } else if (($col->scale == 4) && ($col->precision == 10)) {
397 |                         $datatype = \SMALLMONEY;
398 |                     } else {
399 |                         $datatype = \DECIMAL;
400 |                     }
401 | 
402 |                     break;
403 |                 case 93:
404 |                     if (($col->precision == 16) && ($col->scale == 0)) {
405 |                         $datatype = \SMALLDATETIME;
406 |                     } else if (($col->precision == 23) && ($col->scale == 3)) {
407 |                         $datatype = \DATETIME;
408 |                     } else {
409 |                         $datatype = \DATETIME2;
410 |                     }
411 | 
412 |                     break;
413 |                 default:
414 |                     $datatype = $this->ezsql_sqlsrv_type2str_non_dup[$col->typeid];
415 |                     break;
416 |             }
417 |         }
418 | 
419 |         return $datatype;
420 |     }
421 | 
422 |     /**
423 |      *  Close the active SQLSRV connection
424 |      */
425 |     public function disconnect()
426 |     {
427 |         $this->connQueries = 0;
428 |         @\sqlsrv_close($this->dbh);
429 |         $this->_connected = false;
430 |     }
431 | 
432 |     /**
433 |      * Reset database handle
434 |      */
435 |     public function reset()
436 |     {
437 |         $this->dbh = null;
438 |     }
439 | 
440 |     /**
441 |      * Get connection handle
442 |      */
443 |     public function handle()
444 |     {
445 |         return $this->dbh;
446 |     }
447 | 
448 |     /**
449 |      * Begin sqlsrv Transaction
450 |      */
451 |     public function beginTransaction()
452 |     {
453 |         @\sqlsrv_begin_transaction($this->dbh);
454 |         $this->isTransactional = true;
455 |     }
456 | 
457 |     public function commit()
458 |     {
459 |         @\sqlsrv_commit($this->dbh);
460 |         $this->isTransactional = false;
461 |     }
462 | 
463 |     public function rollback()
464 |     {
465 |         @\sqlsrv_rollback($this->dbh);
466 |         $this->isTransactional = false;
467 |     }
468 | } // end class
469 | 


--------------------------------------------------------------------------------
/lib/DatabaseInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ezsql;
  4 | 
  5 | interface DatabaseInterface
  6 | {
  7 |     /**
  8 |      * Database configuration methods:
  9 |      *
 10 |      * - getDriver();
 11 |      * - getDsn();
 12 |      * - getUser();
 13 |      * - getPassword()
 14 |      * - getName();
 15 |      * - getHost();
 16 |      * - getPort();
 17 |      * - getCharset();
 18 |      * - getOptions();
 19 |      * - getIsFile();
 20 |      * - getToMssql();
 21 |      * - getToMysql();
 22 |      * - getPath();
 23 |      *---
 24 |      * - setDriver($args);
 25 |      * - setDsn($args);
 26 |      * - setUser($args);
 27 |      * - setPassword($args);
 28 |      * - setName($args);
 29 |      * - setHost($args);
 30 |      * - setPort($args);
 31 |      * - setCharset($args);
 32 |      * - setOptions($args);
 33 |      * - setIsFile($args);
 34 |      * - setToMssql($args);
 35 |      * - setToMysql($args);
 36 |      * - setPath($args);
 37 |      *
 38 |      * @return string|array|bool|object
 39 |      */
 40 |     public function settings();
 41 | 
 42 |     /**
 43 |      * Format a mySQL string correctly for safe mySQL insert
 44 |      * (no matter if magic quotes are on or not)
 45 |      *
 46 |      * @param string $str
 47 |      * @return string
 48 |      */
 49 |     public function escape(string $str);
 50 | 
 51 |     /**
 52 |      * Return specific system date syntax
 53 |      * i.e. Oracle: SYSDATE Mysql: NOW()
 54 |      *
 55 |      * @return string
 56 |      */
 57 |     public function sysDate();
 58 | 
 59 |     /**
 60 |      * Creates a prepared query, binds the given parameters and returns the result of the executed.
 61 |      *
 62 |      * Supplying the the whole query string, and placing '?' within,
 63 |      * then the same number of arguments in an array.
 64 |      *
 65 |      * Example:
 66 |      *  `query_prepared('INSERT INTO unit_test(id, test_key) VALUES(1, ?)', ['test 1']);`
 67 |      *
 68 |      * - It will determine arguments type, execute, and return results.
 69 |      *
 70 |      * @param string $query
 71 |      * @param array $param
 72 |      * @return bool|mixed
 73 |      */
 74 |     public function query_prepared(string $query, array $param = null);
 75 | 
 76 |     /**
 77 |      * Perform SQL query and try to determine result value.
 78 |      *
 79 |      * It should be noted that you can send any type of query to the
 80 |      * database using this command.
 81 |      *
 82 |      * If there are any results generated they will be stored and can be
 83 |      * accessed by any ezsql function as long as you use a null query.
 84 |      *
 85 |      * If there are results returned the function will return `true`.
 86 |      * if no results the return will be `false`.
 87 |      *
 88 |      * @param string $query
 89 |      * @param bool $use_prepare
 90 |      * @return bool|mixed
 91 |      */
 92 |     public function query(string $query, bool $use_prepare = false);
 93 | 
 94 |     /**
 95 |      * Close the database connection
 96 |      */
 97 |     public function disconnect();
 98 | 
 99 |     /**
100 |      * Get connection handle
101 |      */
102 |     public function handle();
103 | 
104 |     /**
105 |      * Reset connection handle
106 |      */
107 |     public function reset();
108 | 
109 |     /**
110 |      * Begin Transaction
111 |      */
112 |     public function beginTransaction();
113 | 
114 |     /**
115 |      * Commit Transaction
116 |      */
117 |     public function commit();
118 | 
119 |     /**
120 |      * Rollback Transaction
121 |      */
122 |     public function rollback();
123 | }
124 | 


--------------------------------------------------------------------------------
/lib/Db.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace ezsql;
 6 | 
 7 | use ezsql\ezQueryInterface;
 8 | 
 9 | /**
10 |  * Used internally for needed **global** variables.
11 |  *
12 |  * @internal
13 |  */
14 | final class Db
15 | {
16 |     /**
17 |      * @var ezQueryInterface[]
18 |      */
19 |     protected static $storage;
20 | 
21 |     /**
22 |      * @param string $key
23 |      * @param mixed $value
24 |      * @return void
25 |      */
26 |     public static function set(string $key, $value): void
27 |     {
28 |         self::$storage[$key] = $value;
29 |     }
30 | 
31 |     /**
32 |      * @param string $key
33 |      * @return ezQueryInterface
34 |      */
35 |     public static function get(string $key): ?ezQueryInterface
36 |     {
37 |         return self::$storage[$key] ?? null;
38 |     }
39 | 
40 |     /**
41 |      * @param string $tag
42 |      * @return boolean
43 |      */
44 |     public static function has(string $tag): bool
45 |     {
46 |         return isset(self::$storage[$tag]);
47 |     }
48 | 
49 |     /**
50 |      * @param string $tag
51 |      * @return void
52 |      */
53 |     public static function clear(string $tag): void
54 |     {
55 |         if (self::has($tag))
56 |             unset(self::$storage[$tag]);
57 |     }
58 | 
59 |     /**
60 |      * @return void
61 |      */
62 |     public static function reset(): void
63 |     {
64 |         self::$storage = null;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/lib/Exception/ContainerException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ezsql\Exception;
 4 | 
 5 | use Psr\Container\ContainerExceptionInterface;
 6 | use RuntimeException;
 7 | 
 8 | class ContainerException extends RuntimeException implements ContainerExceptionInterface
 9 | { }
10 | 


--------------------------------------------------------------------------------
/lib/Exception/NotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ezsql\Exception;
 4 | 
 5 | use Psr\Container\NotFoundExceptionInterface;
 6 | use InvalidArgumentException;
 7 | 
 8 | class NotFoundException extends InvalidArgumentException implements NotFoundExceptionInterface
 9 | { }
10 | 


--------------------------------------------------------------------------------
/lib/ezResultset.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * Originally:
  5 |  *  ezSQL Database mysql specific class for working with query results record set component
  6 |  */
  7 | 
  8 | namespace ezsql;
  9 | 
 10 | class ezResultset implements \Iterator
 11 | {
 12 |     /**
 13 |      * Returns the result as array
 14 |      */
 15 |     const RESULT_AS_ARRAY = 'array';
 16 | 
 17 |     /**
 18 |      * Returns the result as object of stdClass
 19 |      */
 20 |     const RESULT_AS_OBJECT = 'object';
 21 | 
 22 |     /**
 23 |      * Returns the result as numeric array
 24 |      */
 25 |     const RESULT_AS_ROW = 'row';
 26 | 
 27 |     /**
 28 |      * Returns the result as json encoded
 29 |      */
 30 |     const RESULT_AS_JSON = 'json';
 31 | 
 32 |     /**
 33 |      * The current position in the resultset
 34 |      * @var int
 35 |      */
 36 |     private $_position = 0;
 37 | 
 38 |     /**
 39 |      * Contains the possible return types
 40 |      * @var array
 41 |      */
 42 |     private $_checkTypes = array('array', 'object', 'row', 'json');
 43 | 
 44 |     /**
 45 |      * The resultset
 46 |      * @var array
 47 |      */
 48 |     private $_resultset = array();
 49 | 
 50 |     /**
 51 |      * Initializes the record object
 52 |      * @param array|object $query_result The result of an ezSQL query
 53 |      * @throws Exception When $query_result is not an array
 54 |      */
 55 |     public function __construct($query_result)
 56 |     {
 57 |         if (!\is_array($query_result)) {
 58 |             throw new \Exception("$query_result is not valid.");
 59 |         }
 60 |         $this->_resultset = $query_result;
 61 |         $this->_position = 0;
 62 |     } // __construct
 63 | 
 64 |     /**
 65 |      * Sets the position to zero
 66 |      */
 67 |     public function rewind(): void
 68 |     {
 69 |         $this->_position = 0;
 70 |     } // rewind
 71 | 
 72 |     /**
 73 |      * Returns the current row of the resultset as stdClass, which is the
 74 |      * default mode, or as array as {field name} => {field value}.
 75 |      * @param string $mode Return the current row as array, or object
 76 |      *                      Default is RESULT_AS_OBJECT
 77 |      * @return \stdClass|array
 78 |      */
 79 |     public function current($mode = self::RESULT_AS_OBJECT)
 80 |     {
 81 |         $return_val = null;
 82 |         if (!\in_array($mode, $this->_checkTypes)) {
 83 |             throw new \Exception(\sprintf('$mode is not in %s1 or %s2', self::RESULT_AS_OBJECT, self::RESULT_AS_ARRAY));
 84 |         }
 85 | 
 86 |         if ($this->valid()) {
 87 |             switch ($mode) {
 88 |                 case self::RESULT_AS_OBJECT:
 89 |                     // The result is a standard row of stdClass
 90 |                     $return_val = $this->_resultset[$this->_position];
 91 |                     break;
 92 |                 case self::RESULT_AS_ARRAY:
 93 |                     $return_val = \get_object_vars($this->_resultset[$this->_position]);
 94 |                     break;
 95 |                 case self::RESULT_AS_ROW:
 96 |                     $return_val = \array_values(\get_object_vars($this->_resultset[$this->_position]));
 97 |                     break;
 98 |                 case self::RESULT_AS_JSON:
 99 |                     $return_val = \json_encode($this->_resultset[$this->_position]);
100 |                     break;
101 |                 default:
102 |                     throw new \Error("Invalid result fetch type");
103 |             }
104 |         } else {
105 |             $result = false;
106 |         }
107 |         return $return_val;
108 |     } // current
109 | 
110 |     /**
111 |      * Returns the current position in the resultset
112 |      * @return int
113 |      */
114 |     public function key(): int
115 |     {
116 |         return $this->_position;
117 |     } // key
118 | 
119 |     /**
120 |      * Sets the position of the resultset up by one
121 |      */
122 |     public function next(): void
123 |     {
124 |         ++$this->_position;
125 |     } // next
126 | 
127 |     /**
128 |      * Sets position of the resultset down by one, if the position is below the
129 |      * start, the position is set to the start position
130 |      */
131 |     public function previous(): void
132 |     {
133 |         --$this->_position;
134 | 
135 |         if ($this->_position < 0) {
136 |             $this->_position = 0;
137 |         }
138 |     } // previous
139 | 
140 |     /**
141 |      * Whether the current position contains a row, or not
142 |      * @return boolean
143 |      */
144 |     public function valid(): bool
145 |     {
146 |         return isset($this->_resultset[$this->_position]);
147 |     } // valid
148 | 
149 |     /**
150 |      * Returns the current record as an associative array and moves the internal data pointer ahead.
151 |      * Behaves like mysql_fetch_assoc
152 |      * @return array
153 |      */
154 |     public function fetch_assoc()
155 |     {
156 |         if ($this->valid()) {
157 |             $return_val = $this->current(self::RESULT_AS_ARRAY);
158 |             $this->next();
159 |         } else {
160 |             $return_val = false;
161 |         }
162 | 
163 |         return $return_val;
164 |     } // fetch_assoc
165 | 
166 |     /**
167 |      * Returns the current record as a numeric array and moves the internal data pointer ahead.
168 |      * Behaves like mysql_fetch_row
169 |      * @return array
170 |      */
171 |     public function fetch_row()
172 |     {
173 |         if ($this->valid()) {
174 |             $return_val = $this->current(self::RESULT_AS_ROW);
175 |             $this->next();
176 |         } else {
177 |             $return_val = false;
178 |         }
179 | 
180 |         return $return_val;
181 |     } // fetch_row
182 | 
183 |     /**
184 |      * Returns n object with properties that correspond to the fetched row and moves
185 |      * the internal data pointer ahead. Behaves like mysql_fetch_object.
186 |      * @return object
187 |      */
188 |     public function fetch_object()
189 |     {
190 |         if ($this->valid()) {
191 |             $return_val = $this->current(self::RESULT_AS_OBJECT);
192 |             $this->next();
193 |         } else {
194 |             $return_val = false;
195 |         }
196 | 
197 |         return $return_val;
198 |     } // fetch_object
199 | 
200 |     /**
201 |      * Returns the current record as an json object and moves the internal data pointer ahead.
202 |      * @return string
203 |      */
204 |     public function fetch_json()
205 |     {
206 |         if ($this->valid()) {
207 |             $return_val = $this->current(self::RESULT_AS_JSON);
208 |             $this->next();
209 |         } else {
210 |             $return_val = false;
211 |         }
212 | 
213 |         return $return_val;
214 |     } // fetch_assoc
215 |     //public function
216 | } // ezResultset
217 | 


--------------------------------------------------------------------------------
/lib/ezSchema.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ezsql;
  4 | 
  5 | use ezsql\DatabaseInterface;
  6 | use function ezsql\functions\{
  7 |     getInstance,
  8 |     to_string
  9 | };
 10 | 
 11 | class ezSchema
 12 | {
 13 |     const STRINGS = [
 14 |         'common' => ['CHAR', 'VARCHAR', 'TEXT'],
 15 |         'mysqli' => ['TINYTEXT', 'MEDIUMTEXT', 'LONGTEXT', 'BINARY', 'VARBINARY'],
 16 |         'pgsql' => ['CHARACTER', 'CHARACTER VARYING'],
 17 |         'sqlsrv' => ['NCHAR', 'NVARCHAR', 'NTEXT', 'BINARY', 'VARBINARY', 'IMAGE'],
 18 |         'sqlite3' => ['TINYTEXT', 'MEDIUMTEXT', 'LONGTEXT', 'NCHAR', 'NVARCHAR', 'CLOB']
 19 |     ];
 20 | 
 21 |     const NUMBERS = [
 22 |         'common' => ['INT'],
 23 |         'mysqli' => [
 24 |             'BIT', 'INTEGER', 'TINYINT', 'SMALLINT', 'MEDIUMINT', 'BIGINT', 'FLOAT',
 25 |             'BOOL', 'BOOLEAN'
 26 |         ],
 27 |         'pgsql' => [
 28 |             'BIT', 'VARBIT', 'BIT VARYING', 'SMALLINT', 'INT', 'INTEGER',
 29 |             'BIGINT', 'SMALLSERIAL', 'SERIAL', 'BIGSERIAL', 'DOUBLE PRECISION', 'REAL',
 30 |             'MONEY', 'BOOL', 'BOOLEAN'
 31 |         ],
 32 |         'sqlsrv' => [
 33 |             'BIT', 'TINYINT', 'SMALLINT', 'BIGINT', 'SMALLMONEY', 'MONEY',
 34 |             'FLOAT', 'REAL'
 35 |         ],
 36 |         'sqlite3' => [
 37 |             'TINYINT', 'SMALLINT', 'MEDIUMINT', 'BIGINT', 'INTEGER', 'INT2',
 38 |             'INT4', 'INT8', 'REAL', 'DOUBLE', 'DOUBLE PRECISION', 'FLOAT', 'BOOLEAN'
 39 |         ]
 40 |     ];
 41 | 
 42 |     const NUMERICS = [
 43 |         'common' => ['NUMERIC', 'DECIMAL'],
 44 |         'mysqli' => ['IDENTITY', 'DEC', 'FIXED', 'FLOAT', 'DOUBLE', 'DOUBLE PRECISION', 'REAL'],
 45 |         'sqlsrv' => ['DEC'],
 46 |         'pgsql' => [],
 47 |         'sqlite3' => []
 48 |     ];
 49 | 
 50 |     const DATE_TIME = [
 51 |         'common' => ['DATE', 'TIMESTAMP', 'TIME'],
 52 |         'mysqli' => ['DATETIME', 'YEAR'],
 53 |         'pgsql' => [
 54 |             'TIMESTAMP WITHOUT TIME ZONE', 'TIMESTAMP WITH TIME ZONE',
 55 |             'TIME WITHOUT TIME ZONE', 'TIME WITH TIME ZONE'
 56 |         ],
 57 |         'sqlsrv' => ['DATETIME', 'DATETIME2', 'SMALLDATETIME', 'DATETIMEOFFSET'],
 58 |         'sqlite3' => ['DATETIME']
 59 |     ];
 60 | 
 61 |     const OBJECTS  = [
 62 |         'mysqli' => ['TINYBLOB', 'BLOB', 'MEDIUMBLOB', 'LONGTEXT'],
 63 |         'sqlite3' => ['BLOB'],
 64 |         'pgsql' => [],
 65 |         'sqlsrv' => []
 66 |     ];
 67 | 
 68 |     const OPTIONS  = ['CONSTRAINT', 'PRIMARY KEY', 'FOREIGN KEY', 'UNIQUE', 'INDEX', 'REFERENCES'];
 69 |     const ALTERS  = ['ADD', 'DROP COLUMN', 'CHANGE COLUMN', 'RENAME TO', 'MODIFY', 'ALTER COLUMN'];
 70 |     const CHANGES  = [
 71 |         'mysqli' => 'MODIFY COLUMN',
 72 |         'pgsql' => 'ALTER COLUMN',
 73 |         'sqlsrv' => 'ALTER COLUMN',
 74 |         'sqlite3' => ''
 75 |     ];
 76 | 
 77 |     const AUTO_NUMBERS  = [
 78 |         'mysqli' => 'AUTO_INCREMENT',
 79 |         'pgsql' => 'SERIAL',
 80 |         'sqlsrv' => 'IDENTITY(1,1)',
 81 |         'sqlite3' => 'AUTOINCREMENT'
 82 |     ];
 83 | 
 84 |     private $arguments = null;
 85 | 
 86 |     public function __construct(...$args)
 87 |     {
 88 |         $this->arguments = $args;
 89 |     }
 90 | 
 91 |     /**
 92 |      * Makes an datatype callable from the above supported CONSTANTS.
 93 |      * This is used to create the database schema.
 94 |      *
 95 |      * @param string $type
 96 |      * @param array $args
 97 |      *
 98 |      * @return string
 99 |      * @throws \Exception
100 |      */
101 |     public function __call($type, $args)
102 |     {
103 |         $vendor = self::vendor();
104 |         if (empty($vendor))
105 |             return false;
106 | 
107 |         $args = $this->arguments;
108 |         $stringTypes = self::STRINGS['common'];
109 |         $stringTypes += self::STRINGS[$vendor];
110 |         $numericTypes = self::NUMERICS['common'];
111 |         $numericTypes += self::NUMERICS[$vendor];
112 |         $numberTypes = self::NUMBERS['common'];
113 |         $numberTypes += self::NUMBERS[$vendor];
114 |         $dateTimeTypes = self::DATE_TIME['common'];
115 |         $dateTimeTypes += self::DATE_TIME[$vendor];
116 |         $objectTypes = self::OBJECTS[$vendor];
117 | 
118 |         $stringPattern = "/" . \implode('|', $stringTypes) . "/i";
119 |         $numericPattern = "/" . \implode('|', $numericTypes) . "/i";
120 |         $numberPattern = "/" . \implode('|', $numberTypes) . "/i";
121 |         $dateTimePattern = "/" . \implode('|', $dateTimeTypes) . "/i";
122 |         $objectPattern = "/" . \implode('|', $objectTypes) . "/i";
123 | 
124 |         $store = '';
125 |         $value = '';
126 |         $options = '';
127 |         $extra = '';
128 |         if (
129 |             \preg_match($stringPattern, $type)
130 |             || \preg_match($numberPattern, $type)
131 |             || \preg_match($dateTimePattern, $type)
132 |         ) {
133 |             // check for string data type
134 |             // check for whole number data type
135 |             // check for date time data type
136 |             $numberOrString = $args[0];
137 |             $store = \is_int($numberOrString) ? '(' . $numberOrString . ')' : '';
138 |             $store = empty($store) && !empty($numberOrString) ? ' ' . $numberOrString : $store;
139 |             $value = !empty($args[1]) ? ' ' . $args[1] : '';
140 |             $options = !empty($args[2]) ? ' ' . $args[2] : '';
141 |             $extra = !empty($args[3]) ? ' ' . $args[3] : '';
142 |         } elseif (\preg_match($numericPattern, $type)) {
143 |             // check for numeric data type
144 |             $store = '(' . (!empty($args[0]) ? $args[0] : 10) . ',';
145 |             $store .= (!empty($args[1]) ? $args[1] : 2) . ')';
146 |             $value = !empty($args[2]) ? ' ' . $args[2] : '';
147 |             $options = !empty($args[3]) ? $args[3] : '';
148 |             $extra = !empty($args[4]) ? ' ' . $args[4] : '';
149 |         } elseif (\preg_match($objectPattern, $type)) {
150 |             // check for large object data type
151 |             $store = !empty($args[0]) ? ' ' . $args[0] : ' ';
152 |         } else {
153 |             throw new \Exception("$type does not exist");
154 |         }
155 | 
156 |         $data = $type . $store . $value . $options . $extra;
157 |         return $data;
158 |     }
159 | 
160 |     /**
161 |      * Returns database vendor string, either the global instance, or provided database class.
162 |      * @param \ezsql\DatabaseInterface|null $db
163 |      *
164 |      * @return string|null `mysqli`|`pgsql`|`sqlite3`|`sqlsrv`
165 |      */
166 |     public static function vendor(DatabaseInterface $db = null)
167 |     {
168 |         $type = null;
169 |         $instance = empty($db) || !is_object($db) ? getInstance() : $db;
170 |         if ($instance instanceof DatabaseInterface) {
171 |             $type = $instance->settings()->getDriver();
172 |             if ($type === \Pdo) {
173 |                 $type = null;
174 |                 $dbh = $instance->handle();
175 |                 if (\strpos($dbh->getAttribute(\PDO::ATTR_CLIENT_VERSION), 'mysql') !== false)
176 |                     $type = \MYSQL;
177 |                 elseif (\strpos($dbh->getAttribute(\PDO::ATTR_CLIENT_VERSION), 'pgsql') !== false)
178 |                     $type = \POSTGRESQL;
179 |                 elseif (\strpos($dbh->getAttribute(\PDO::ATTR_CLIENT_VERSION), 'sqlite') !== false)
180 |                     $type = \SQLITE3;
181 |                 elseif (\strpos($dbh->getAttribute(\PDO::ATTR_CLIENT_VERSION), 'sqlsrv') !== false)
182 |                     $type = \SQLSERVER;
183 |             }
184 |         }
185 | 
186 |         return $type;
187 |     }
188 | 
189 |     /**
190 |      * Creates an database column,
191 |      * - column, datatype, value/options with the given arguments.
192 |      *
193 |      * // datatype are global CONSTANTS and can be written out like:
194 |      *      - VARCHAR, 32, notNULL, PRIMARY, SEQUENCE|AUTO, ....
195 |      * // SEQUENCE|AUTO constants will replaced with the proper auto sequence for the SQL driver
196 |      *
197 |      * @param string $column|CONSTRAINT, - column name/CONSTRAINT usage for PRIMARY|FOREIGN KEY
198 |      * @param string $type|$constraintName, - data type for column/primary|foreign constraint name
199 |      * @param mixed $size|...$primaryForeignKeys,
200 |      * @param mixed $value, - column should be NULL or NOT NULL. If omitted, assumes NULL
201 |      * @param mixed $default - Optional. It is the value to assign to the column
202 |      *
203 |      * @return string|bool - SQL schema string, or false for error
204 |      */
205 |     public static function column(string $column = null, string $type = null, ...$args)
206 |     {
207 |         $vendor = self::vendor();
208 |         if (empty($column) || empty($type) || empty($vendor))
209 |             return false;
210 | 
211 |         $columnData = '';
212 |         if (($column == \CONSTRAINT) || ($column == \INDEX)) {
213 |             if (empty($args[0]) || empty($args[1])) {
214 |                 return false;
215 |             }
216 | 
217 |             $keyType = ($column != \INDEX) ? \array_shift($args) . ' ' : ' ';
218 |             $keys = $keyType . '(' . to_string($args) . '), ';
219 |             $columnData .= $column . ' ' . $type . ' ' . $keys;
220 |         } elseif (($column == \ADD) || ($column == \DROP) || ($column == \CHANGER)) {
221 |             if ($column != \DROP) {
222 |                 // check for modify placeholder and replace with vendors
223 |                 $column = \str_replace(\CHANGER, self::CHANGES[$vendor], $column);
224 |                 $column = $column . ' ' . $type;
225 |                 $type2 = \array_shift($args);
226 |                 $data = self::datatype($type2, ...$args);
227 |             } elseif ($vendor != \SQLITE3)
228 |                 $data = $type;
229 | 
230 |             if (!empty($data))
231 |                 $columnData = $column . ' ' . $data . ', ';
232 |         } else {
233 |             $data = self::datatype($type, ...$args);
234 |             if (!empty($data)) {
235 |                 // check for sequence placeholder and replace with vendors
236 |                 $data = \str_replace(\SEQUENCE, self::AUTO_NUMBERS[$vendor], $data);
237 |                 $columnData = $column . ' ' . $data . ', ';
238 |             }
239 |         }
240 | 
241 |         $schemaColumns = !empty($columnData) ? $columnData : null;
242 |         if (\is_string($schemaColumns))
243 |             return $schemaColumns;
244 | 
245 |         return false;
246 |     }
247 | 
248 |     /**
249 |      * Creates an datatype with given arguments.
250 |      *
251 |      * @param string $type,
252 |      * @param mixed $size,
253 |      * @param mixed $value,
254 |      * @param mixed $default
255 |      *
256 |      * @return string
257 |      */
258 |     public static function datatype(string $type, ...$args)
259 |     {
260 |         $data = new self(...$args);
261 |         return $data->$type();
262 |     }
263 | }
264 | 


--------------------------------------------------------------------------------
/openssl.cnf:
--------------------------------------------------------------------------------
 1 | #
 2 | # OpenSSL configuration file.
 3 | #
 4 | 
 5 | HOME			= .
 6 | RANDFILE		= $ENV::HOME/.rnd
 7 | 
 8 | [ req ]
 9 | default_bits            = 2048
10 | default_md              = sha256
11 | default_keyfile         = certificate.key
12 | distinguished_name      = req_distinguished_name
13 | x509_extensions         = v3_ca
14 | string_mask             = nombstr
15 | 
16 | [ req_distinguished_name ]
17 | countryName             = Country Name (2 letter code)
18 | countryName_min         = 2
19 | countryName_max         = 2
20 | stateOrProvinceName     = State or Province Name (full name)
21 | localityName            = Locality Name (eg, city)
22 | 0.organizationName      = Organization Name (eg, company)
23 | organizationalUnitName  = Organizational Unit Name (eg, section)
24 | commonName              = Common Name (eg, YOUR fqdn)
25 | commonName_max          = 64
26 | emailAddress            = Email Address
27 | emailAddress_max        = 64
28 | 
29 | [ ssl_server ]
30 | basicConstraints        = CA:FALSE
31 | nsCertType              = server
32 | keyUsage                = digitalSignature, keyEncipherment
33 | extendedKeyUsage        = serverAuth, nsSGC, msSGC
34 | nsComment               = "OpenSSL Certificate for SSL Web Server"
35 | 
36 | [ v3_req ]
37 | basicConstraints        = CA:FALSE
38 | keyUsage                = nonRepudiation, digitalSignature, keyEncipherment
39 | 
40 | [ v3_ca ]
41 | basicConstraints        = critical, CA:true, pathlen:0
42 | nsCertType              = sslCA
43 | keyUsage                = cRLSign, keyCertSign
44 | extendedKeyUsage        = serverAuth, clientAuth
45 | nsComment               = "OpenSSL CA Certificate"
46 | 


--------------------------------------------------------------------------------
/unsupported/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | # Versions of PHP you want your project run with.
 4 | php:
 5 |   - 5.6
 6 |   - 7.0
 7 |   - 7.1
 8 |   - 7.2
 9 | 
10 | env:
11 |   - MYSQL_HOST=127.0.0.1 MYSQL_USER=root
12 | 
13 | services:
14 |   - mysql
15 |   - postgresql
16 | 
17 | -before_install:
18 |   - sudo add-apt-repository ppa:cubrid/cubrid -y
19 |   - sudo apt-get update -q
20 |   - sudo apt-get install cubrid php7-cubrid -y
21 | 
22 | # Commands to be run before your environment runs.
23 | before_script:
24 |   - composer self-update
25 |   - composer require php-coveralls/php-coveralls
26 |   - mysql -e 'CREATE DATABASE IF NOT EXISTS ez_test;'
27 |   - mysql -e 'GRANT ALL PRIVILEGES ON ez_test.* TO ez_test@localhost;'
28 |   - mysql -e "SET PASSWORD FOR 'ez_test'@'localhost' = PASSWORD('ezTest')"
29 |   - psql -c 'CREATE DATABASE ez_test;' -U postgres
30 |   - psql -c "CREATE USER ez_test WITH PASSWORD 'ezTest';" -U postgres
31 |   - cubrid service start
32 |   - cubrid createdb --db-volume-size=128M --db-page-size=16K --log-volume-size=128M ez_test en_US
33 |   - cubrid server start ez_test
34 |   - csql ez_test -u dba -c "CREATE USER ez_test PASSWORD 'ezTest' MEMBERS dba"   
35 |   
36 | after_success:
37 |   - bash <(curl -s https://codecov.io/bash)
38 | 
39 | # Commands you want to run that will verify your build.
40 | script: 
41 |   - phpunit --coverage-clover=coverage.xml
42 | 
43 | # allow_failures: Allow this build to fail under the specified environments.
44 | # fast_finish: If your build fails do not continue trying to build, just stop.
45 | matrix:
46 |   allow_failures:
47 |   - php: 5.6
48 |   - php: 7.2
49 |     env: KEY=VALUE  
50 |   fast_finish: true
51 | 


--------------------------------------------------------------------------------
/unsupported/appveyor.yml:
--------------------------------------------------------------------------------
  1 | build: false
  2 | platform:
  3 |   - x64
  4 | clone_folder: c:\projects\php-project-workspace
  5 | 
  6 | ## Build matrix for lowest and highest possible targets
  7 | environment:
  8 |   matrix:
  9 |   - php_ver_target: 7.1
 10 |   MYSQL_DATABASE: ez_test
 11 |   MYSQL_HOST: localhost
 12 |   MYSQL_USER: root
 13 |   MYSQL_PASSWORD: Password12!
 14 |   MYSQL_PATH: C:\Program Files\MySQL\MySQL Server 5.7
 15 |   
 16 | services:
 17 |     - mssql2014
 18 |     - mysql
 19 |     - postgresql
 20 |     
 21 | ## Cache composer, chocolatey and php bits
 22 | cache:
 23 |     - composer.phar
 24 |     # Cache chocolatey packages
 25 |     - C:\ProgramData\chocolatey\bin -> .appveyor.yml
 26 |     - C:\ProgramData\chocolatey\lib -> .appveyor.yml
 27 |     # Cache php install
 28 |     - c:\tools\php -> .appveyor.yml
 29 |     
 30 | ## Set up environment variables
 31 | init:
 32 |     - SET CUBRID=c:\CUBRID
 33 |     - SET PATH=C:\Program Files\OpenSSL;c:\tools\php;C:\Program Files\PostgreSQL\9.4\bin\;C:\CUBRID\bin\;%PATH%
 34 |     - SET COMPOSER_NO_INTERACTION=1
 35 |     - SET PHP=1 # This var is connected to PHP install cache
 36 |     - SET ANSICON=121x90 (121x90)
 37 |     
 38 | ## Install PHP and composer, and run the appropriate composer command Get the MSSQL DLL's and XDEBUG
 39 | install:
 40 |     - IF EXIST c:\tools\php (SET PHP=0)
 41 |     - ps: >-
 42 |         If ($env:php_ver_target -eq "5.6") {
 43 |           appveyor-retry cinst --params '""/InstallDir:C:\tools\php""' --ignore-checksums -y --forcex86 php --version ((choco search php --exact --all-versions -r | select-string -pattern $env:php_ver_target | sort { [version]($_ -split '\|' | select -last 1) } -Descending | Select-Object -first 1) -replace '[php|]','')
 44 |         } Else {
 45 |           appveyor-retry cinst --params '""/InstallDir:C:\tools\php""' --ignore-checksums -y php --version ((choco search php --exact --all-versions -r | select-string -pattern $env:php_ver_target | sort { [version]($_ -split '\|' | select -last 1) } -Descending | Select-Object -first 1) -replace '[php|]','')
 46 |         }
 47 |     - appveyor-retry cinst -y sqlite
 48 |     - cd c:\tools
 49 |     - IF %PHP%==1 appveyor-retry appveyor DownloadFile http://dl.filehorse.com//win/developer-tools/oracle-database-express-64/OracleXE112_Win64.zip?st=JBllKt6MNHDfMAyhjqLFNA&e=1522806869&fn=OracleXE112_Win64.zip
 50 |     - IF %PHP%==1 7z x -y OracleXE112_Win64.zip > $null
 51 |     - IF %PHP%==1 del OracleXE112_Win64.zip
 52 |     - cd c:\tools\DISK1
 53 |     - IF %PHP%==1 setup.exe /s f1"response\OracleXE-install.iss" /f2"response\setup.log"
 54 |     - cd c:\tools\php\ext
 55 |     - IF %PHP%==1 appveyor-retry appveyor DownloadFile http://ftp.cubrid.org/CUBRID_Drivers/PHP_Driver/10.1.0/Windows/CUBRID-PHP-7.1-WIN64-VC14_NTS-10.1.0.0003.zip
 56 |     - IF %PHP%==1 appveyor-retry appveyor DownloadFile http://ftp.cubrid.org/CUBRID_Drivers/PHP_Driver/PDO/CUBRID10.1.0/Windows/CUBRID-PDO-7.1-WIN64-VC14-NTS-10.1.0.0003.bin.zip
 57 |     - IF %PHP%==1 7z x -y CUBRID-PHP-7.1-WIN64-VC14_NTS-10.1.0.0003.zip > $null
 58 |     - IF %PHP%==1 7z x -y CUBRID-PDO-7.1-WIN64-VC14-NTS-10.1.0.0003.bin.zip > $null
 59 |     - cd c:\tools
 60 |     - IF %PHP%==1 appveyor-retry appveyor DownloadFile http://ftp.cubrid.org/CUBRID_Engine/10.1_latest/CUBRID-Windows-x64-10.1-latest.msi
 61 |     - IF %PHP%==1 REG ADD "HKCU\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers" /V %cd%\CUBRID-Windows-x64-10.1-latest.msi /T REG_SZ /D WIN7RTM /F
 62 |     - IF %PHP%==1 msiexec /i CUBRID-Windows-x64-10.1-latest.msi /q
 63 |     - cd c:\tools\php
 64 |     # Get the MSSQL DLL's
 65 |     - ps: >-
 66 |         If ($env:PHP -eq "1") {
 67 |           If ($env:php_ver_target -eq "5.6") {
 68 |             $source = "https://cdn.joomla.org/ci/php-sqlsrv.zip"
 69 |             $destination = "c:\tools\php\php-sqlsrv.zip"
 70 |             Invoke-WebRequest $source -OutFile $destination
 71 |             #appveyor-retry appveyor DownloadFile https://cdn.joomla.org/ci/php-sqlsrv.zip
 72 |             7z x php-sqlsrv.zip > $null
 73 |             copy SQLSRV\php_sqlsrv_56_nts.dll ext\php_sqlsrv_nts.dll
 74 |             copy SQLSRV\php_pdo_sqlsrv_56_nts.dll ext\php_pdo_sqlsrv_nts.dll
 75 |             Remove-Item c:\tools\php\* -include .zip
 76 |             } Else {
 77 |             $DLLVersion = "4.3.0"
 78 |             cd c:\tools\php\ext
 79 |             $source = "http://windows.php.net/downloads/pecl/releases/sqlsrv/$($DLLVersion)/php_sqlsrv-$($DLLVersion)-$($env:php_ver_target)-nts-vc14-x64.zip"
 80 |             $destination = "c:\tools\php\ext\php_sqlsrv-$($DLLVersion)-$($env:php_ver_target)-nts-vc14-x64.zip"
 81 |             Invoke-WebRequest $source -OutFile $destination
 82 |             #appveyor-retry appveyor DownloadFile http://windows.php.net/downloads/pecl/releases/sqlsrv/$($DLLVersion)/php_sqlsrv-$($DLLVersion)-$($env:php_ver_target)-nts-vc14-x64.zip
 83 |             7z x -y php_sqlsrv-$($DLLVersion)-$($env:php_ver_target)-nts-vc14-x64.zip > $null
 84 |             $source = "http://windows.php.net/downloads/pecl/releases/pdo_sqlsrv/$($DLLVersion)/php_pdo_sqlsrv-$($DLLVersion)-$($env:php_ver_target)-nts-vc14-x64.zip"
 85 |             $destination = "c:\tools\php\ext\php_pdo_sqlsrv-$($DLLVersion)-$($env:php_ver_target)-nts-vc14-x64.zip"
 86 |             Invoke-WebRequest $source -OutFile $destination
 87 |             #appveyor-retry appveyor DownloadFile http://windows.php.net/downloads/pecl/releases/pdo_sqlsrv/$($DLLVersion)/php_pdo_sqlsrv-$($DLLVersion)-$($env:php_ver_target)-nts-vc14-x64.zip
 88 |             7z x -y php_pdo_sqlsrv-$($DLLVersion)-$($env:php_ver_target)-nts-vc14-x64.zip > $null
 89 |             Remove-Item c:\tools\php\ext* -include .zip
 90 |             cd c:\tools\php}}
 91 |     - IF %PHP%==1 copy php.ini-production php.ini /Y
 92 |     - IF %PHP%==1 echo date.timezone="UTC" >> php.ini
 93 |     - IF %PHP%==1 echo extension_dir=ext >> php.ini
 94 |     - IF %PHP%==1 echo extension=php_openssl.dll >> php.ini
 95 |     - IF %PHP%==1 echo extension=php_mbstring.dll >> php.ini
 96 |     - IF %PHP%==1 echo extension=php_fileinfo.dll >> php.ini
 97 |     - ps: >-
 98 |         If ($env:php_ver_target -eq "5.6") {
 99 |           Add-Content php.ini "`nextension=php_sqlsrv_nts.dll"
100 |           Add-Content php.ini "`nextension=php_pdo_sqlsrv_nts.dll"
101 |           Add-Content php.ini "`n"
102 |         } Else {
103 |           Add-Content php.ini "`nextension=php_sqlsrv.dll"
104 |           Add-Content php.ini "`nextension=php_pdo_sqlsrv.dll"
105 |           Add-Content php.ini "`n"
106 |         }
107 |     - IF %PHP%==1 echo extension=php_pgsql.dll >> php.ini
108 |     - IF %PHP%==1 echo extension=php_pdo_pgsql.dll >> php.ini
109 |     - IF %PHP%==1 echo extension=php_sqlite3.dll >> php.ini
110 |     - IF %PHP%==1 echo extension=php_pdo_sqlite.dll >> php.ini
111 |     - IF %PHP%==1 echo extension=php_mysqli.dll >> php.ini
112 |     - IF %PHP%==1 echo extension=php_pdo_mysql.dll >> php.ini
113 |     - IF %PHP%==1 echo extension=php_cubrid.dll >> php.ini
114 |     - IF %PHP%==1 echo extension=php_pdo_cubrid.dll >> php.ini
115 |     - IF %PHP%==1 appveyor-retry appveyor DownloadFile https://xdebug.org/files/php_xdebug-2.6.0-7.1-vc14-nts-x86_64.dll -FileName c:\tools\php\ext\php_xdebug-2.6.0-7.1-vc14-nts-x86_64.dll
116 |     - IF %PHP%==1 echo [xdebug] >> php.ini
117 |     - IF %PHP%==1 echo zend_extension=php_xdebug-2.6.0-7.1-vc14-nts-x86_64.dll >> php.ini
118 |     - IF %PHP%==1 echo zend.assertions=1 >> php.ini
119 |     - IF %PHP%==1 echo assert.exception=On >> php.ini
120 |     - IF %PHP%==1 echo xdebug.remote_enable=1 >> php.ini
121 |     - IF %PHP%==1 echo xdebug.remote_autostart=1 >> php.ini
122 |     - IF %PHP%==1 echo xdebug.profiler_enable=off >> php.ini
123 |     - IF %PHP%==1 echo @php %%~dp0composer.phar %%* > composer.bat
124 |     - appveyor-retry appveyor DownloadFile https://getcomposer.org/composer.phar
125 |     - cd c:\projects\php-project-workspace
126 |     - composer self-update
127 |     - composer require php-coveralls/php-coveralls
128 |     
129 | build_script:
130 |   # postgres
131 |   - SET PGUSER=postgres
132 |   - SET PGPASSWORD=Password12!
133 |   - createdb ez_test
134 |   - psql -c "CREATE USER ez_test WITH PASSWORD 'ezTest';"
135 |   # sqlserver
136 |   - sqlcmd -S localhost,1433 -U sa -P Password12! -Q "CREATE DATABASE ez_test"
137 |   - sqlcmd -S localhost,1433 -U sa -P Password12! -d ez_test -Q "CREATE LOGIN ez_test WITH PASSWORD=N'ezTest', DEFAULT_DATABASE=ez_test, CHECK_EXPIRATION=OFF, CHECK_POLICY=OFF; ALTER SERVER ROLE [sysadmin] ADD MEMBER ez_test" 
138 |   
139 | before_test:
140 |   # cubrid
141 |   - mkdir c:\CUBRID\database
142 |   - cd c:\CUBRID\database
143 |   - cubrid service start
144 |   - cubrid createdb --db-volume-size=128M --db-page-size=16K --log-volume-size=128M ez_test en_US
145 |   - cubrid server start ez_test
146 |   - csql ez_test -u dba -c "CREATE USER ez_test PASSWORD 'ezTest' MEMBERS dba"
147 |   # mysql
148 |   - SET PATH=%MYSQL_PATH%\bin;%PATH%
149 |   - mysqladmin --host=%MYSQL_HOST% --user=%MYSQL_USER% --password=%MYSQL_PASSWORD% create %MYSQL_DATABASE%    
150 |   - mysql -u root -p"Password12!" -e "CREATE DATABASE IF NOT EXISTS ez_test;"
151 |   - mysql -u root -p"Password12!" -e "GRANT ALL PRIVILEGES ON ez_test.* TO ez_test@localhost IDENTIFIED BY 'ezTest'";
152 |   - mysql -u root -p"Password12!" -e "FLUSH PRIVILEGES;"
153 |     
154 | on_success:
155 |   - ps: |
156 |       $env:PATH = 'C:\msys64\usr\bin;' + $env:PATH
157 |       Invoke-WebRequest -Uri 'https://codecov.io/bash' -OutFile codecov.sh
158 |       bash codecov.sh -f "coverage.xml"
159 |       
160 | ## Run the actual test
161 | test_script:
162 |     - cd c:\projects\php-project-workspace
163 |     - vendor/bin/phpunit --coverage-clover=coverage.xml
164 |     


--------------------------------------------------------------------------------
/unsupported/ez_sql_loader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | function ez_autoloader($class) {    
 3 |     $base_dir = __DIR__ .DIRECTORY_SEPARATOR.'lib'.DIRECTORY_SEPARATOR;
 4 |     $prefix = 'ezsql\\';
 5 |     
 6 |     $len = strlen($prefix);
 7 |     if (strncmp($prefix, $class, $len) !== 0) {
 8 |         return;
 9 |     }
10 | 
11 |     $relative_class = substr($class, $len);
12 |     $file = $base_dir.strtolower( str_replace('\\', DIRECTORY_SEPARATOR , $relative_class) ).'.php';
13 |     if (file_exists($file)) {
14 |         require_once($file);
15 |     }
16 | }
17 | spl_autoload_register('ez_autoloader');
18 | 
19 | function sql_autoloader($class) {    
20 |     $base_dir = __DIR__ .DIRECTORY_SEPARATOR.'lib'.DIRECTORY_SEPARATOR.'Database'.DIRECTORY_SEPARATOR;
21 |     $prefix = 'ezsql\\Database\\';
22 |     
23 |     $len = strlen($prefix);
24 |     if (strncmp($prefix, $class, $len) !== 0) {
25 |         return;
26 |     }
27 | 
28 |     $relative_class = substr($class, $len);
29 |     $file = $base_dir.strtolower( str_replace('\\', DIRECTORY_SEPARATOR , $relative_class) ).'.php';
30 |     if (file_exists($file)) {
31 |         require_once($file);
32 |     }
33 | }
34 | spl_autoload_register('sql_autoloader');
35 | 


--------------------------------------------------------------------------------
/unsupported/lib/ez_sql_cubrid.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | 	global $ezSQL_cubrid_str;
  4 | 	
  5 | 	$ezSQL_cubrid_str = array
  6 | 	(
  7 | 		1 => 'Require $dbuser and $dbname to connect to a database server',
  8 | 		2 => 'Error establishing CUBRID database connection. Correct user/password? Correct hostname? Correct database name and port ? Database server running?'
  9 | 	);
 10 | 
 11 | 	/**********************************************************************
 12 | 	*  ezSQL Database specific class - CUBRID
 13 | 	*/
 14 | 
 15 | 	if ( ! function_exists ('cubrid_connect') ) die('<b>Fatal Error:</b> ezSQL_cubrid requires CUBRID PHP Driver to be compiled and or linked in to the PHP engine');
 16 | 	if ( ! class_exists ('ezSQLcore') ) die('<b>Fatal Error:</b> ezSQL_cubrid requires ezSQLcore (ez_sql_core.php) to be included/loaded before it can be used');
 17 | 
 18 | 	class ezSQL_cubrid extends ezSQLcore
 19 | 	{
 20 | 
 21 | 		var $dbuser = false;
 22 | 		var $dbpassword = false;
 23 | 		var $dbname = false;
 24 | 		var $dbhost = false;
 25 |         var $dbport = false;
 26 | 		var $rows_affected = false;
 27 | 
 28 | 		/**********************************************************************
 29 | 		*  Constructor - allow the user to perform a quick connect at the
 30 | 		*  same time as initializing the ezSQL_cubrid class
 31 | 		*/
 32 | 
 33 | 		function __construct($dbuser='', $dbpassword='', $dbname='', $dbhost='localhost', $dbport=33000)
 34 | 		{
 35 | 			$this->dbuser = $dbuser;
 36 | 			$this->dbpassword = $dbpassword;
 37 | 			$this->dbname = $dbname;
 38 | 			$this->dbhost = $dbhost;
 39 |             $this->dbport = $dbport;
 40 |             
 41 |             global $_ezCubrid;
 42 |             $_ezCubrid = $this;
 43 | 		}
 44 | 
 45 | 		/**********************************************************************
 46 | 		*  In the case of CUBRID quick_connect is not really needed
 47 | 		*  because std. connect already does what quick connect does -
 48 | 		*  but for the sake of consistency it has been included
 49 | 		*/
 50 | 		function quick_connect($dbuser='', $dbpassword='', $dbname='', $dbhost='localhost', $dbport=33000)
 51 | 		{
 52 | 			return $this->connect($dbuser='', $dbpassword='', $dbname='', $dbhost='localhost', $dbport=33000);
 53 | 		}
 54 |         
 55 | 		/**********************************************************************
 56 | 		*  Try to connect to CUBRID database server
 57 | 		*/
 58 | 
 59 | 		function connect($dbuser='', $dbpassword='', $dbname='', $dbhost='localhost', $dbport=33000)
 60 | 		{
 61 | 			global $ezSQL_cubrid_str; $return_val = false;
 62 |             $this->_connected = false;
 63 | 			
 64 | 			// Keep track of how long the DB takes to connect
 65 | 			$this->timer_start('db_connect_time');
 66 |             
 67 | 			// Must have a user and a password
 68 | 			if ( ! $dbuser || ! $dbname )
 69 | 			{
 70 | 				$this->register_error($ezSQL_cubrid_str[1].' in '.__FILE__.' on line '.__LINE__);
 71 | 				$this->show_errors ? trigger_error($ezSQL_cubrid_str[1],E_USER_WARNING) : null;
 72 | 			}
 73 | 			// Try to establish the server database handle
 74 | 			else if ( ! $this->dbh = @cubrid_connect($dbhost,$dbport,$dbname,$dbuser,$dbpassword) )
 75 | 			{
 76 | 				$this->register_error($ezSQL_cubrid_str[2].' in '.__FILE__.' on line '.__LINE__);
 77 | 				$this->show_errors ? trigger_error($ezSQL_cubrid_str[2],E_USER_WARNING) : null;
 78 | 			}
 79 | 			else
 80 | 			{
 81 | 				$this->dbuser = $dbuser;
 82 | 				$this->dbpassword = $dbpassword;
 83 | 				$this->dbhost = $dbhost;
 84 |                 $this->dbname = $dbname;
 85 |                 $this->dbport = $dbport;
 86 | 				$return_val = true;
 87 |                 $this->_connected = true;
 88 | 
 89 | 				$this->conn_queries = 0;
 90 | 			}
 91 | 
 92 | 			return $return_val;
 93 | 		}
 94 | 
 95 | 		/**********************************************************************
 96 | 		*  Format a CUBRID string correctly for safe CUBRID insert
 97 | 		*  (no mater if magic quotes are on or not)
 98 | 		*/
 99 | 
100 | 		function escape($str)
101 | 		{
102 | 			// If there is no existing database connection then try to connect
103 | 			if ( ! isset($this->dbh) || ! $this->dbh )
104 | 			{
105 | 				$this->connect($this->dbuser, $this->dbpassword, $this->dbhost);
106 | 			}
107 | 
108 | 			return cubrid_real_escape_string(stripslashes($str));
109 | 		}
110 | 
111 | 		/**********************************************************************
112 | 		*  Return CUBRID specific system date syntax
113 | 		*  i.e. Oracle: SYSDATE Mysql/CUBRID: NOW()
114 | 		*/
115 | 
116 | 		function sysdate()
117 | 		{
118 | 			return 'NOW()';
119 | 		}
120 | 
121 | 		/**********************************************************************
122 | 		*  Perform CUBRID query and try to determine result value
123 | 		*/
124 | 
125 | 		function query($query)
126 | 		{
127 | 			// This keeps the connection alive for very long running scripts
128 | 			if ( $this->count(false) >= 500 )
129 | 			{
130 | 				$this->disconnect();
131 | 				$this->connect($this->dbuser,$this->dbpassword,$this->dbname,$this->dbhost,$this->dbport);
132 | 			}
133 | 
134 | 			// Initialise return
135 | 			$return_val = 0;
136 | 
137 | 			// Flush cached values..
138 | 			$this->flush();
139 | 
140 | 			// For reg expressions
141 | 			$query = trim($query);
142 | 
143 | 			// Log how the function was called
144 | 			$this->func_call = "\$db->query(\"$query\")";
145 | 
146 | 			// Keep track of the last query for debug..
147 | 			$this->last_query = $query;
148 | 
149 | 			// Count how many queries there have been
150 | 			$this->count(true, true);
151 | 			
152 | 			// Start timer
153 | 			$this->timer_start($this->num_queries);
154 | 
155 | 			// Use core file cache function
156 | 			if ( $cache = $this->get_cache($query) )
157 | 			{
158 | 				// Keep tack of how long all queries have taken
159 | 				$this->timer_update_global($this->num_queries);
160 | 
161 | 				// Trace all queries
162 | 				if ( $this->use_trace_log )
163 | 				{
164 | 					$this->trace_log[] = $this->debug(false);
165 | 				}
166 | 				
167 | 				return $cache;
168 | 			}
169 | 
170 | 			// If there is no existing database connection then try to connect
171 | 			if ( ! isset($this->dbh) || ! $this->dbh )
172 | 			{
173 | 				$this->connect($this->dbuser, $this->dbpassword, $this->dbname, $this->dbhost, $this->dbport);
174 | 			}
175 | 
176 | 			// Perform the query via std cubrid_query function..
177 | 			$this->result = @cubrid_query($query,$this->dbh);
178 | 
179 | 			// If there is an error then take note of it..
180 | 			if ( $str = @cubrid_error($this->dbh) )
181 | 			{
182 | 				$this->register_error($str);
183 | 				$this->show_errors ? trigger_error($str,E_USER_WARNING) : null;
184 | 				return false;
185 | 			}
186 | 
187 | 			// Query was an insert, delete, update, replace
188 | 			if ( preg_match("/^(insert|delete|update|replace|truncate|drop|create|alter)\s+/i",$query) )
189 | 			{
190 | 				$is_insert = true;
191 | 				$this->rows_affected = @cubrid_affected_rows($this->dbh);
192 | 
193 | 				// Take note of the insert_id
194 | 				if ( preg_match("/^(insert|replace)\s+/i",$query) )
195 | 				{
196 | 					$this->insert_id = @cubrid_insert_id($this->dbh);
197 | 				}
198 | 
199 | 				// Return number fo rows affected
200 | 				$return_val = $this->rows_affected;
201 | 			}
202 | 			// Query was a select
203 | 			else
204 | 			{
205 | 				$is_insert = false;
206 | 
207 | 				// Take note of column info
208 | 				$i=0;
209 | 				while ($i < @cubrid_num_fields($this->result))
210 | 				{
211 | 					$this->col_info[$i] = @cubrid_fetch_field($this->result);
212 | 					$i++;
213 | 				}
214 | 
215 | 				// Store Query Results
216 | 				$num_rows=0;
217 | 				while ( $row = @cubrid_fetch_object($this->result) )
218 | 				{
219 | 					// Store relults as an objects within main array
220 | 					$this->last_result[$num_rows] = $row;
221 | 					$num_rows++;
222 | 				}
223 | 
224 | 				@cubrid_free_result($this->result);
225 | 
226 | 				// Log number of rows the query returned
227 | 				$this->num_rows = $num_rows;
228 | 
229 | 				// Return number of rows selected
230 | 				$return_val = $this->num_rows;
231 | 			}
232 | 
233 | 			// disk caching of queries
234 | 			$this->store_cache($query,$is_insert);
235 | 
236 | 			// If debug ALL queries
237 | 			$this->trace || $this->debug_all ? $this->debug() : null ;
238 | 
239 | 			// Keep tack of how long all queries have taken
240 | 			$this->timer_update_global($this->num_queries);
241 | 
242 | 			// Trace all queries
243 | 			if ( $this->use_trace_log )
244 | 			{
245 | 				$this->trace_log[] = $this->debug(false);
246 | 			}
247 | 
248 | 			return $return_val;
249 | 
250 | 		}
251 | 		
252 | 		/**********************************************************************
253 | 		*  Close the active CUBRID connection
254 | 		*/
255 | 
256 | 		function disconnect()
257 | 		{
258 | 			$this->conn_queries = 0;
259 | 			@cubrid_close($this->dbh);
260 | 		}
261 | 
262 | 	}
263 | 


--------------------------------------------------------------------------------
/unsupported/lib/ez_sql_oracle8_9.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | 	/**********************************************************************
  4 | 	*  ezSQL error strings - Oracle
  5 | 	*/
  6 | 
  7 | 	global $ezsql_oracle8_9_str;
  8 | 	
  9 | 	$ezsql_oracle8_9_str = array
 10 | 	(
 11 | 		1 => 'Require $dbuser, $dbpassword and $dbname to connect to a database server',
 12 | 		2 => 'ezSQL auto created the following Oracle sequence'
 13 | 	);
 14 | 
 15 | 	/**********************************************************************
 16 | 	*  ezSQL Database specific class - Oracle
 17 | 	*/
 18 | 
 19 | 	if ( ! function_exists ('oci_connect') ) die('<b>Fatal Error:</b> ezSQL_oracle8_9 requires Oracle OCI Lib to be compiled and/or linked in to the PHP engine');
 20 | 	if ( ! class_exists ('ezSQLcore') ) die('<b>Fatal Error:</b> ezSQL_oracle8_9 requires ezSQLcore (ez_sql_core.php) to be included/loaded before it can be used');
 21 | 
 22 | 	class ezSQL_oracle8_9 extends ezSQLcore
 23 | 	{
 24 | 
 25 | 		var $dbuser = false;
 26 | 		var $dbpassword = false;
 27 | 		var $dbname = false;
 28 | 		var $rows_affected = false;
 29 | 
 30 | 		/**********************************************************************
 31 | 		*  Constructor - allow the user to perform a quick connect at the
 32 | 		*  same time as initializing the ezSQL_oracle8_9 class
 33 | 		*/
 34 | 
 35 | 		function __construct($dbuser='', $dbpassword='', $dbname='')
 36 | 		{
 37 | 
 38 | 			// Turn on track errors
 39 | 			ini_set('track_errors',1);
 40 | 
 41 | 			$this->dbuser = $dbuser;
 42 | 			$this->dbpassword = $dbpassword;
 43 | 			$this->dbname = $dbname;
 44 | 
 45 |             global $_ezOracle8_9;
 46 |             $_ezOracle8_9 = $this;
 47 | 		}
 48 | 
 49 | 		/**********************************************************************
 50 | 		*  Try to connect to Oracle database server
 51 | 		*/
 52 | 
 53 | 		function connect($dbuser='', $dbpassword='', $dbname='')
 54 | 		{
 55 | 			global $ezsql_oracle8_9_str; $return_val = false;
 56 |             $this->_connected = false;
 57 | 
 58 | 			// Must have a user and a password
 59 | 			if ( ! $dbuser || ! $dbpassword || ! $dbname )
 60 | 			{
 61 | 				$this->register_error($ezsql_oracle8_9_str[1].' in '.__FILE__.' on line '.__LINE__);
 62 | 				$this->show_errors ? trigger_error($ezsql_oracle8_9_str[1],E_USER_WARNING) : null;
 63 | 			}
 64 | 			// Try to establish the server database handle
 65 | 			else if ( ! $this->dbh = oci_connect($dbuser, $dbpassword, $dbname) )
 66 | 			{
 67 | 				$this->register_error($php_errormsg);
 68 | 				$this->show_errors ? trigger_error($php_errormsg,E_USER_WARNING) : null;
 69 | 			}
 70 | 			else
 71 | 			{
 72 | 				$this->dbuser = $dbuser;
 73 | 				$this->dbpassword = $dbpassword;
 74 | 				$this->dbname = $dbname;
 75 | 				$return_val = true;
 76 |                 $this->_connected = true;
 77 | 
 78 | 				$this->conn_queries = 0;
 79 | 			}
 80 |             
 81 | 			return $return_val;
 82 | 		}
 83 | 
 84 | 		/**********************************************************************
 85 | 		*  In the case of Oracle quick_connect is not really needed
 86 | 		*  because std. connect already does what quick connect does -
 87 | 		*  but for the sake of consistency it has been included
 88 | 		*/
 89 | 
 90 | 		function quick_connect($dbuser='', $dbpassword='', $dbname='')
 91 | 		{
 92 | 			return $this->connect($dbuser='', $dbpassword='', $dbname='');
 93 | 		}
 94 | 
 95 | 		/**********************************************************************
 96 | 		*  Return Oracle specific system date syntax
 97 | 		*  i.e. Oracle: SYSDATE Mysql: NOW()
 98 | 		*/
 99 | 
100 | 		function sysdate()
101 | 		{
102 | 			return "SYSDATE";
103 | 		}
104 | 
105 | 		/**********************************************************************
106 | 		*  These special Oracle functions make sure that even if your test
107 | 		*  pattern is '' it will still match records that are null if
108 | 		*  you don't use these funcs then oracle will return no results
109 | 		*  if $user = ''; even if there were records that = ''
110 | 		*
111 | 		*  SELECT * FROM USERS WHERE USER = ".$db->is_equal_str($user)."
112 | 		*/
113 | 
114 | 		function is_equal_str($str='')
115 | 		{
116 | 			return ($str==''?'IS NULL':"= '".$this->escape($str)."'");
117 | 		}
118 | 
119 | 		function is_equal_int($int)
120 | 		{
121 | 			return ($int==''?'IS NULL':'= '.$int);
122 | 		}
123 | 
124 | 		/**********************************************************************
125 | 		*  Another oracle specific function - if you have set up a sequence
126 | 		*  this function returns the next ID from that sequence
127 | 		*/
128 | 
129 | 		function insert_id($seq_name)
130 | 		{
131 | 			global $ezsql_oracle8_9_str;
132 | 
133 | 			$return_val = $this->get_var("SELECT $seq_name.nextVal id FROM Dual");
134 | 
135 | 			// If no return value then try to create the sequence
136 | 			if ( ! $return_val )
137 | 			{
138 | 				$this->query("CREATE SEQUENCE $seq_name maxValue 9999999999 INCREMENT BY 1 START WITH 1 CACHE 20 CYCLE");
139 | 				$return_val = $this->get_var("SELECT $seq_name.nextVal id FROM Dual");
140 | 				$this->register_error($ezsql_oracle8_9_str[2].": $seq_name");
141 | 				$this->show_errors ? trigger_error($ezsql_oracle8_9_str[2].": $seq_name",E_USER_NOTICE) : null;
142 | 			}
143 | 
144 | 			return $return_val;
145 | 		}
146 | 
147 | 		/**********************************************************************
148 | 		*  Perform Oracle query and try to determine result value
149 | 		*/
150 | 
151 | 		function query($query)
152 | 		{
153 | 
154 | 			$return_value = 0;
155 | 
156 | 			// Flush cached values..
157 | 			$this->flush();
158 | 
159 | 			// Log how the function was called
160 | 			$this->func_call = "\$db->query(\"$query\")";
161 | 
162 | 			// Keep track of the last query for debug..
163 | 			$this->last_query = $query;
164 | 
165 | 			$this->count(true, true);
166 | 
167 | 			// Use core file cache function
168 | 			if ( $cache = $this->get_cache($query) )
169 | 			{
170 | 				return $cache;
171 | 			}
172 | 
173 | 			// If there is no existing database connection then try to connect
174 | 			if ( ! isset($this->dbh) || ! $this->dbh )
175 | 			{
176 | 				$this->connect($this->dbuser, $this->dbpassword, $this->dbname);
177 | 			}
178 | 
179 | 			// Parses the query and returns a statement..
180 | 			if ( ! $stmt = oci_parse($this->dbh, $query))
181 | 			{
182 | 				$error = oci_error($this->dbh);
183 | 				$this->register_error($error["message"]);
184 | 				$this->show_errors ? trigger_error($error["message"],E_USER_WARNING) : null;
185 | 				return false;
186 | 			}
187 | 
188 | 			// Execut the query..
189 | 			elseif ( ! $this->result = oci_execute($stmt))
190 | 			{
191 | 				$error = oci_error($stmt);
192 | 				$this->register_error($error["message"]);
193 | 				$this->show_errors ? trigger_error($error["message"],E_USER_WARNING) : null;
194 | 				return false;
195 | 			}
196 | 
197 | 			// If query was an insert
198 | 			$is_insert = false;
199 | 			if ( preg_match('/^(insert|delete|update|create) /i', $query) )
200 | 			{
201 | 				$is_insert = true;
202 | 
203 | 				// num afected rows
204 | 				$return_value = $this->rows_affected = @oci_num_rows($stmt);
205 | 			}
206 | 			// If query was a select
207 | 			else
208 | 			{
209 | 
210 | 				// Get column information
211 | 				if ( $num_cols = @OCINumCols($stmt) )
212 | 				{
213 | 					// Fetch the column meta data
214 | 	    			for ( $i = 1; $i <= $num_cols; $i++ )
215 | 	    			{
216 |                                     
217 |                                     if ( !is_object($this->col_info) ) {
218 |                                         $this->col_info[] = new stdClass;
219 |                                     }
220 |                                     
221 | 	    				$this->col_info[($i-1)]->name = @OCIColumnName($stmt,$i);
222 | 	    				$this->col_info[($i-1)]->type = @OCIColumnType($stmt,$i);
223 | 	    				$this->col_info[($i-1)]->size = @OCIColumnSize($stmt,$i);
224 | 				    }
225 | 				}
226 |                             
227 |                             // Store Query Results 
228 |                             $num_rows=0; 
229 |                             while ( $row = @oci_fetch_object($stmt) ) 
230 |                             { 
231 |                                 // Store relults as an objects within main array 
232 |                                 $this->last_result[$num_rows] = $row; 
233 |                                 $num_rows++; 
234 |                             } 
235 | 
236 |                             // num result rows
237 |                             $return_value = $num_rows;
238 | 			}
239 | 
240 | 			// disk caching of queries
241 | 			$this->store_cache($query,$is_insert);
242 | 
243 | 			// If debug ALL queries
244 | 			$this->trace || $this->debug_all ? $this->debug() : null ;
245 | 
246 | 			return $return_value;
247 | 
248 | 		}
249 | 
250 | 	}
251 | 


--------------------------------------------------------------------------------
/unsupported/tests/cubrid/ezSQL_cubridTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | require_once('ez_sql_loader.php');
  3 | 
  4 | require 'vendor/autoload.php';
  5 | use PHPUnit\Framework\TestCase;
  6 | 
  7 | /**
  8 |  * Generated by PHPUnit_SkeletonGenerator on 2018-03-08 at 03:16:41.
  9 |  */
 10 | class ezSQL_cubridTest extends TestCase
 11 | {
 12 |         /**
 13 |      * constant string user name 
 14 |      */
 15 |     const TEST_DB_USER = 'ez_test';
 16 |     
 17 |     /**
 18 |      * constant string password 
 19 |      */
 20 |     const TEST_DB_PASSWORD = 'ezTest';
 21 |     
 22 |     /**
 23 |      * constant database name 
 24 |      */
 25 |     const TEST_DB_NAME = 'ez_test';
 26 |     
 27 |     /**
 28 |      * constant database host
 29 |      */
 30 |     const TEST_DB_HOST = 'localhost';
 31 |     
 32 |     /**
 33 |      * constant database port 
 34 |      */
 35 |     const TEST_DB_PORT = 33000;
 36 |     
 37 |     /**
 38 |      * @var ezSQL_cubrid
 39 |      */
 40 |     protected $object;
 41 |     private $errors;
 42 |  
 43 |     function errorHandler($errno, $errstr, $errfile, $errline, $errcontext) {
 44 |         $this->errors[] = compact("errno", "errstr", "errfile",
 45 |             "errline", "errcontext");
 46 |     }
 47 | 
 48 |     function assertError($errstr, $errno) {
 49 |         foreach ($this->errors as $error) {
 50 |             if ($error["errstr"] === $errstr
 51 |                 && $error["errno"] === $errno) {
 52 |                 return;
 53 |             }
 54 |         }
 55 |         $this->fail("Error with level " . $errno .
 56 |             " and message '" . $errstr . "' not found in ", 
 57 |             var_export($this->errors, TRUE));
 58 |     }   
 59 | 
 60 |     /**
 61 |      * Sets up the fixture, for example, opens a network connection.
 62 |      * This method is called before a test is executed.
 63 |      */
 64 |     protected function setUp()
 65 |     {
 66 |         if (!extension_loaded('cubrid')) {
 67 |             $this->markTestSkipped(
 68 |               'The cubrid Lib is not available.'
 69 |             );
 70 |         }
 71 |         $this->object = new ezSQL_cubrid(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME);
 72 |     }
 73 | 
 74 |     /**
 75 |      * Tears down the fixture, for example, closes a network connection.
 76 |      * This method is called after a test is executed.
 77 |      */
 78 |     protected function tearDown()
 79 |     {
 80 |         $this->object->query('DROP TABLE IF EXISTS unit_test');
 81 |         $this->object = null;
 82 |     }
 83 | 
 84 |     /**
 85 |      * @covers ezSQL_cubrid::quick_connect
 86 |      */
 87 |     public function testQuick_connect() {
 88 |         $this->assertTrue($this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME));
 89 |     } // testQuick_connect
 90 | 
 91 |     /**
 92 |      * @covers ezSQL_cubrid::connect
 93 |      * 
 94 |      */
 95 |     public function testConnect() {        
 96 |         $this->errors = array();
 97 |         set_error_handler(array($this, 'errorHandler')); 
 98 |          
 99 |         $this->assertFalse($this->object->connect('',''));  
100 |         $this->assertFalse($this->object->connect('self::TEST_DB_USER', 'self::TEST_DB_PASSWORD',' self::TEST_DB_NAME'));  
101 |         
102 |         $this->assertTrue($this->object->connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME, self::TEST_DB_HOST, self::TEST_DB_PORT));
103 |     } // testConnect
104 |     
105 |     /**
106 |      * @covers ezSQL_cubrid::escape
107 |      */
108 |     public function testEscape() {
109 |         $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME);
110 |         $result = $this->object->escape("This is'nt escaped.");
111 | 
112 |         $this->assertEquals("This is''nt escaped.", $result);
113 |     } // testEscape
114 | 
115 |     /**
116 |      * @covers ezSQL_cubrid::sysdate
117 |      */
118 |     public function testSysdate() {
119 |         $this->assertEquals('NOW()', $this->object->sysdate());
120 |     } // testSysdate
121 |     
122 |     /**
123 |      * @covers ezSQLcore::get_var
124 |      */
125 |     public function testGet_var() { 
126 |         $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME); 
127 |         // Demo of getting a single variable from the db
128 |         // (and using abstracted function sysdate)   
129 |         $current_time = $this->object->get_var("SELECT " . $this->object->sysdate());
130 |         $this->assertNotNull($current_time);
131 |     } // testGet_var
132 | 
133 |     /**
134 |      * @covers ezSQLcore::get_results
135 |      */
136 |     public function testGet_results() {           
137 |     $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME);    
138 |     
139 | 	// Get list of tables from current database..
140 | 	$my_tables = $this->object->get_results("SHOW TABLES",ARRAY_N);
141 |     $this->assertNotNull($my_tables);
142 |     
143 | 	// Loop through each row of results..
144 | 	foreach ( $my_tables as $table )
145 |         {
146 |             // Get results of DESC table..
147 |             $this->assertNotNull($this->object->get_results("DESC $table[0]"));
148 |         }
149 |     } // testGet_results
150 |     
151 |     /**
152 |      * @covers ezSQL_cubrid::query
153 |      */
154 |     public function testQuery() {
155 |         $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME); 
156 |         $this->assertNotFalse($this->object->query('CREATE TABLE unit_test(id int, test_key varchar(50), PRIMARY KEY (ID))'));
157 |         $this->assertEquals($this->object->query('INSERT INTO unit_test(id, test_key) VALUES(1, \'test 1\')'), 1);
158 |         
159 |         $this->object->dbh = null;
160 |         $this->assertEquals($this->object->query('INSERT INTO unit_test(id, test_key) VALUES(2, \'test 2\')'),1);
161 |         $this->object->disconnect();
162 |         $this->assertFalse($this->object->query('INSERT INTO unit_test(id, test_key) VALUES(3, \'test 3\')'));    
163 |     } // testQuery
164 | 
165 |     /**
166 |      * @covers ezSQLcore::insert
167 |      */
168 |     public function testInsert()
169 |     {
170 |         $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME);  
171 |         $this->object->query('DROP TABLE IF EXISTS unit_test');  
172 |         $this->object->query('CREATE TABLE unit_test(id int, test_key varchar(50), PRIMARY KEY (ID))');
173 |         
174 |         $result = $this->object->insert('unit_test', array('id'=>'1', 'test_key'=>'test 1' ));
175 |         $this->assertEquals(0, $result);
176 |     }
177 |        
178 |     /**
179 |      * @covers ezSQLcore::update
180 |      */
181 |     public function testUpdate()
182 |     {
183 |         $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME);    
184 |         $this->object->query('CREATE TABLE unit_test(id int, test_key varchar(50), PRIMARY KEY (ID))');
185 |         $this->object->insert('unit_test', array('id'=>'1', 'test_key'=>'test 1' ));
186 |         $this->object->insert('unit_test', array('id'=>'2', 'test_key'=>'test 2' ));
187 |         $this->object->insert('unit_test', array('id'=>'3', 'test_key'=>'test 3' ));
188 |         $unit_test['test_key'] = 'testing';
189 |         $where="id  =  1";
190 |         $this->assertEquals($this->object->update('unit_test', $unit_test, $where), 1);
191 |         $this->assertEquals($this->object->update('unit_test', $unit_test, eq('test_key','test 3', _AND), eq('id','3')), 1);
192 |         $this->assertEquals($this->object->update('unit_test', $unit_test, "id = 4"), 0);
193 |         $this->assertEquals($this->object->update('unit_test', $unit_test, "test_key  =  test 2  and", "id  =  2"), 1);
194 |     }
195 |     
196 |     /**
197 |      * @covers ezSQLcore::delete
198 |      */
199 |     public function testDelete()
200 |     {
201 |         $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME);    
202 |         $this->object->query('CREATE TABLE unit_test(id int, test_key varchar(50), PRIMARY KEY (ID))');
203 |         $unit_test['id'] = '1';
204 |         $unit_test['test_key'] = 'test 1';
205 |         $this->object->insert('unit_test', $unit_test );
206 |         $unit_test['id'] = '2';
207 |         $unit_test['test_key'] = 'test 2';
208 |         $this->object->insert('unit_test', $unit_test );
209 |         $unit_test['id'] = '3';
210 |         $unit_test['test_key'] = 'test 3';
211 |         $this->object->insert('unit_test', $unit_test );
212 |         $where='1';
213 |         $this->assertEquals($this->object->delete('unit_test', array('id','=','1')), 1);
214 |         $this->assertEquals($this->object->delete('unit_test', 
215 |             array('test_key','=',$unit_test['test_key'],'and'),
216 |             array('id','=','3')), 1);
217 |         $this->assertEquals($this->object->delete('unit_test', array('test_key','=',$where)), 0);
218 |         $where="id  =  2";
219 |         $this->assertEquals($this->object->delete('unit_test', $where), 1);
220 |     }  
221 | 
222 |     /**
223 |      * @covers ezSQLcore::selecting
224 |      */
225 |     public function testSelecting()
226 |     {
227 |         $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME);    
228 |         $this->object->query('CREATE TABLE unit_test(id int, test_key varchar(50), PRIMARY KEY (ID))');
229 |         $this->object->insert('unit_test', array('id'=>'1', 'test_key'=>'testing 1' ));
230 |         $this->object->insert('unit_test', array('id'=>'2', 'test_key'=>'testing 2' ));
231 |         $this->object->insert('unit_test', array('id'=>'3', 'test_key'=>'testing 3' ));
232 |         
233 |         $result = $this->object->selecting('unit_test');
234 |         $i = 1;
235 |         foreach ($result as $row) {
236 |             $this->assertEquals($i, $row->id);
237 |             $this->assertEquals('testing ' . $i, $row->test_key);
238 |             ++$i;
239 |         }
240 |         
241 |         $where=eq('test_key','testing 2');
242 |         $result = $this->object->selecting('unit_test', 'id', $where);
243 |         foreach ($result as $row) {
244 |             $this->assertEquals(2, $row->id);
245 |         }
246 |         
247 |         $result = $this->object->selecting('unit_test', 'test_key', eq( 'id','3' ));
248 |         foreach ($result as $row) {
249 |             $this->assertEquals('testing 3', $row->test_key);
250 |         }
251 |         
252 |         $result = $this->object->selecting('unit_test', array ('test_key'), "id  =  1");
253 |         foreach ($result as $row) {
254 |             $this->assertEquals('testing 1', $row->test_key);
255 |         }
256 |     } 
257 | 	
258 |     /**
259 |      * @covers ezSQL_cubrid::disconnect
260 |      */
261 |     public function testDisconnect() {
262 |         $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME);    
263 |         $this->object->disconnect();
264 |         $this->assertFalse($this->object->isConnected());
265 |     } // testDisconnect
266 |     
267 |     /**
268 |      * @covers ezSQL_cubrid::__construct
269 |      */
270 |     public function test__Construct() {   
271 |         $this->errors = array();
272 |         set_error_handler(array($this, 'errorHandler'));    
273 |         
274 |         $cubrid = $this->getMockBuilder(ezSQL_cubrid::class)
275 |         ->setMethods(null)
276 |         ->disableOriginalConstructor()
277 |         ->getMock();
278 |         
279 |         $this->assertNull($cubrid->__construct());  
280 |     } 
281 | }
282 | 


--------------------------------------------------------------------------------
/unsupported/tests/oracle8_9/ezSQL_oracle8_9Test.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | require_once('ez_sql_loader.php');
  3 | 
  4 | require 'vendor/autoload.php';
  5 | use PHPUnit\Framework\TestCase;
  6 | 
  7 | /**
  8 |  * Test class for ezSQL_oracle8_9.
  9 |  * Desc..: Oracle 8 + 9 component (part of ezSQL databse abstraction library)
 10 |  * 
 11 |  * @author  Justin Vincent (jv@jvmultimedia.com)
 12 |  * @author  Stefanie Janine Stoelting <mail@stefanie-stoelting.de>
 13 |  * @link    http://twitter.com/justinvincent
 14 |  * @name    ezSQL_oracle8_9Test
 15 |  * @package ezSQL
 16 |  * @subpackage Tests
 17 |  * @license FREE / Donation (LGPL - You may do what you like with ezSQL - no exceptions.)
 18 |  * @todo The connection to Oracle is not tested by now. There might also be 
 19 |  *       tests done for different versions of Oracle
 20 |  *
 21 |  */
 22 | class ezSQL_oracle8_9Test extends TestCase {
 23 | 
 24 |     /**
 25 |      * @var ezSQL_oracle8_9
 26 |      */
 27 |     protected $object;
 28 |     private $errors;
 29 |  
 30 |     function errorHandler($errno, $errstr, $errfile, $errline, $errcontext) {
 31 |         $this->errors[] = compact("errno", "errstr", "errfile",
 32 |             "errline", "errcontext");
 33 |     }
 34 | 
 35 |     function assertError($errstr, $errno) {
 36 |         foreach ($this->errors as $error) {
 37 |             if ($error["errstr"] === $errstr
 38 |                 && $error["errno"] === $errno) {
 39 |                 return;
 40 |             }
 41 |         }
 42 |         $this->fail("Error with level " . $errno .
 43 |             " and message '" . $errstr . "' not found in ", 
 44 |             var_export($this->errors, TRUE));
 45 |     }   
 46 | 
 47 |     /**
 48 |      * Sets up the fixture, for example, opens a network connection.
 49 |      * This method is called before a test is executed.
 50 |      */
 51 |     protected function setUp() {
 52 |         if (!extension_loaded('oci8_12c')) {
 53 |             $this->markTestSkipped(
 54 |               'The Oracle OCI Lib is not available.'
 55 |             );
 56 |         }
 57 |         $this->object = new ezSQL_oracle8_9;
 58 |     } // setUp
 59 | 
 60 |     /**
 61 |      * Tears down the fixture, for example, closes a network connection.
 62 |      * This method is called after a test is executed.
 63 |      */
 64 |     protected function tearDown() {
 65 |         $this->object = null;
 66 |     } // tearDown
 67 | 
 68 |     /**
 69 |      * @covers ezSQL_oracle8_9::connect
 70 |      * @todo Implement testConnect().
 71 |      */
 72 |     public function testConnect() {
 73 |         // Remove the following lines when you implement this test.
 74 |         $this->markTestIncomplete(
 75 |                 'This test has not been implemented yet.'
 76 |         );
 77 |     } // testConnect
 78 | 
 79 |     /**
 80 |      * @covers ezSQL_oracle8_9::quick_connect
 81 |      * @todo Implement testQuick_connect().
 82 |      */
 83 |     public function testQuick_connect() {
 84 |         // Remove the following lines when you implement this test.
 85 |         $this->markTestIncomplete(
 86 |                 'This test has not been implemented yet.'
 87 |         );
 88 |     } // testQuick_connect
 89 | 
 90 |     /**
 91 |      * @covers ezSQL_oracle8_9::select
 92 |      * @todo Implement testSelect().
 93 |      */
 94 |     public function testSelect() {
 95 |         // Remove the following lines when you implement this test.
 96 |         $this->markTestIncomplete(
 97 |                 'This test has not been implemented yet.'
 98 |         );
 99 |     } // testSelect
100 | 
101 |     /**
102 |      * @covers ezSQL_oracle8_9::escape
103 |      */
104 |     public function testEscape() {
105 |         $result = $this->object->escape("This is'nt escaped.");
106 | 
107 |         $this->assertEquals("This is''nt escaped.", $result);
108 |     } // testEscape
109 | 
110 |     /**
111 |      * @covers ezSQL_oracle8_9::sysdate
112 |      */
113 |     public function testSysdate() {
114 |         $this->assertEquals('SYSDATE', $this->object->sysdate());
115 |     } // testSysdate
116 | 
117 |     /**
118 |      * @covers ezSQL_oracle8_9::is_equal_str
119 |      */
120 |     public function testIs_equal_str() {
121 |         $expected = '= \'ezTest string\'';
122 |         
123 |         $this->assertEquals($expected, $this->object->is_equal_str('ezTest string'));
124 |     } // testIs_equal_str
125 | 
126 |     /**
127 |      * @covers ezSQL_oracle8_9::is_equal_int
128 |      */
129 |     public function testIs_equal_int() {
130 |         $expected = '= 123';
131 |         
132 |         $this->assertEquals($expected, $this->object->is_equal_int(123));
133 |     } // testIs_equal_int
134 | 
135 |     /**
136 |      * @covers ezSQL_oracle8_9::insert_id
137 |      * @todo Implement testInsert_id().
138 |      */
139 |     public function testInsert_id() {
140 |         // Remove the following lines when you implement this test.
141 |         $this->markTestIncomplete(
142 |                 'This test has not been implemented yet.'
143 |         );
144 |     } // testInsert_id
145 | 
146 |     /**
147 |      * @covers ezSQL_oracle8_9::nextVal
148 |      * @todo Implement testNextVal().
149 |      */
150 |     public function testNextVal() {
151 |         // Remove the following lines when you implement this test.
152 |         $this->markTestIncomplete(
153 |                 'This test has not been implemented yet.'
154 |         );
155 |     } // testNextVal
156 | 
157 |     /**
158 |      * @covers ezSQL_oracle8_9::query
159 |      * @todo Implement testQuery().
160 |      */
161 |     public function testQuery() {
162 |         // Remove the following lines when you implement this test.
163 |         $this->markTestIncomplete(
164 |                 'This test has not been implemented yet.'
165 |         );
166 |     } // testQuery
167 | 
168 |     /**
169 |      * @covers ezSQL_oracle8_9::disconnect
170 |      * @todo Implement testDisconnect().
171 |      */
172 |     public function testDisconnect() {
173 |         // Remove the following lines when you implement this test.
174 |         $this->markTestIncomplete(
175 |                 'This test has not been implemented yet.'
176 |         );
177 |     } // testDisconnect
178 | 
179 |     /**
180 |      * @covers ezSQL_oracle8_9::getDBName
181 |      * @todo Implement testGetDBName().
182 |      */
183 |     public function testGetDBName() {
184 |         // Remove the following lines when you implement this test.
185 |         $this->markTestIncomplete(
186 |                 'This test has not been implemented yet.'
187 |         );
188 |     } // testGetDBName
189 |     
190 |     /**
191 |      * @covers ezSQLcore::get_var
192 |      */
193 |     public function testGet_var() { 
194 |         $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME); 
195 |         // Demo of getting a single variable from the db
196 |         // (and using abstracted function sysdate)   
197 |         $current_time = $this->object->get_var("SELECT " . $this->object->sysdate() . " FROM DUAL");
198 |         $this->assertNotNull($current_time);
199 |     } // testGet_var
200 | 
201 |     /**
202 |      * @covers ezSQLcore::get_results
203 |      */
204 |     public function testGet_results() {           
205 |     $this->object->quick_connect(self::TEST_DB_USER, self::TEST_DB_PASSWORD, self::TEST_DB_NAME);    
206 |     
207 | 	// Get list of tables from current database..
208 | 	$my_tables = $this->object->get_results("SELECT TABLE_NAME FROM USER_TABLES",ARRAY_N);
209 |     $this->assertNotNull($my_tables);
210 |     
211 | 	// Loop through each row of results..
212 | 	foreach ( $my_tables as $table )
213 |         {
214 |             // Get results of DESC table..
215 |             $this->assertNotNull($this->object->get_results("SELECT COLUMN_NAME, DATA_TYPE, DATA_LENGTH, DATA_PRECISION FROM USER_TAB_COLUMNS WHERE TABLE_NAME = '$table[0]'"));
216 |         }
217 |     } // testGet_results
218 |     
219 |     /**
220 |      * @covers ezSQL_oracle8_9::__construct
221 |      */
222 |     public function test__Construct() {   
223 |         $this->errors = array();
224 |         set_error_handler(array($this, 'errorHandler'));    
225 |         
226 |         $oracle8_9 = $this->getMockBuilder(ezSQL_oracle8_9::class)
227 |         ->setMethods(null)
228 |         ->disableOriginalConstructor()
229 |         ->getMock();
230 |         
231 |         $this->assertNull($oracle8_9->__construct());  
232 |     } 
233 |     
234 | } // ezSQL_oracle8_9Test


--------------------------------------------------------------------------------
/unsupported/tests/oracle8_9/ezSQL_oracleTNSTest_.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | require_once('ez_sql_loader.php');
  3 | 
  4 | require 'vendor/autoload.php';
  5 | use PHPUnit\Framework\TestCase;
  6 | 
  7 | /**
  8 |  * Test class for ezSQL_oracleTNS.
  9 |  * Desc..: Oracle TNS component (part of ezSQL databse abstraction library)
 10 |  *
 11 |  * @author  Justin Vincent (jv@jvmultimedia.com)
 12 |  * @author  Stefanie Janine Stoelting (mail@stefanie-stoelting.de)
 13 |  * @link    http://twitter.com/justinvincent
 14 |  * @name    ezSQL_oracleTNSTest
 15 |  * @package ezSQL
 16 |  * @subpackage Tests
 17 |  * @license FREE / Donation (LGPL - You may do what you like with ezSQL - no exceptions.)
 18 |  */
 19 | class ezSQL_oracleTNSTest extends TestCase {
 20 | 
 21 |     /**
 22 |      * @var ezSQL_oracleTNS
 23 |      */
 24 |     protected $object;
 25 |     private $errors;
 26 |  
 27 |     function errorHandler($errno, $errstr, $errfile, $errline, $errcontext) {
 28 |         $this->errors[] = compact("errno", "errstr", "errfile",
 29 |             "errline", "errcontext");
 30 |     }
 31 | 
 32 |     function assertError($errstr, $errno) {
 33 |         foreach ($this->errors as $error) {
 34 |             if ($error["errstr"] === $errstr
 35 |                 && $error["errno"] === $errno) {
 36 |                 return;
 37 |             }
 38 |         }
 39 |         $this->fail("Error with level " . $errno .
 40 |             " and message '" . $errstr . "' not found in ", 
 41 |             var_export($this->errors, TRUE));
 42 |     }   
 43 | 
 44 |     /**
 45 |      * The connection parameters for the Oracle DB connection
 46 |      * @var array
 47 |      */
 48 |     private $oraConnectionParamsTestConnection = array(
 49 |         'User'          => 'CMP',
 50 |         'Password'      => 'cmp',
 51 |         'Host'          => 'en-yoda-1',
 52 |         'Port'          => '1521',
 53 |         'SessionName'   => 'ppisa.febi.bilstein.local',
 54 |         'TNS'           => 'AL32UTF8'
 55 |     );
 56 | 
 57 |     private $sequenceName = 'UNITTEST_ORATNS';
 58 | 
 59 |     /**
 60 |      * Sets up the fixture, for example, opens a network connection.
 61 |      * This method is called before a test is executed.
 62 |      */
 63 |     protected function setUp() {
 64 |         if (!extension_loaded('oci8_12c')) {
 65 |             $this->markTestSkipped(
 66 |               'The Oracle OCI Lib is not available.'
 67 |             );
 68 |         }
 69 |         $this->object = new ezSQL_oracleTNS(
 70 |                     $this->oraConnectionParamsTestConnection['Host'],
 71 |                     $this->oraConnectionParamsTestConnection['Port'],
 72 |                     $this->oraConnectionParamsTestConnection['SessionName'],
 73 |                     $this->oraConnectionParamsTestConnection['User'],
 74 |                     $this->oraConnectionParamsTestConnection['Password'],
 75 |                     $this->oraConnectionParamsTestConnection['TNS']
 76 |                 );
 77 | 
 78 |         // Create the sequence
 79 |         $sql = 'CREATE SEQUENCE ' . $this->sequenceName;
 80 |         $this->object->query($sql);
 81 | 
 82 |     } // setUp
 83 | 
 84 |     /**
 85 |      * Tears down the fixture, for example, closes a network connection.
 86 |      * This method is called after a test is executed.
 87 |      */
 88 |     protected function tearDown() {
 89 |         // Drop the sequence
 90 |         //$sql = 'DROP SEQUENCE ' . $this->sequenceName;
 91 |         //$this->object->query($sql);
 92 | 
 93 |         $this->object = null;
 94 |     } // tearDown
 95 | 
 96 |     /**
 97 |      * @covers ezSQL_oracleTNS::connect
 98 |      */
 99 |     public function testConnect() {
100 |         $this->object->connect(
101 |                     $this->oraConnectionParamsTestConnection['User'],
102 |                     $this->oraConnectionParamsTestConnection['Password']
103 |                 );
104 |         $this->assertTrue($this->object->isConnected());
105 |     } // testConnect
106 | 
107 |     /**
108 |      * To test connection pooling with oci_pconnect instead of oci_connect
109 |      * @covers ezSQL_oracleTNS::connect
110 |      */
111 |     public function testPConnect() {
112 |         $this->object = null;
113 | 
114 |         $this->object = new ezSQL_oracleTNS(
115 |                     $this->oraConnectionParamsTestConnection['Host'],
116 |                     $this->oraConnectionParamsTestConnection['Port'],
117 |                     $this->oraConnectionParamsTestConnection['SessionName'],
118 |                     $this->oraConnectionParamsTestConnection['User'],
119 |                     $this->oraConnectionParamsTestConnection['Password'],
120 |                     $this->oraConnectionParamsTestConnection['TNS'],
121 |                     true
122 |                 );
123 | 
124 |         $this->object->connect(
125 |                     $this->oraConnectionParamsTestConnection['User'],
126 |                     $this->oraConnectionParamsTestConnection['Password']
127 |                 );
128 |         $this->assertTrue($this->object->isConnected());
129 | 
130 |         $sql = 'SELECT 5*5 AS TEST_RESULT FROM DUAL';
131 | 
132 |         $recordset = $this->object->query($sql);
133 |         $this->assertEquals(1, $recordset);
134 |     } // testPConnect
135 | 
136 |     /**
137 |      * @covers ezSQL_oracleTNS::quick_connect
138 |      */
139 |     public function testQuick_connect() {
140 |         $this->object->quick_connect(
141 |                     $this->oraConnectionParamsTestConnection['User'],
142 |                     $this->oraConnectionParamsTestConnection['Password']
143 |                 );
144 |         $this->assertTrue(true);
145 |     } // testQuick_connect
146 | 
147 |     /**
148 |      * @covers ezSQL_oracleTNS::select
149 |      */
150 |     public function testSelect() {
151 |         $this->object->select(
152 |                     $this->oraConnectionParamsTestConnection['User'],
153 |                     $this->oraConnectionParamsTestConnection['Password']
154 |                 );
155 |         $this->assertTrue(true);
156 |     } // testSelect
157 | 
158 |     /**
159 |      * @covers ezSQL_oracleTNS::escape
160 |      */
161 |     public function testEscape() {
162 |         $result = $this->object->escape("This is'nt escaped.");
163 | 
164 |         $this->assertEquals("This is''nt escaped.", $result);
165 |     } // testEscape
166 | 
167 |     /**
168 |      * @covers ezSQL_oracleTNS::sysdate
169 |      */
170 |     public function testSysdate() {
171 |         $this->assertEquals('SYSDATE', $this->object->sysdate());
172 |     } // testSysdate
173 | 
174 |     /**
175 |      * @covers ezSQL_oracleTNS::is_equal_str
176 |      */
177 |     public function testIs_equal_str() {
178 |         $expected = '= \'ezTest string\'';
179 | 
180 |         $this->assertEquals($expected, $this->object->is_equal_str('ezTest string'));
181 |     } // testIs_equal_str
182 | 
183 |     /**
184 |      * @covers ezSQL_oracleTNS::is_equal_int
185 |      */
186 |     public function testIs_equal_int() {
187 |         $expected = '= 123';
188 | 
189 |         $this->assertEquals($expected, $this->object->is_equal_int(123));
190 |     } // testIs_equal_int
191 | 
192 |     /**
193 |      * @covers ezSQL_oracleTNS::insert_id
194 |      */
195 |     public function testInsert_id() {
196 |         $this->object->connect(
197 |                     $this->oraConnectionParamsTestConnection['User'],
198 |                     $this->oraConnectionParamsTestConnection['Password']
199 |                 );
200 | 
201 |         $result = $this->object->insert_id($this->sequenceName);
202 | 
203 |         $this->assertEquals(1, $result);
204 | 
205 |         $result = $this->object->insert_id($this->sequenceName);
206 | 
207 |         $this->assertEquals(2, $result);
208 |     } // testInsert_id
209 | 
210 |     /**
211 |      * @covers ezSQL_oracleTNS::nextVal
212 |      */
213 |     public function testNextVal() {
214 |         $this->object->connect(
215 |                     $this->oraConnectionParamsTestConnection['User'],
216 |                     $this->oraConnectionParamsTestConnection['Password']
217 |                 );
218 |         $result = $this->object->nextVal($this->sequenceName);
219 | 
220 |         $this->assertEquals(1, $result);
221 | 
222 |         $result = $this->object->nextVal($this->sequenceName);
223 | 
224 |         $this->assertEquals(2, $result);
225 |     } // testNextVal
226 | 
227 |     /**
228 |      * @covers ezSQL_oracleTNS::query
229 |      */
230 |     public function testQuery() {
231 |         $this->object->connect(
232 |                     $this->oraConnectionParamsTestConnection['User'],
233 |                     $this->oraConnectionParamsTestConnection['Password']
234 |                 );
235 | 
236 |         $sql = 'SELECT 5*5 AS TEST_RESULT FROM DUAL';
237 | 
238 |         $recordset = $this->object->query($sql);
239 |         $this->assertEquals(1, $recordset);
240 |     } // testQuery
241 | 
242 |     /**
243 |      * @covers ezSQL_oracleTNS::disconnect
244 |      */
245 |     public function testDisconnect() {
246 |         $this->object->disconnect();
247 | 
248 |         $this->assertFalse($this->object->isConnected());
249 |     } // testDisconnect
250 |        
251 |     /**
252 |      * @covers ezSQL_oracleTNS::__construct
253 |      */
254 |     public function test__Construct() {            
255 |         $oracle = $this->getMockBuilder(ezSQL_oracleTNS::class)
256 |         ->setMethods(null)
257 |         ->disableOriginalConstructor()
258 |         ->getMock();
259 |         
260 |         $this->assertNull($oracle->__construct());  
261 |     } 
262 | } // ezSQL_oracleTNSTest


--------------------------------------------------------------------------------