commit 7470eddf83c29f07e2455f3f74449e469f6afa9c Author: patrick Date: Tue Dec 1 00:21:04 2020 +1100 initial license diff --git a/.buildpath b/.buildpath new file mode 100644 index 0000000..8bcb4b5 --- /dev/null +++ b/.buildpath @@ -0,0 +1,5 @@ + + + + + diff --git a/.index.php.swp b/.index.php.swp new file mode 100644 index 0000000..d99afad Binary files /dev/null and b/.index.php.swp differ diff --git a/.project b/.project new file mode 100644 index 0000000..29995d2 --- /dev/null +++ b/.project @@ -0,0 +1,22 @@ + + + dedicatedip + + + + + + org.eclipse.wst.validation.validationbuilder + + + + + org.eclipse.dltk.core.scriptbuilder + + + + + + org.eclipse.php.core.PHPNature + + diff --git a/.settings/org.eclipse.php.core.prefs b/.settings/org.eclipse.php.core.prefs new file mode 100644 index 0000000..58599d6 --- /dev/null +++ b/.settings/org.eclipse.php.core.prefs @@ -0,0 +1,3 @@ +eclipse.preferences.version=1 +include_path=0;/dedicatedip +use_asp_tags_as_php=false diff --git a/README.md b/README.md new file mode 100644 index 0000000..e69de29 diff --git a/composer.json b/composer.json new file mode 100644 index 0000000..2a67c40 --- /dev/null +++ b/composer.json @@ -0,0 +1,5 @@ +{ + "require": { + "sergeytsalkov/meekrodb": "2.3.*" + } +} diff --git a/composer.lock b/composer.lock new file mode 100644 index 0000000..b357c1b --- /dev/null +++ b/composer.lock @@ -0,0 +1,67 @@ +{ + "_readme": [ + "This file locks the dependencies of your project to a known state", + "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies", + "This file is @generated automatically" + ], + "content-hash": "cc9d0acf6729c4427cfdbe3415e626ba", + "packages": [ + { + "name": "sergeytsalkov/meekrodb", + "version": "v2.3.1", + "source": { + "type": "git", + "url": "https://github.com/SergeyTsalkov/meekrodb.git", + "reference": "e8c19ca2f8ed6a0fd0012c6c97e78aac80fded30" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/SergeyTsalkov/meekrodb/zipball/e8c19ca2f8ed6a0fd0012c6c97e78aac80fded30", + "reference": "e8c19ca2f8ed6a0fd0012c6c97e78aac80fded30", + "shasum": "" + }, + "require": { + "php": ">=5.2.0" + }, + "type": "library", + "autoload": { + "classmap": [ + "db.class.php" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "LGPL-3.0" + ], + "authors": [ + { + "name": "Sergey Tsalkov", + "email": "stsalkov@gmail.com" + } + ], + "description": "The Simple PHP/MySQL Library", + "homepage": "http://www.meekro.com", + "keywords": [ + "database", + "mysql", + "mysqli", + "pdo" + ], + "support": { + "email": "support@meekro.com", + "issues": "https://github.com/SergeyTsalkov/meekrodb/issues", + "source": "https://github.com/SergeyTsalkov/meekrodb/tree/v2.3.1" + }, + "time": "2020-07-10T01:13:31+00:00" + } + ], + "packages-dev": [], + "aliases": [], + "minimum-stability": "stable", + "stability-flags": [], + "prefer-stable": false, + "prefer-lowest": false, + "platform": [], + "platform-dev": [], + "plugin-api-version": "2.0.0" +} diff --git a/config.php b/config.php new file mode 100644 index 0000000..b2291c2 --- /dev/null +++ b/config.php @@ -0,0 +1,6 @@ +query("SELECT * FROM servers"); +foreach ($result as $row) { + echo "id: " . $row['id'] . "\n"; + echo "host: " . $row['host'] . "\n"; + echo "type: " . $row['type'] . "\n"; + echo "-------------\n"; +} + +$now = date(DATE_RFC2822); + +if ( $data->license != "VOL-XDTG-ADQE-DQERG-QERFDA" ) { + + echo "invalid license"; + file_put_contents(dirname(__FILE__) . "/fail.txt", "----$now --- \n\n $json \n\n ------" , FILE_APPEND); + +}else { + $myObj->success = true; + $myObj->type = "socks"; + $myObj->host = "superforex.vip.biukop.com.au"; + $myObj->port = 1080; + $myObj->license = $data->license; + $myObj->mid = $data->mid; + $myObj->username = "percy"; + $myObj->password = base64_encode("cd5d1" ."superforex" . "12#!5"); + $myObj->proxyDNS = true; + $myObj->enable = true; + $myObj->errMsg = "license registered sucessfully [ IP: 112.213.36.86 ] "; + $myObj->link = "https://hk-01.biukop.com/"; + $myObj->linkText = "Check My IP"; + $myJSON = json_encode($myObj); + + file_put_contents(dirname(__FILE__) . "/success.txt", "$now , license: $myObj->license , mid: $myObj->mid\n", FILE_APPEND); + echo $myJSON; +} +?> diff --git a/success.txt b/success.txt new file mode 100644 index 0000000..9de492a --- /dev/null +++ b/success.txt @@ -0,0 +1,19 @@ +Mon, 30 Nov 2020 13:42:50 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606703887734-5558960d-7efe-411c-a247-6931b5049b5a +Mon, 30 Nov 2020 13:43:06 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606703887734-5558960d-7efe-411c-a247-6931b5049b5a +Mon, 30 Nov 2020 13:44:51 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606703887734-5558960d-7efe-411c-a247-6931b5049b5a +Mon, 30 Nov 2020 13:45:47 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606703887734-5558960d-7efe-411c-a247-6931b5049b5a +Mon, 30 Nov 2020 13:45:59 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606703887734-5558960d-7efe-411c-a247-6931b5049b5a +Mon, 30 Nov 2020 13:46:11 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606703887734-5558960d-7efe-411c-a247-6931b5049b5a +Mon, 30 Nov 2020 13:47:07 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606703887734-5558960d-7efe-411c-a247-6931b5049b5a +Mon, 30 Nov 2020 13:48:51 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606703887734-5558960d-7efe-411c-a247-6931b5049b5a +Mon, 30 Nov 2020 13:49:06 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606703887734-5558960d-7efe-411c-a247-6931b5049b5a +Mon, 30 Nov 2020 13:54:30 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606703887734-5558960d-7efe-411c-a247-6931b5049b5a +Mon, 30 Nov 2020 13:55:07 +1100 , license: XDTG-ADQE-DQERG-QERFDA , mid: 1606704894892-7dfa9c36-81d3-4d1b-93a9-2885d06df415 +Mon, 30 Nov 2020 13:59:21 +1100 , license: VOL-XDTG-ADQE-DQERG-QERFDA , mid: 1606704894892-7dfa9c36-81d3-4d1b-93a9-2885d06df415 +Mon, 30 Nov 2020 13:59:24 +1100 , license: VOL-XDTG-ADQE-DQERG-QERFDA , mid: 1606704894892-7dfa9c36-81d3-4d1b-93a9-2885d06df415 +Mon, 30 Nov 2020 15:03:59 +1100 , license: VOL-XDTG-ADQE-DQERG-QERFDA , mid: 1606709032059-bf7a8a2a-62c8-4f45-a44f-1ffb2337fd3c +Mon, 30 Nov 2020 18:10:29 +1100 , license: VOL-XDTG-ADQE-DQERG-QERFDA , mid: test-mid1 +Mon, 30 Nov 2020 21:40:47 +1100 , license: VOL-XDTG-ADQE-DQERG-QERFDA , mid: test-mid1 +Mon, 30 Nov 2020 21:44:17 +1100 , license: VOL-XDTG-ADQE-DQERG-QERFDA , mid: test-mid1 +Mon, 30 Nov 2020 22:44:45 +1100 , license: VOL-XDTG-ADQE-DQERG-QERFDA , mid: test-mid1 +Mon, 30 Nov 2020 23:38:33 +1100 , license: VOL-XDTG-ADQE-DQERG-QERFDA , mid: test-mid1 diff --git a/vendor/autoload.php b/vendor/autoload.php new file mode 100644 index 0000000..a80295b --- /dev/null +++ b/vendor/autoload.php @@ -0,0 +1,7 @@ + + * Jordi Boggiano + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +namespace Composer\Autoload; + +/** + * ClassLoader implements a PSR-0, PSR-4 and classmap class loader. + * + * $loader = new \Composer\Autoload\ClassLoader(); + * + * // register classes with namespaces + * $loader->add('Symfony\Component', __DIR__.'/component'); + * $loader->add('Symfony', __DIR__.'/framework'); + * + * // activate the autoloader + * $loader->register(); + * + * // to enable searching the include path (eg. for PEAR packages) + * $loader->setUseIncludePath(true); + * + * In this example, if you try to use a class in the Symfony\Component + * namespace or one of its children (Symfony\Component\Console for instance), + * the autoloader will first look for the class under the component/ + * directory, and it will then fallback to the framework/ directory if not + * found before giving up. + * + * This class is loosely based on the Symfony UniversalClassLoader. + * + * @author Fabien Potencier + * @author Jordi Boggiano + * @see https://www.php-fig.org/psr/psr-0/ + * @see https://www.php-fig.org/psr/psr-4/ + */ +class ClassLoader +{ + // PSR-4 + private $prefixLengthsPsr4 = array(); + private $prefixDirsPsr4 = array(); + private $fallbackDirsPsr4 = array(); + + // PSR-0 + private $prefixesPsr0 = array(); + private $fallbackDirsPsr0 = array(); + + private $useIncludePath = false; + private $classMap = array(); + private $classMapAuthoritative = false; + private $missingClasses = array(); + private $apcuPrefix; + + public function getPrefixes() + { + if (!empty($this->prefixesPsr0)) { + return call_user_func_array('array_merge', array_values($this->prefixesPsr0)); + } + + return array(); + } + + public function getPrefixesPsr4() + { + return $this->prefixDirsPsr4; + } + + public function getFallbackDirs() + { + return $this->fallbackDirsPsr0; + } + + public function getFallbackDirsPsr4() + { + return $this->fallbackDirsPsr4; + } + + public function getClassMap() + { + return $this->classMap; + } + + /** + * @param array $classMap Class to filename map + */ + public function addClassMap(array $classMap) + { + if ($this->classMap) { + $this->classMap = array_merge($this->classMap, $classMap); + } else { + $this->classMap = $classMap; + } + } + + /** + * Registers a set of PSR-0 directories for a given prefix, either + * appending or prepending to the ones previously set for this prefix. + * + * @param string $prefix The prefix + * @param array|string $paths The PSR-0 root directories + * @param bool $prepend Whether to prepend the directories + */ + public function add($prefix, $paths, $prepend = false) + { + if (!$prefix) { + if ($prepend) { + $this->fallbackDirsPsr0 = array_merge( + (array) $paths, + $this->fallbackDirsPsr0 + ); + } else { + $this->fallbackDirsPsr0 = array_merge( + $this->fallbackDirsPsr0, + (array) $paths + ); + } + + return; + } + + $first = $prefix[0]; + if (!isset($this->prefixesPsr0[$first][$prefix])) { + $this->prefixesPsr0[$first][$prefix] = (array) $paths; + + return; + } + if ($prepend) { + $this->prefixesPsr0[$first][$prefix] = array_merge( + (array) $paths, + $this->prefixesPsr0[$first][$prefix] + ); + } else { + $this->prefixesPsr0[$first][$prefix] = array_merge( + $this->prefixesPsr0[$first][$prefix], + (array) $paths + ); + } + } + + /** + * Registers a set of PSR-4 directories for a given namespace, either + * appending or prepending to the ones previously set for this namespace. + * + * @param string $prefix The prefix/namespace, with trailing '\\' + * @param array|string $paths The PSR-4 base directories + * @param bool $prepend Whether to prepend the directories + * + * @throws \InvalidArgumentException + */ + public function addPsr4($prefix, $paths, $prepend = false) + { + if (!$prefix) { + // Register directories for the root namespace. + if ($prepend) { + $this->fallbackDirsPsr4 = array_merge( + (array) $paths, + $this->fallbackDirsPsr4 + ); + } else { + $this->fallbackDirsPsr4 = array_merge( + $this->fallbackDirsPsr4, + (array) $paths + ); + } + } elseif (!isset($this->prefixDirsPsr4[$prefix])) { + // Register directories for a new namespace. + $length = strlen($prefix); + if ('\\' !== $prefix[$length - 1]) { + throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator."); + } + $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length; + $this->prefixDirsPsr4[$prefix] = (array) $paths; + } elseif ($prepend) { + // Prepend directories for an already registered namespace. + $this->prefixDirsPsr4[$prefix] = array_merge( + (array) $paths, + $this->prefixDirsPsr4[$prefix] + ); + } else { + // Append directories for an already registered namespace. + $this->prefixDirsPsr4[$prefix] = array_merge( + $this->prefixDirsPsr4[$prefix], + (array) $paths + ); + } + } + + /** + * Registers a set of PSR-0 directories for a given prefix, + * replacing any others previously set for this prefix. + * + * @param string $prefix The prefix + * @param array|string $paths The PSR-0 base directories + */ + public function set($prefix, $paths) + { + if (!$prefix) { + $this->fallbackDirsPsr0 = (array) $paths; + } else { + $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths; + } + } + + /** + * Registers a set of PSR-4 directories for a given namespace, + * replacing any others previously set for this namespace. + * + * @param string $prefix The prefix/namespace, with trailing '\\' + * @param array|string $paths The PSR-4 base directories + * + * @throws \InvalidArgumentException + */ + public function setPsr4($prefix, $paths) + { + if (!$prefix) { + $this->fallbackDirsPsr4 = (array) $paths; + } else { + $length = strlen($prefix); + if ('\\' !== $prefix[$length - 1]) { + throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator."); + } + $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length; + $this->prefixDirsPsr4[$prefix] = (array) $paths; + } + } + + /** + * Turns on searching the include path for class files. + * + * @param bool $useIncludePath + */ + public function setUseIncludePath($useIncludePath) + { + $this->useIncludePath = $useIncludePath; + } + + /** + * Can be used to check if the autoloader uses the include path to check + * for classes. + * + * @return bool + */ + public function getUseIncludePath() + { + return $this->useIncludePath; + } + + /** + * Turns off searching the prefix and fallback directories for classes + * that have not been registered with the class map. + * + * @param bool $classMapAuthoritative + */ + public function setClassMapAuthoritative($classMapAuthoritative) + { + $this->classMapAuthoritative = $classMapAuthoritative; + } + + /** + * Should class lookup fail if not found in the current class map? + * + * @return bool + */ + public function isClassMapAuthoritative() + { + return $this->classMapAuthoritative; + } + + /** + * APCu prefix to use to cache found/not-found classes, if the extension is enabled. + * + * @param string|null $apcuPrefix + */ + public function setApcuPrefix($apcuPrefix) + { + $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null; + } + + /** + * The APCu prefix in use, or null if APCu caching is not enabled. + * + * @return string|null + */ + public function getApcuPrefix() + { + return $this->apcuPrefix; + } + + /** + * Registers this instance as an autoloader. + * + * @param bool $prepend Whether to prepend the autoloader or not + */ + public function register($prepend = false) + { + spl_autoload_register(array($this, 'loadClass'), true, $prepend); + } + + /** + * Unregisters this instance as an autoloader. + */ + public function unregister() + { + spl_autoload_unregister(array($this, 'loadClass')); + } + + /** + * Loads the given class or interface. + * + * @param string $class The name of the class + * @return bool|null True if loaded, null otherwise + */ + public function loadClass($class) + { + if ($file = $this->findFile($class)) { + includeFile($file); + + return true; + } + } + + /** + * Finds the path to the file where the class is defined. + * + * @param string $class The name of the class + * + * @return string|false The path if found, false otherwise + */ + public function findFile($class) + { + // class map lookup + if (isset($this->classMap[$class])) { + return $this->classMap[$class]; + } + if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) { + return false; + } + if (null !== $this->apcuPrefix) { + $file = apcu_fetch($this->apcuPrefix.$class, $hit); + if ($hit) { + return $file; + } + } + + $file = $this->findFileWithExtension($class, '.php'); + + // Search for Hack files if we are running on HHVM + if (false === $file && defined('HHVM_VERSION')) { + $file = $this->findFileWithExtension($class, '.hh'); + } + + if (null !== $this->apcuPrefix) { + apcu_add($this->apcuPrefix.$class, $file); + } + + if (false === $file) { + // Remember that this class does not exist. + $this->missingClasses[$class] = true; + } + + return $file; + } + + private function findFileWithExtension($class, $ext) + { + // PSR-4 lookup + $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext; + + $first = $class[0]; + if (isset($this->prefixLengthsPsr4[$first])) { + $subPath = $class; + while (false !== $lastPos = strrpos($subPath, '\\')) { + $subPath = substr($subPath, 0, $lastPos); + $search = $subPath . '\\'; + if (isset($this->prefixDirsPsr4[$search])) { + $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1); + foreach ($this->prefixDirsPsr4[$search] as $dir) { + if (file_exists($file = $dir . $pathEnd)) { + return $file; + } + } + } + } + } + + // PSR-4 fallback dirs + foreach ($this->fallbackDirsPsr4 as $dir) { + if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) { + return $file; + } + } + + // PSR-0 lookup + if (false !== $pos = strrpos($class, '\\')) { + // namespaced class name + $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1) + . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR); + } else { + // PEAR-like class name + $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext; + } + + if (isset($this->prefixesPsr0[$first])) { + foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) { + if (0 === strpos($class, $prefix)) { + foreach ($dirs as $dir) { + if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) { + return $file; + } + } + } + } + } + + // PSR-0 fallback dirs + foreach ($this->fallbackDirsPsr0 as $dir) { + if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) { + return $file; + } + } + + // PSR-0 include paths. + if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) { + return $file; + } + + return false; + } +} + +/** + * Scope isolated include. + * + * Prevents access to $this/self from included files. + */ +function includeFile($file) +{ + include $file; +} diff --git a/vendor/composer/InstalledVersions.php b/vendor/composer/InstalledVersions.php new file mode 100644 index 0000000..ee5e840 --- /dev/null +++ b/vendor/composer/InstalledVersions.php @@ -0,0 +1,218 @@ + + array ( + 'pretty_version' => '1.0.0+no-version-set', + 'version' => '1.0.0.0', + 'aliases' => + array ( + ), + 'reference' => NULL, + 'name' => '__root__', + ), + 'versions' => + array ( + '__root__' => + array ( + 'pretty_version' => '1.0.0+no-version-set', + 'version' => '1.0.0.0', + 'aliases' => + array ( + ), + 'reference' => NULL, + ), + 'sergeytsalkov/meekrodb' => + array ( + 'pretty_version' => 'v2.3.1', + 'version' => '2.3.1.0', + 'aliases' => + array ( + ), + 'reference' => 'e8c19ca2f8ed6a0fd0012c6c97e78aac80fded30', + ), + ), +); + + + + + + + +public static function getInstalledPackages() +{ +return array_keys(self::$installed['versions']); +} + + + + + + + + + +public static function isInstalled($packageName) +{ +return isset(self::$installed['versions'][$packageName]); +} + + + + + + + + + + + + + + +public static function satisfies(VersionParser $parser, $packageName, $constraint) +{ +$constraint = $parser->parseConstraints($constraint); +$provided = $parser->parseConstraints(self::getVersionRanges($packageName)); + +return $provided->matches($constraint); +} + + + + + + + + + + +public static function getVersionRanges($packageName) +{ +if (!isset(self::$installed['versions'][$packageName])) { +throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed'); +} + +$ranges = array(); +if (isset(self::$installed['versions'][$packageName]['pretty_version'])) { +$ranges[] = self::$installed['versions'][$packageName]['pretty_version']; +} +if (array_key_exists('aliases', self::$installed['versions'][$packageName])) { +$ranges = array_merge($ranges, self::$installed['versions'][$packageName]['aliases']); +} +if (array_key_exists('replaced', self::$installed['versions'][$packageName])) { +$ranges = array_merge($ranges, self::$installed['versions'][$packageName]['replaced']); +} +if (array_key_exists('provided', self::$installed['versions'][$packageName])) { +$ranges = array_merge($ranges, self::$installed['versions'][$packageName]['provided']); +} + +return implode(' || ', $ranges); +} + + + + + +public static function getVersion($packageName) +{ +if (!isset(self::$installed['versions'][$packageName])) { +throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed'); +} + +if (!isset(self::$installed['versions'][$packageName]['version'])) { +return null; +} + +return self::$installed['versions'][$packageName]['version']; +} + + + + + +public static function getPrettyVersion($packageName) +{ +if (!isset(self::$installed['versions'][$packageName])) { +throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed'); +} + +if (!isset(self::$installed['versions'][$packageName]['pretty_version'])) { +return null; +} + +return self::$installed['versions'][$packageName]['pretty_version']; +} + + + + + +public static function getReference($packageName) +{ +if (!isset(self::$installed['versions'][$packageName])) { +throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed'); +} + +if (!isset(self::$installed['versions'][$packageName]['reference'])) { +return null; +} + +return self::$installed['versions'][$packageName]['reference']; +} + + + + + +public static function getRootPackage() +{ +return self::$installed['root']; +} + + + + + + + +public static function getRawData() +{ +return self::$installed; +} + + + + + + + + + + + + + + + + + + + +public static function reload($data) +{ +self::$installed = $data; +} +} diff --git a/vendor/composer/LICENSE b/vendor/composer/LICENSE new file mode 100644 index 0000000..f27399a --- /dev/null +++ b/vendor/composer/LICENSE @@ -0,0 +1,21 @@ + +Copyright (c) Nils Adermann, Jordi Boggiano + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is furnished +to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + diff --git a/vendor/composer/autoload_classmap.php b/vendor/composer/autoload_classmap.php new file mode 100644 index 0000000..683b088 --- /dev/null +++ b/vendor/composer/autoload_classmap.php @@ -0,0 +1,17 @@ + $vendorDir . '/composer/InstalledVersions.php', + 'DB' => $vendorDir . '/sergeytsalkov/meekrodb/db.class.php', + 'DBHelper' => $vendorDir . '/sergeytsalkov/meekrodb/db.class.php', + 'DBTransaction' => $vendorDir . '/sergeytsalkov/meekrodb/db.class.php', + 'MeekroDB' => $vendorDir . '/sergeytsalkov/meekrodb/db.class.php', + 'MeekroDBEval' => $vendorDir . '/sergeytsalkov/meekrodb/db.class.php', + 'MeekroDBException' => $vendorDir . '/sergeytsalkov/meekrodb/db.class.php', + 'WhereClause' => $vendorDir . '/sergeytsalkov/meekrodb/db.class.php', +); diff --git a/vendor/composer/autoload_namespaces.php b/vendor/composer/autoload_namespaces.php new file mode 100644 index 0000000..b7fc012 --- /dev/null +++ b/vendor/composer/autoload_namespaces.php @@ -0,0 +1,9 @@ += 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded()); + if ($useStaticLoader) { + require __DIR__ . '/autoload_static.php'; + + call_user_func(\Composer\Autoload\ComposerStaticInit9e6487acd796bef3591a49601b8f5a50::getInitializer($loader)); + } else { + $map = require __DIR__ . '/autoload_namespaces.php'; + foreach ($map as $namespace => $path) { + $loader->set($namespace, $path); + } + + $map = require __DIR__ . '/autoload_psr4.php'; + foreach ($map as $namespace => $path) { + $loader->setPsr4($namespace, $path); + } + + $classMap = require __DIR__ . '/autoload_classmap.php'; + if ($classMap) { + $loader->addClassMap($classMap); + } + } + + $loader->register(true); + + return $loader; + } +} diff --git a/vendor/composer/autoload_static.php b/vendor/composer/autoload_static.php new file mode 100644 index 0000000..5c22c8f --- /dev/null +++ b/vendor/composer/autoload_static.php @@ -0,0 +1,27 @@ + __DIR__ . '/..' . '/composer/InstalledVersions.php', + 'DB' => __DIR__ . '/..' . '/sergeytsalkov/meekrodb/db.class.php', + 'DBHelper' => __DIR__ . '/..' . '/sergeytsalkov/meekrodb/db.class.php', + 'DBTransaction' => __DIR__ . '/..' . '/sergeytsalkov/meekrodb/db.class.php', + 'MeekroDB' => __DIR__ . '/..' . '/sergeytsalkov/meekrodb/db.class.php', + 'MeekroDBEval' => __DIR__ . '/..' . '/sergeytsalkov/meekrodb/db.class.php', + 'MeekroDBException' => __DIR__ . '/..' . '/sergeytsalkov/meekrodb/db.class.php', + 'WhereClause' => __DIR__ . '/..' . '/sergeytsalkov/meekrodb/db.class.php', + ); + + public static function getInitializer(ClassLoader $loader) + { + return \Closure::bind(function () use ($loader) { + $loader->classMap = ComposerStaticInit9e6487acd796bef3591a49601b8f5a50::$classMap; + + }, null, ClassLoader::class); + } +} diff --git a/vendor/composer/installed.json b/vendor/composer/installed.json new file mode 100644 index 0000000..6fa0cf2 --- /dev/null +++ b/vendor/composer/installed.json @@ -0,0 +1,57 @@ +{ + "packages": [ + { + "name": "sergeytsalkov/meekrodb", + "version": "v2.3.1", + "version_normalized": "2.3.1.0", + "source": { + "type": "git", + "url": "https://github.com/SergeyTsalkov/meekrodb.git", + "reference": "e8c19ca2f8ed6a0fd0012c6c97e78aac80fded30" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/SergeyTsalkov/meekrodb/zipball/e8c19ca2f8ed6a0fd0012c6c97e78aac80fded30", + "reference": "e8c19ca2f8ed6a0fd0012c6c97e78aac80fded30", + "shasum": "" + }, + "require": { + "php": ">=5.2.0" + }, + "time": "2020-07-10T01:13:31+00:00", + "type": "library", + "installation-source": "dist", + "autoload": { + "classmap": [ + "db.class.php" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "LGPL-3.0" + ], + "authors": [ + { + "name": "Sergey Tsalkov", + "email": "stsalkov@gmail.com" + } + ], + "description": "The Simple PHP/MySQL Library", + "homepage": "http://www.meekro.com", + "keywords": [ + "database", + "mysql", + "mysqli", + "pdo" + ], + "support": { + "email": "support@meekro.com", + "issues": "https://github.com/SergeyTsalkov/meekrodb/issues", + "source": "https://github.com/SergeyTsalkov/meekrodb/tree/v2.3.1" + }, + "install-path": "../sergeytsalkov/meekrodb" + } + ], + "dev": true, + "dev-package-names": [] +} diff --git a/vendor/composer/installed.php b/vendor/composer/installed.php new file mode 100644 index 0000000..adaf1eb --- /dev/null +++ b/vendor/composer/installed.php @@ -0,0 +1,33 @@ + + array ( + 'pretty_version' => '1.0.0+no-version-set', + 'version' => '1.0.0.0', + 'aliases' => + array ( + ), + 'reference' => NULL, + 'name' => '__root__', + ), + 'versions' => + array ( + '__root__' => + array ( + 'pretty_version' => '1.0.0+no-version-set', + 'version' => '1.0.0.0', + 'aliases' => + array ( + ), + 'reference' => NULL, + ), + 'sergeytsalkov/meekrodb' => + array ( + 'pretty_version' => 'v2.3.1', + 'version' => '2.3.1.0', + 'aliases' => + array ( + ), + 'reference' => 'e8c19ca2f8ed6a0fd0012c6c97e78aac80fded30', + ), + ), +); diff --git a/vendor/composer/platform_check.php b/vendor/composer/platform_check.php new file mode 100644 index 0000000..201e2fc --- /dev/null +++ b/vendor/composer/platform_check.php @@ -0,0 +1,26 @@ += 50200)) { + $issues[] = 'Your Composer dependencies require a PHP version ">= 5.2.0". You are running ' . PHP_VERSION . '.'; +} + +if ($issues) { + if (!headers_sent()) { + header('HTTP/1.1 500 Internal Server Error'); + } + if (!ini_get('display_errors')) { + if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') { + fwrite(STDERR, 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . implode(PHP_EOL, $issues) . PHP_EOL.PHP_EOL); + } elseif (!headers_sent()) { + echo 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . str_replace('You are running '.PHP_VERSION.'.', '', implode(PHP_EOL, $issues)) . PHP_EOL.PHP_EOL; + } + } + trigger_error( + 'Composer detected issues in your platform: ' . implode(' ', $issues), + E_USER_ERROR + ); +} diff --git a/vendor/sergeytsalkov/meekrodb/.gitignore b/vendor/sergeytsalkov/meekrodb/.gitignore new file mode 100644 index 0000000..55317fd --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/.gitignore @@ -0,0 +1 @@ +simpletest/test_setup.php diff --git a/vendor/sergeytsalkov/meekrodb/LICENSE b/vendor/sergeytsalkov/meekrodb/LICENSE new file mode 100644 index 0000000..65c5ca8 --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/vendor/sergeytsalkov/meekrodb/README.md b/vendor/sergeytsalkov/meekrodb/README.md new file mode 100644 index 0000000..24ba91e --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/README.md @@ -0,0 +1,149 @@ +MeekroDB -- The Simple PHP MySQL Library +======== +Learn more: http://www.meekro.com + +MeekroDB is: + +* A PHP MySQL library that lets you **get more done with fewer lines of code**, and **makes SQL injection 100% impossible**. +* Google's #1 search result for "php mysql library" since 2013, with **thousands of deployments worldwide**. +* A library with a **perfect security track record**. No bugs relating to security or SQL injection have ever been discovered. + +Installation +======== +When you're ready to get started, see the [Quick Start Guide](http://www.meekro.com/quickstart.php) on our website. + +### Manual Setup +Include the `db.class.php` file into your project and set it up like this: + + require_once 'db.class.php'; + DB::$user = 'my_database_user'; + DB::$password = 'my_database_password'; + DB::$dbName = 'my_database_name'; + +### Composer +Add this to your `composer.json` + + { + "require": { + "sergeytsalkov/meekrodb": "*" + } + } + +Code Examples +======== +### Grab some rows from the database and print out a field from each row. + + $accounts = DB::query("SELECT * FROM accounts WHERE type = %s AND age > %i", $type, 15); + foreach ($accounts as $account) { + echo $account['username'] . "\n"; + } + +### Insert a new row. + + DB::insert('mytable', array( + 'name' => $name, + 'rank' => $rank, + 'location' => $location, + 'age' => $age, + 'intelligence' => $intelligence + )); + +### Grab one row or field + + $account = DB::queryFirstRow("SELECT * FROM accounts WHERE username=%s", 'Joe'); + $number_accounts = DB::queryFirstField("SELECT COUNT(*) FROM accounts"); + +### Use a list in a query + DB::query("SELECT * FROM tbl WHERE name IN %ls AND age NOT IN %li", array('John', 'Bob'), array(12, 15)); + +### Nested Transactions + + DB::$nested_transactions = true; + DB::startTransaction(); // outer transaction + // .. some queries.. + $depth = DB::startTransaction(); // inner transaction + echo $depth . 'transactions are currently active'; // 2 + + // .. some queries.. + DB::commit(); // commit inner transaction + // .. some queries.. + DB::commit(); // commit outer transaction + +### Lots More - See: http://www.meekro.com/docs.php + + +How is MeekroDB better than PDO? +======== +### Optional Static Class Mode +Most web apps will only ever talk to one database. This means that +passing $db objects to every function of your code just adds unnecessary clutter. +The simplest approach is to use static methods such as DB::query(), and that's how +MeekroDB works. Still, if you need database objects, MeekroDB can do that too. + +### Do more with fewer lines of code +The code below escapes your parameters for safety, runs the query, and grabs +the first row of results. Try doing that in one line with PDO. + + $account = DB::queryFirstRow("SELECT * FROM accounts WHERE username=%s", 'Joe'); + +### Work with list parameters easily +Using MySQL's IN keyword should not be hard. MeekroDB smooths out the syntax for you, +PDO does not. + + $accounts = DB::query("SELECT * FROM accounts WHERE username IN %ls", array('Joe', 'Frank')); + + +### Simple inserts +Using MySQL's INSERT should not be more complicated than passing in an +associative array. MeekroDB also simplifies many related commands, including +the useful and bizarre INSERT .. ON DUPLICATE UPDATE command. PDO does none of this. + + DB::insert('accounts', array('username' => 'John', 'password' => 'whatever')); + +### Focus on the goal, not the task +Want to do INSERT yourself rather than relying on DB::insert()? +It's dead simple. I don't even want to think about how many lines +you'd need to pull this off in PDO. + + // Insert 2 rows at once + DB::query("INSERT INTO %b %lb VALUES %ll?", 'accounts', + array('username', 'password', 'last_login_timestamp'), + array( + array('Joe', 'joes_password', new DateTime('yesterday')), + array('Frank', 'franks_password', new DateTime('last Monday')) + ) + ); + +### Nested transactions +MySQL's SAVEPOINT commands lets you create nested transactions, but only +if you keep track of SAVEPOINT ids yourself. MeekroDB does this for you, +so you can have nested transactions with no complexity or learning curve. + + DB::$nested_transactions = true; + DB::startTransaction(); // outer transaction + // .. some queries.. + $depth = DB::startTransaction(); // inner transaction + echo $depth . 'transactions are currently active'; // 2 + + // .. some queries.. + DB::commit(); // commit inner transaction + // .. some queries.. + DB::commit(); // commit outer transaction + +### Flexible error and success handlers +Set your own custom function run on errors, or on every query that succeeds. +You can easily have separate error handling behavior for the dev and live +versions of your application. Want to count up all your queries and their +runtime? Just add a new success handler. + +### More about MeekroDB's design philosophy: http://www.meekro.com/beliefs.php + +My Other Projects +======== +A little shameless self-promotion! + + * [Ark Server Hosting](https://arkservers.io) -- Ark: Survival Evolved server hosting by ArkServers.io! + * [7 Days To Die Server Hosting](https://arkservers.io/7days) -- 7 Days to Die server hosting by ArkServers.io! + * [Best Minecraft Server Hosting](https://bestminecraft.org) -- Ranking and recommendations for minecraft server hosting! + * [ChunkHost](https://chunkhost.com) -- VPS Hosting starting at $5/month! We accept bitcoin! + * [brooce](https://github.com/SergeyTsalkov/brooce) - Language-agnostic job queue written in Go! Write your jobs in any language, schedule them from any language, run them anywhere! diff --git a/vendor/sergeytsalkov/meekrodb/composer.json b/vendor/sergeytsalkov/meekrodb/composer.json new file mode 100644 index 0000000..f494063 --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/composer.json @@ -0,0 +1,29 @@ +{ + "name": "SergeyTsalkov/meekrodb", + "description": "The Simple PHP/MySQL Library", + "homepage": "http://www.meekro.com", + "support": { + "email": "support@meekro.com" + }, + "keywords": [ + "mysql", + "database", + "mysqli", + "pdo" + ], + "license": "LGPL-3.0", + "authors": [ + { + "name": "Sergey Tsalkov", + "email": "stsalkov@gmail.com" + } + ], + "require": { + "php": ">=5.2.0" + }, + "autoload": { + "classmap": [ + "db.class.php" + ] + } +} diff --git a/vendor/sergeytsalkov/meekrodb/db.class.php b/vendor/sergeytsalkov/meekrodb/db.class.php new file mode 100644 index 0000000..c90c48a --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/db.class.php @@ -0,0 +1,1009 @@ +. +*/ + + +class DB { + // initial connection + public static $dbName = ''; + public static $user = ''; + public static $password = ''; + public static $host = 'localhost'; + public static $port = 3306; //hhvm complains if this is null + public static $socket = null; + public static $encoding = 'latin1'; + + // configure workings + public static $param_char = '%'; + public static $named_param_seperator = '_'; + public static $success_handler = false; + public static $error_handler = true; + public static $throw_exception_on_error = false; + public static $nonsql_error_handler = null; + public static $pre_sql_handler = false; + public static $throw_exception_on_nonsql_error = false; + public static $nested_transactions = false; + public static $usenull = true; + public static $ssl = array('key' => '', 'cert' => '', 'ca_cert' => '', 'ca_path' => '', 'cipher' => ''); + public static $connect_options = array(MYSQLI_OPT_CONNECT_TIMEOUT => 30); + + // internal + protected static $mdb = null; + public static $variables_to_sync = array('param_char', 'named_param_seperator', 'success_handler', 'error_handler', 'throw_exception_on_error', + 'nonsql_error_handler', 'pre_sql_handler', 'throw_exception_on_nonsql_error', 'nested_transactions', 'usenull', 'ssl', 'connect_options'); + + public static function getMDB() { + $mdb = DB::$mdb; + + if ($mdb === null) { + $mdb = DB::$mdb = new MeekroDB(); + } + + // Sync everytime because settings might have changed. It's fast. + $mdb->sync_config(); + + return $mdb; + } + + // yes, this is ugly. __callStatic() only works in 5.3+ + public static function get() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'get'), $args); } + public static function disconnect() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'disconnect'), $args); } + public static function query() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'query'), $args); } + public static function queryFirstRow() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstRow'), $args); } + public static function queryOneRow() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneRow'), $args); } + public static function queryAllLists() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryAllLists'), $args); } + public static function queryFullColumns() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFullColumns'), $args); } + public static function queryFirstList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstList'), $args); } + public static function queryOneList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneList'), $args); } + public static function queryFirstColumn() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstColumn'), $args); } + public static function queryOneColumn() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneColumn'), $args); } + public static function queryFirstField() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryFirstField'), $args); } + public static function queryOneField() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryOneField'), $args); } + public static function queryRaw() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryRaw'), $args); } + public static function queryRawUnbuf() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'queryRawUnbuf'), $args); } + + public static function insert() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insert'), $args); } + public static function insertIgnore() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertIgnore'), $args); } + public static function insertUpdate() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertUpdate'), $args); } + public static function replace() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'replace'), $args); } + public static function update() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'update'), $args); } + public static function delete() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'delete'), $args); } + + public static function insertId() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'insertId'), $args); } + public static function count() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'count'), $args); } + public static function affectedRows() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'affectedRows'), $args); } + + public static function useDB() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'useDB'), $args); } + public static function startTransaction() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'startTransaction'), $args); } + public static function commit() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'commit'), $args); } + public static function rollback() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'rollback'), $args); } + public static function tableList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'tableList'), $args); } + public static function columnList() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'columnList'), $args); } + + public static function sqlEval() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'sqlEval'), $args); } + public static function nonSQLError() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'nonSQLError'), $args); } + + public static function serverVersion() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'serverVersion'), $args); } + public static function transactionDepth() { $args = func_get_args(); return call_user_func_array(array(DB::getMDB(), 'transactionDepth'), $args); } + + + public static function debugMode($handler = true) { + DB::$success_handler = $handler; + } + +} + + +class MeekroDB { + // initial connection + public $dbName = ''; + public $user = ''; + public $password = ''; + public $host = 'localhost'; + public $port = 3306; + public $socket = null; + public $encoding = 'latin1'; + + // configure workings + public $param_char = '%'; + public $named_param_seperator = '_'; + public $success_handler = false; + public $error_handler = true; + public $throw_exception_on_error = false; + public $nonsql_error_handler = null; + public $pre_sql_handler = false; + public $throw_exception_on_nonsql_error = false; + public $nested_transactions = false; + public $usenull = true; + public $ssl = array('key' => '', 'cert' => '', 'ca_cert' => '', 'ca_path' => '', 'cipher' => ''); + public $connect_options = array(MYSQLI_OPT_CONNECT_TIMEOUT => 30); + + // internal + public $internal_mysql = null; + public $server_info = null; + public $insert_id = 0; + public $num_rows = 0; + public $affected_rows = 0; + public $current_db = null; + public $nested_transactions_count = 0; + + + public function __construct($host=null, $user=null, $password=null, $dbName=null, $port=null, $encoding=null, $socket=null) { + if ($host === null) $host = DB::$host; + if ($user === null) $user = DB::$user; + if ($password === null) $password = DB::$password; + if ($dbName === null) $dbName = DB::$dbName; + if ($port === null) $port = DB::$port; + if ($socket === null) $socket = DB::$socket; + if ($encoding === null) $encoding = DB::$encoding; + + $this->host = $host; + $this->user = $user; + $this->password = $password; + $this->dbName = $dbName; + $this->port = $port; + $this->socket = $socket; + $this->encoding = $encoding; + + $this->sync_config(); + } + + // suck in config settings from static class + public function sync_config() { + foreach (DB::$variables_to_sync as $variable) { + if ($this->$variable !== DB::$$variable) { + $this->$variable = DB::$$variable; + } + } + } + + public function get() { + $mysql = $this->internal_mysql; + + if (!($mysql instanceof MySQLi)) { + if (! $this->port) $this->port = ini_get('mysqli.default_port'); + $this->current_db = $this->dbName; + $mysql = new mysqli(); + + $connect_flags = 0; + if ($this->ssl['key']) { + $mysql->ssl_set($this->ssl['key'], $this->ssl['cert'], $this->ssl['ca_cert'], $this->ssl['ca_path'], $this->ssl['cipher']); + $connect_flags |= MYSQLI_CLIENT_SSL; + } + foreach ($this->connect_options as $key => $value) { + $mysql->options($key, $value); + } + + // suppress warnings, since we will check connect_error anyway + @$mysql->real_connect($this->host, $this->user, $this->password, $this->dbName, $this->port, $this->socket, $connect_flags); + + if ($mysql->connect_error) { + return $this->nonSQLError('Unable to connect to MySQL server! Error: ' . $mysql->connect_error); + } + + $mysql->set_charset($this->encoding); + $this->internal_mysql = $mysql; + $this->server_info = $mysql->server_info; + } + + return $mysql; + } + + public function disconnect() { + $mysqli = $this->internal_mysql; + if ($mysqli instanceof MySQLi) { + if ($thread_id = $mysqli->thread_id) $mysqli->kill($thread_id); + $mysqli->close(); + } + $this->internal_mysql = null; + } + + public function nonSQLError($message) { + if ($this->throw_exception_on_nonsql_error) { + $e = new MeekroDBException($message); + throw $e; + } + + $error_handler = is_callable($this->nonsql_error_handler) ? $this->nonsql_error_handler : 'meekrodb_error_handler'; + + call_user_func($error_handler, array( + 'type' => 'nonsql', + 'error' => $message + )); + } + + public function debugMode($handler = true) { + $this->success_handler = $handler; + } + + public function serverVersion() { $this->get(); return $this->server_info; } + public function transactionDepth() { return $this->nested_transactions_count; } + public function insertId() { return $this->insert_id; } + public function affectedRows() { return $this->affected_rows; } + public function count() { $args = func_get_args(); return call_user_func_array(array($this, 'numRows'), $args); } + public function numRows() { return $this->num_rows; } + + public function useDB() { $args = func_get_args(); return call_user_func_array(array($this, 'setDB'), $args); } + public function setDB($dbName) { + $db = $this->get(); + if (! $db->select_db($dbName)) return $this->nonSQLError("Unable to set database to $dbName"); + $this->current_db = $dbName; + } + + + public function startTransaction() { + if ($this->nested_transactions && $this->serverVersion() < '5.5') { + return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion()); + } + + if (!$this->nested_transactions || $this->nested_transactions_count == 0) { + $this->query('START TRANSACTION'); + $this->nested_transactions_count = 1; + } else { + $this->query("SAVEPOINT LEVEL{$this->nested_transactions_count}"); + $this->nested_transactions_count++; + } + + return $this->nested_transactions_count; + } + + public function commit($all=false) { + if ($this->nested_transactions && $this->serverVersion() < '5.5') { + return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion()); + } + + if ($this->nested_transactions && $this->nested_transactions_count > 0) + $this->nested_transactions_count--; + + if (!$this->nested_transactions || $all || $this->nested_transactions_count == 0) { + $this->nested_transactions_count = 0; + $this->query('COMMIT'); + } else { + $this->query("RELEASE SAVEPOINT LEVEL{$this->nested_transactions_count}"); + } + + return $this->nested_transactions_count; + } + + public function rollback($all=false) { + if ($this->nested_transactions && $this->serverVersion() < '5.5') { + return $this->nonSQLError("Nested transactions are only available on MySQL 5.5 and greater. You are using MySQL " . $this->serverVersion()); + } + + if ($this->nested_transactions && $this->nested_transactions_count > 0) + $this->nested_transactions_count--; + + if (!$this->nested_transactions || $all || $this->nested_transactions_count == 0) { + $this->nested_transactions_count = 0; + $this->query('ROLLBACK'); + } else { + $this->query("ROLLBACK TO SAVEPOINT LEVEL{$this->nested_transactions_count}"); + } + + return $this->nested_transactions_count; + } + + protected function formatTableName($table) { + $table = trim($table, '`'); + + if (strpos($table, '.')) return implode('.', array_map(array($this, 'formatTableName'), explode('.', $table))); + else return '`' . str_replace('`', '``', $table) . '`'; + } + + public function update() { + $args = func_get_args(); + $table = array_shift($args); + $params = array_shift($args); + + $update_part = $this->parseQueryParams( + str_replace('%', $this->param_char, "UPDATE %b SET %hc"), + $table, $params + ); + + $where_part = call_user_func_array(array($this, 'parseQueryParams'), $args); + $query = $update_part . ' WHERE ' . $where_part; + return $this->query($query); + } + + public function insertOrReplace($which, $table, $datas, $options=array()) { + $datas = unserialize(serialize($datas)); // break references within array + $keys = $values = array(); + + if (isset($datas[0]) && is_array($datas[0])) { + $var = '%ll?'; + foreach ($datas as $datum) { + ksort($datum); + if (! $keys) $keys = array_keys($datum); + $values[] = array_values($datum); + } + + } else { + $var = '%l?'; + $keys = array_keys($datas); + $values = array_values($datas); + } + + if ($which != 'INSERT' && $which != 'INSERT IGNORE' && $which != 'REPLACE') { + return $this->nonSQLError('insertOrReplace() must be called with one of: INSERT, INSERT IGNORE, REPLACE'); + } + + if (isset($options['update']) && is_array($options['update']) && $options['update'] && $which == 'INSERT') { + if (array_values($options['update']) !== $options['update']) { + return $this->query( + str_replace('%', $this->param_char, "INSERT INTO %b %lb VALUES $var ON DUPLICATE KEY UPDATE %hc"), + $table, $keys, $values, $options['update']); + } else { + $update_str = array_shift($options['update']); + $query_param = array( + str_replace('%', $this->param_char, "INSERT INTO %b %lb VALUES $var ON DUPLICATE KEY UPDATE ") . $update_str, + $table, $keys, $values); + $query_param = array_merge($query_param, $options['update']); + return call_user_func_array(array($this, 'query'), $query_param); + } + + } + + return $this->query( + str_replace('%', $this->param_char, "%l INTO %b %lb VALUES $var"), + $which, $table, $keys, $values); + } + + public function insert($table, $data) { return $this->insertOrReplace('INSERT', $table, $data); } + public function insertIgnore($table, $data) { return $this->insertOrReplace('INSERT IGNORE', $table, $data); } + public function replace($table, $data) { return $this->insertOrReplace('REPLACE', $table, $data); } + + public function insertUpdate() { + $args = func_get_args(); + $table = array_shift($args); + $data = array_shift($args); + + if (! isset($args[0])) { // update will have all the data of the insert + if (isset($data[0]) && is_array($data[0])) { //multiple insert rows specified -- failing! + return $this->nonSQLError("Badly formatted insertUpdate() query -- you didn't specify the update component!"); + } + + $args[0] = $data; + } + + if (is_array($args[0])) $update = $args[0]; + else $update = $args; + + return $this->insertOrReplace('INSERT', $table, $data, array('update' => $update)); + } + + public function delete() { + $args = func_get_args(); + $table = $this->formatTableName(array_shift($args)); + + $where = call_user_func_array(array($this, 'parseQueryParams'), $args); + $query = "DELETE FROM {$table} WHERE {$where}"; + return $this->query($query); + } + + public function sqleval() { + $args = func_get_args(); + $text = call_user_func_array(array($this, 'parseQueryParams'), $args); + return new MeekroDBEval($text); + } + + public function columnList($table) { + return $this->queryOneColumn('Field', "SHOW COLUMNS FROM %b", $table); + } + + public function tableList($db = null) { + if ($db) { + $olddb = $this->current_db; + $this->useDB($db); + } + + $result = $this->queryFirstColumn('SHOW TABLES'); + if (isset($olddb)) $this->useDB($olddb); + return $result; + } + + protected function preparseQueryParams() { + $args = func_get_args(); + $sql = trim(strval(array_shift($args))); + $args_all = $args; + + if (count($args_all) == 0) return array($sql); + + $param_char_length = strlen($this->param_char); + $named_seperator_length = strlen($this->named_param_seperator); + + $types = array( + $this->param_char . 'll', // list of literals + $this->param_char . 'ls', // list of strings + $this->param_char . 'l', // literal + $this->param_char . 'li', // list of integers + $this->param_char . 'ld', // list of decimals + $this->param_char . 'lb', // list of backticks + $this->param_char . 'lt', // list of timestamps + $this->param_char . 's', // string + $this->param_char . 'i', // integer + $this->param_char . 'd', // double / decimal + $this->param_char . 'b', // backtick + $this->param_char . 't', // timestamp + $this->param_char . '?', // infer type + $this->param_char . 'l?', // list of inferred types + $this->param_char . 'll?', // list of lists of inferred types + $this->param_char . 'hc', // hash `key`='value' pairs separated by commas + $this->param_char . 'ha', // hash `key`='value' pairs separated by and + $this->param_char . 'ho', // hash `key`='value' pairs separated by or + $this->param_char . 'ss', // search string (like string, surrounded with %'s) + $this->param_char . 'ssb', // search string (like, begins with) + $this->param_char . 'sse', // search string (like, ends with) + ); + + // generate list of all MeekroDB variables in our query, and their position + // in the form "offset => variable", sorted by offsets + $posList = array(); + foreach ($types as $type) { + $lastPos = 0; + while (($pos = strpos($sql, $type, $lastPos)) !== false) { + $lastPos = $pos + 1; + if (isset($posList[$pos]) && strlen($posList[$pos]) > strlen($type)) continue; + $posList[$pos] = $type; + } + } + + ksort($posList); + + // for each MeekroDB variable, substitute it with array(type: i, value: 53) or whatever + $chunkyQuery = array(); // preparsed query + $pos_adj = 0; // how much we've added or removed from the original sql string + foreach ($posList as $pos => $type) { + $type = substr($type, $param_char_length); // variable, without % in front of it + $length_type = strlen($type) + $param_char_length; // length of variable w/o % + + $new_pos = $pos + $pos_adj; // position of start of variable + $new_pos_back = $new_pos + $length_type; // position of end of variable + $arg_number_length = 0; // length of any named or numbered parameter addition + + // handle numbered parameters + if ($arg_number_length = strspn($sql, '0123456789', $new_pos_back)) { + $arg_number = substr($sql, $new_pos_back, $arg_number_length); + if (! array_key_exists($arg_number, $args_all)) return $this->nonSQLError("Non existent argument reference (arg $arg_number): $sql"); + + $arg = $args_all[$arg_number]; + + // handle named parameters + } else if (substr($sql, $new_pos_back, $named_seperator_length) == $this->named_param_seperator) { + $arg_number_length = strspn($sql, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_', + $new_pos_back + $named_seperator_length) + $named_seperator_length; + + $arg_number = substr($sql, $new_pos_back + $named_seperator_length, $arg_number_length - $named_seperator_length); + if (count($args_all) != 1 || !is_array($args_all[0])) return $this->nonSQLError("If you use named parameters, the second argument must be an array of parameters"); + if (! array_key_exists($arg_number, $args_all[0])) return $this->nonSQLError("Non existent argument reference (arg $arg_number): $sql"); + + $arg = $args_all[0][$arg_number]; + + } else { + $arg_number = 0; + $arg = array_shift($args); + } + + if ($new_pos > 0) $chunkyQuery[] = substr($sql, 0, $new_pos); + + if (is_object($arg) && ($arg instanceof WhereClause)) { + list($clause_sql, $clause_args) = $arg->textAndArgs(); + array_unshift($clause_args, $clause_sql); + $preparsed_sql = call_user_func_array(array($this, 'preparseQueryParams'), $clause_args); + $chunkyQuery = array_merge($chunkyQuery, $preparsed_sql); + } else { + $chunkyQuery[] = array('type' => $type, 'value' => $arg); + } + + $sql = substr($sql, $new_pos_back + $arg_number_length); + $pos_adj -= $new_pos_back + $arg_number_length; + } + + if (strlen($sql) > 0) $chunkyQuery[] = $sql; + + return $chunkyQuery; + } + + public function escape($str) { return "'" . $this->get()->real_escape_string(strval($str)) . "'"; } + + public function sanitize($value, $type='basic', $hashjoin=', ') { + if ($type == 'basic') { + if (is_object($value)) { + if ($value instanceof MeekroDBEval) return $value->text; + else if ($value instanceof DateTime) return $this->escape($value->format('Y-m-d H:i:s')); + else return $this->escape($value); // use __toString() value for objects, when possible + } + + if (is_null($value)) return $this->usenull ? 'NULL' : "''"; + else if (is_bool($value)) return ($value ? 1 : 0); + else if (is_int($value)) return $value; + else if (is_float($value)) return $value; + else if (is_array($value)) return "''"; + else return $this->escape($value); + + } else if ($type == 'list') { + if (is_array($value)) { + $value = array_values($value); + return '(' . implode(', ', array_map(array($this, 'sanitize'), $value)) . ')'; + } else { + return $this->nonSQLError("Expected array parameter, got something different!"); + } + } else if ($type == 'doublelist') { + if (is_array($value) && array_values($value) === $value && is_array($value[0])) { + $cleanvalues = array(); + foreach ($value as $subvalue) { + $cleanvalues[] = $this->sanitize($subvalue, 'list'); + } + return implode(', ', $cleanvalues); + + } else { + return $this->nonSQLError("Expected double array parameter, got something different!"); + } + } else if ($type == 'hash') { + if (is_array($value)) { + $pairs = array(); + foreach ($value as $k => $v) { + $pairs[] = $this->formatTableName($k) . '=' . $this->sanitize($v); + } + + return implode($hashjoin, $pairs); + } else { + return $this->nonSQLError("Expected hash (associative array) parameter, got something different!"); + } + } else { + return $this->nonSQLError("Invalid type passed to sanitize()!"); + } + + } + + protected function parseTS($ts) { + if (is_string($ts)) return date('Y-m-d H:i:s', strtotime($ts)); + else if (is_object($ts) && ($ts instanceof DateTime)) return $ts->format('Y-m-d H:i:s'); + } + + protected function intval($var) { + if (PHP_INT_SIZE == 8) return intval($var); + return floor(doubleval($var)); + } + + public function parseQueryParams() { + $args = func_get_args(); + $chunkyQuery = call_user_func_array(array($this, 'preparseQueryParams'), $args); + + $query = ''; + $array_types = array('ls', 'li', 'ld', 'lb', 'll', 'lt', 'l?', 'll?', 'hc', 'ha', 'ho'); + + foreach ($chunkyQuery as $chunk) { + if (is_string($chunk)) { + $query .= $chunk; + continue; + } + + $type = $chunk['type']; + $arg = $chunk['value']; + $result = ''; + + $is_array_type = in_array($type, $array_types, true); + if ($is_array_type && !is_array($arg)) return $this->nonSQLError("Badly formatted SQL query: Expected array, got scalar instead!"); + else if (!$is_array_type && is_array($arg)) $arg = ''; + + if ($type == 's') $result = $this->escape($arg); + else if ($type == 'i') $result = $this->intval($arg); + else if ($type == 'd') $result = doubleval($arg); + else if ($type == 'b') $result = $this->formatTableName($arg); + else if ($type == 'l') $result = $arg; + else if ($type == 'ss') $result = $this->escape("%" . str_replace(array('%', '_'), array('\%', '\_'), $arg) . "%"); + else if ($type == 'ssb') $result = $this->escape(str_replace(array('%', '_'), array('\%', '\_'), $arg) . "%"); + else if ($type == 'sse') $result = $this->escape("%" . str_replace(array('%', '_'), array('\%', '\_'), $arg)); + else if ($type == 't') $result = $this->escape($this->parseTS($arg)); + + else if ($type == 'ls') $result = array_map(array($this, 'escape'), $arg); + else if ($type == 'li') $result = array_map(array($this, 'intval'), $arg); + else if ($type == 'ld') $result = array_map('doubleval', $arg); + else if ($type == 'lb') $result = array_map(array($this, 'formatTableName'), $arg); + else if ($type == 'll') $result = $arg; + else if ($type == 'lt') $result = array_map(array($this, 'escape'), array_map(array($this, 'parseTS'), $arg)); + + else if ($type == '?') $result = $this->sanitize($arg); + else if ($type == 'l?') $result = $this->sanitize($arg, 'list'); + else if ($type == 'll?') $result = $this->sanitize($arg, 'doublelist'); + else if ($type == 'hc') $result = $this->sanitize($arg, 'hash'); + else if ($type == 'ha') $result = $this->sanitize($arg, 'hash', ' AND '); + else if ($type == 'ho') $result = $this->sanitize($arg, 'hash', ' OR '); + + else return $this->nonSQLError("Badly formatted SQL query: Invalid MeekroDB param $type"); + + if (is_array($result)) $result = '(' . implode(',', $result) . ')'; + + $query .= $result; + } + + return $query; + } + + protected function prependCall($function, $args, $prepend) { array_unshift($args, $prepend); return call_user_func_array($function, $args); } + public function query() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'assoc'); } + public function queryAllLists() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'list'); } + public function queryFullColumns() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'full'); } + + public function queryRaw() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'raw_buf'); } + public function queryRawUnbuf() { $args = func_get_args(); return $this->prependCall(array($this, 'queryHelper'), $args, 'raw_unbuf'); } + + protected function queryHelper() { + $args = func_get_args(); + $type = array_shift($args); + $db = $this->get(); + + $is_buffered = true; + $row_type = 'assoc'; // assoc, list, raw + $full_names = false; + + switch ($type) { + case 'assoc': + break; + case 'list': + $row_type = 'list'; + break; + case 'full': + $row_type = 'list'; + $full_names = true; + break; + case 'raw_buf': + $row_type = 'raw'; + break; + case 'raw_unbuf': + $is_buffered = false; + $row_type = 'raw'; + break; + default: + return $this->nonSQLError('Error -- invalid argument to queryHelper!'); + } + + $sql = call_user_func_array(array($this, 'parseQueryParams'), $args); + + if ($this->pre_sql_handler !== false && is_callable($this->pre_sql_handler)) { + $sql = call_user_func($this->pre_sql_handler, $sql); + } + + if ($this->success_handler) $starttime = microtime(true); + $result = $db->query($sql, $is_buffered ? MYSQLI_STORE_RESULT : MYSQLI_USE_RESULT); + if ($this->success_handler) $runtime = microtime(true) - $starttime; + else $runtime = 0; + + // ----- BEGIN ERROR HANDLING + if (!$sql || $db->error) { + if ($this->error_handler) { + $error_handler = is_callable($this->error_handler) ? $this->error_handler : 'meekrodb_error_handler'; + + call_user_func($error_handler, array( + 'type' => 'sql', + 'query' => $sql, + 'error' => $db->error, + 'code' => $db->errno + )); + } + + if ($this->throw_exception_on_error) { + $e = new MeekroDBException($db->error, $sql, $db->errno); + throw $e; + } + } else if ($this->success_handler) { + $runtime = sprintf('%f', $runtime * 1000); + $success_handler = is_callable($this->success_handler) ? $this->success_handler : 'meekrodb_debugmode_handler'; + + call_user_func($success_handler, array( + 'query' => $sql, + 'runtime' => $runtime, + 'affected' => $db->affected_rows + )); + } + + // ----- END ERROR HANDLING + + $this->insert_id = $db->insert_id; + $this->affected_rows = $db->affected_rows; + + // mysqli_result->num_rows won't initially show correct results for unbuffered data + if ($is_buffered && ($result instanceof MySQLi_Result)) $this->num_rows = $result->num_rows; + else $this->num_rows = null; + + if ($row_type == 'raw' || !($result instanceof MySQLi_Result)) return $result; + + $return = array(); + + if ($full_names) { + $infos = array(); + foreach ($result->fetch_fields() as $info) { + if (strlen($info->table)) $infos[] = $info->table . '.' . $info->name; + else $infos[] = $info->name; + } + } + + while ($row = ($row_type == 'assoc' ? $result->fetch_assoc() : $result->fetch_row())) { + if ($full_names) $row = array_combine($infos, $row); + $return[] = $row; + } + + // free results + $result->free(); + while ($db->more_results()) { + $db->next_result(); + if ($result = $db->use_result()) $result->free(); + } + + return $return; + } + + public function queryOneRow() { $args = func_get_args(); return call_user_func_array(array($this, 'queryFirstRow'), $args); } + public function queryFirstRow() { + $args = func_get_args(); + $result = call_user_func_array(array($this, 'query'), $args); + if (!$result || !is_array($result)) return null; + return reset($result); + } + + public function queryOneList() { $args = func_get_args(); return call_user_func_array(array($this, 'queryFirstList'), $args); } + public function queryFirstList() { + $args = func_get_args(); + $result = call_user_func_array(array($this, 'queryAllLists'), $args); + if (!$result || !is_array($result)) return null; + return reset($result); + } + + public function queryFirstColumn() { + $args = func_get_args(); + $results = call_user_func_array(array($this, 'queryAllLists'), $args); + $ret = array(); + + if (!count($results) || !count($results[0])) return $ret; + + foreach ($results as $row) { + $ret[] = $row[0]; + } + + return $ret; + } + + public function queryOneColumn() { + $args = func_get_args(); + $column = array_shift($args); + $results = call_user_func_array(array($this, 'query'), $args); + $ret = array(); + + if (!count($results) || !count($results[0])) return $ret; + if ($column === null) { + $keys = array_keys($results[0]); + $column = $keys[0]; + } + + foreach ($results as $row) { + $ret[] = $row[$column]; + } + + return $ret; + } + + public function queryFirstField() { + $args = func_get_args(); + $row = call_user_func_array(array($this, 'queryFirstList'), $args); + if ($row == null) return null; + return $row[0]; + } + + public function queryOneField() { + $args = func_get_args(); + $column = array_shift($args); + + $row = call_user_func_array(array($this, 'queryOneRow'), $args); + if ($row == null) { + return null; + } else if ($column === null) { + $keys = array_keys($row); + $column = $keys[0]; + } + + return $row[$column]; + } +} + +class WhereClause { + public $type = 'and'; //AND or OR + public $negate = false; + public $clauses = array(); + + function __construct($type) { + $type = strtolower($type); + if ($type !== 'or' && $type !== 'and') return DB::nonSQLError('you must use either WhereClause(and) or WhereClause(or)'); + $this->type = $type; + } + + function add() { + $args = func_get_args(); + $sql = array_shift($args); + + if ($sql instanceof WhereClause) { + $this->clauses[] = $sql; + } else { + $this->clauses[] = array('sql' => $sql, 'args' => $args); + } + } + + function negateLast() { + $i = count($this->clauses) - 1; + if (!isset($this->clauses[$i])) return; + + if ($this->clauses[$i] instanceof WhereClause) { + $this->clauses[$i]->negate(); + } else { + $this->clauses[$i]['sql'] = 'NOT (' . $this->clauses[$i]['sql'] . ')'; + } + } + + function negate() { + $this->negate = ! $this->negate; + } + + function addClause($type) { + $r = new WhereClause($type); + $this->add($r); + return $r; + } + + function count() { + return count($this->clauses); + } + + function textAndArgs() { + $sql = array(); + $args = array(); + + if (count($this->clauses) == 0) return array('(1)', $args); + + foreach ($this->clauses as $clause) { + if ($clause instanceof WhereClause) { + list($clause_sql, $clause_args) = $clause->textAndArgs(); + } else { + $clause_sql = $clause['sql']; + $clause_args = $clause['args']; + } + + $sql[] = "($clause_sql)"; + $args = array_merge($args, $clause_args); + } + + if ($this->type == 'and') $sql = sprintf('(%s)', implode(' AND ', $sql)); + else $sql = sprintf('(%s)', implode(' OR ', $sql)); + + if ($this->negate) $sql = '(NOT ' . $sql . ')'; + return array($sql, $args); + } + + // backwards compatability + // we now return full WhereClause object here and evaluate it in preparseQueryParams + function text() { return $this; } +} + +class DBTransaction { + private $committed = false; + + function __construct() { + DB::startTransaction(); + } + function __destruct() { + if (! $this->committed) DB::rollback(); + } + function commit() { + DB::commit(); + $this->committed = true; + } + + +} + +class MeekroDBException extends Exception { + protected $query = ''; + + function __construct($message='', $query='', $code = 0) { + parent::__construct($message); + $this->query = $query; + $this->code = $code; + } + + public function getQuery() { return $this->query; } +} + +class DBHelper { + /* + verticalSlice + 1. For an array of assoc rays, return an array of values for a particular key + 2. if $keyfield is given, same as above but use that hash key as the key in new array + */ + + public static function verticalSlice($array, $field, $keyfield = null) { + $array = (array) $array; + + $R = array(); + foreach ($array as $obj) { + if (! array_key_exists($field, $obj)) die("verticalSlice: array doesn't have requested field\n"); + + if ($keyfield) { + if (! array_key_exists($keyfield, $obj)) die("verticalSlice: array doesn't have requested field\n"); + $R[$obj[$keyfield]] = $obj[$field]; + } else { + $R[] = $obj[$field]; + } + } + return $R; + } + + /* + reIndex + For an array of assoc rays, return a new array of assoc rays using a certain field for keys + */ + + public static function reIndex() { + $fields = func_get_args(); + $array = array_shift($fields); + $array = (array) $array; + + $R = array(); + foreach ($array as $obj) { + $target =& $R; + + foreach ($fields as $field) { + if (! array_key_exists($field, $obj)) die("reIndex: array doesn't have requested field\n"); + + $nextkey = $obj[$field]; + $target =& $target[$nextkey]; + } + $target = $obj; + } + return $R; + } +} + +function meekrodb_error_handler($params) { + if (isset($params['query'])) $out[] = "QUERY: " . $params['query']; + if (isset($params['error'])) $out[] = "ERROR: " . $params['error']; + $out[] = ""; + + if (php_sapi_name() == 'cli' && empty($_SERVER['REMOTE_ADDR'])) { + echo implode("\n", $out); + } else { + echo implode("
\n", $out); + } + + die; +} + +function meekrodb_debugmode_handler($params) { + echo "QUERY: " . $params['query'] . " [" . $params['runtime'] . " ms]"; + if (php_sapi_name() == 'cli' && empty($_SERVER['REMOTE_ADDR'])) { + echo "\n"; + } else { + echo "
\n"; + } +} + +class MeekroDBEval { + public $text = ''; + + function __construct($text) { + $this->text = $text; + } +} + +?> diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/BasicTest.php b/vendor/sergeytsalkov/meekrodb/simpletest/BasicTest.php new file mode 100644 index 0000000..7ff3f6d --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/simpletest/BasicTest.php @@ -0,0 +1,439 @@ +assert(!$mysqli->server_info); + } + + function test_1_5_empty_table() { + $counter = DB::queryFirstField("SELECT COUNT(*) FROM accounts"); + $this->assert($counter === strval(0)); + + $row = DB::queryFirstRow("SELECT * FROM accounts"); + $this->assert($row === null); + + $field = DB::queryFirstField("SELECT * FROM accounts"); + $this->assert($field === null); + + $field = DB::queryOneField('nothere', "SELECT * FROM accounts"); + $this->assert($field === null); + + $column = DB::queryFirstColumn("SELECT * FROM accounts"); + $this->assert(is_array($column) && count($column) === 0); + + $column = DB::queryOneColumn('nothere', "SELECT * FROM accounts"); //TODO: is this what we want? + $this->assert(is_array($column) && count($column) === 0); + } + + function test_2_insert_row() { + $true = DB::insert('accounts', array( + 'username' => 'Abe', + 'password' => 'hello' + )); + + $this->assert($true === true); + $this->assert(DB::affectedRows() === 1); + + $counter = DB::queryFirstField("SELECT COUNT(*) FROM accounts"); + $this->assert($counter === strval(1)); + } + + function test_3_more_inserts() { + DB::insert('`accounts`', array( + 'username' => 'Bart', + 'password' => 'hello', + 'age' => 15, + 'height' => 10.371 + )); + $dbname = DB::$dbName; + DB::insert("`$dbname`.`accounts`", array( + 'username' => 'Charlie\'s Friend', + 'password' => 'goodbye', + 'age' => 30, + 'height' => 155.23, + 'favorite_word' => null, + )); + + $this->assert(DB::insertId() === 3); + $counter = DB::queryFirstField("SELECT COUNT(*) FROM accounts"); + $this->assert($counter === strval(3)); + + DB::insert('`accounts`', array( + 'username' => 'Deer', + 'password' => '', + 'age' => 15, + 'height' => 10.371 + )); + + $username = DB::queryFirstField("SELECT username FROM accounts WHERE password=%s0", null); + $this->assert($username === 'Deer'); + + $password = DB::queryFirstField("SELECT password FROM accounts WHERE favorite_word IS NULL"); + $this->assert($password === 'goodbye'); + + DB::$usenull = false; + DB::insertUpdate('accounts', array( + 'id' => 3, + 'favorite_word' => null, + )); + + $password = DB::queryFirstField("SELECT password FROM accounts WHERE favorite_word=%s AND favorite_word=%s", null, ''); + $this->assert($password === 'goodbye'); + + DB::$usenull = true; + DB::insertUpdate('accounts', array( + 'id' => 3, + 'favorite_word' => null, + )); + + DB::$param_char = '###'; + $bart = DB::queryFirstRow("SELECT * FROM accounts WHERE age IN ###li AND height IN ###ld AND username IN ###ls", + array(15, 25), array(10.371, 150.123), array('Bart', 'Barts')); + $this->assert($bart['username'] === 'Bart'); + DB::insert('accounts', array('username' => 'f_u')); + DB::query("DELETE FROM accounts WHERE username=###s", 'f_u'); + DB::$param_char = '%'; + + $charlie_password = DB::queryFirstField("SELECT password FROM accounts WHERE username IN %ls AND username = %s", + array('Charlie', 'Charlie\'s Friend'), 'Charlie\'s Friend'); + $this->assert($charlie_password === 'goodbye'); + + $charlie_password = DB::queryOneField('password', "SELECT * FROM accounts WHERE username IN %ls AND username = %s", + array('Charlie', 'Charlie\'s Friend'), 'Charlie\'s Friend'); + $this->assert($charlie_password === 'goodbye'); + + $passwords = DB::queryFirstColumn("SELECT password FROM accounts WHERE username=%s", 'Bart'); + $this->assert(count($passwords) === 1); + $this->assert($passwords[0] === 'hello'); + + $username = $password = $age = null; + list($age, $username, $password) = DB::queryOneList("SELECT age,username,password FROM accounts WHERE username=%s", 'Bart'); + $this->assert($username === 'Bart'); + $this->assert($password === 'hello'); + $this->assert($age == 15); + + $mysqli_result = DB::queryRaw("SELECT * FROM accounts WHERE favorite_word IS NULL"); + $this->assert($mysqli_result instanceof MySQLi_Result); + $row = $mysqli_result->fetch_assoc(); + $this->assert($row['password'] === 'goodbye'); + $this->assert($mysqli_result->fetch_assoc() === null); + } + + function test_4_query() { + DB::update('accounts', array( + 'birthday' => new DateTime('10 September 2000 13:13:13') + ), 'username=%s', 'Charlie\'s Friend'); + + $results = DB::query("SELECT * FROM accounts WHERE username=%s AND birthday IN %lt", 'Charlie\'s Friend', array('September 10 2000 13:13:13')); + $this->assert(count($results) === 1); + $this->assert($results[0]['age'] === '30' && $results[0]['password'] === 'goodbye'); + $this->assert($results[0]['birthday'] == '2000-09-10 13:13:13'); + + $results = DB::query("SELECT * FROM accounts WHERE username!=%s", "Charlie's Friend"); + $this->assert(count($results) === 3); + + $columnlist = DB::columnList('accounts'); + $this->assert(count($columnlist) === 8); + $this->assert($columnlist[0] === 'id'); + $this->assert($columnlist[5] === 'height'); + + $tablelist = DB::tableList(); + $this->assert(count($tablelist) === 3); + $this->assert($tablelist[0] === 'accounts'); + + $tablelist = null; + $tablelist = DB::tableList(DB::$dbName); + $this->assert(count($tablelist) === 3); + $this->assert($tablelist[0] === 'accounts'); + } + + function test_4_1_query() { + DB::insert('accounts', array( + 'username' => 'newguy', + 'password' => DB::sqleval("REPEAT('blah', %i)", '3'), + 'age' => DB::sqleval('171+1'), + 'height' => 111.15 + )); + + $row = DB::queryOneRow("SELECT * FROM accounts WHERE password=%s", 'blahblahblah'); + $this->assert($row['username'] === 'newguy'); + $this->assert($row['age'] === '172'); + + $true = DB::update('accounts', array( + 'password' => DB::sqleval("REPEAT('blah', %i)", 4), + 'favorite_word' => null, + ), 'username=%s_name', array('name' => 'newguy')); + + $row = null; + $row = DB::queryOneRow("SELECT * FROM accounts WHERE username=%s", 'newguy'); + $this->assert($true === true); + $this->assert($row['password'] === 'blahblahblahblah'); + $this->assert($row['favorite_word'] === null); + + $row = DB::query("SELECT * FROM accounts WHERE password=%s_mypass AND (password=%s_mypass) AND username=%s_myuser", + array('myuser' => 'newguy', 'mypass' => 'blahblahblahblah') + ); + $this->assert(count($row) === 1); + $this->assert($row[0]['username'] === 'newguy'); + $this->assert($row[0]['age'] === '172'); + + $row = DB::query("SELECT * FROM accounts WHERE password IN %li AND password IN %li0 AND username=%s", array('blahblahblahblah'), 'newguy'); + $this->assert(count($row) === 1); + $this->assert($row[0]['username'] === 'newguy'); + $this->assert($row[0]['age'] === '172'); + + $true = DB::query("DELETE FROM accounts WHERE password=%s", 'blahblahblahblah'); + $this->assert($true === true); + $this->assert(DB::affectedRows() === 1); + } + + function test_4_2_delete() { + DB::insert('accounts', array( + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + )); + + $ct = DB::queryFirstField("SELECT COUNT(*) FROM accounts WHERE %ha", array('username' => 'gonesoon', 'height' => 199.194)); + $this->assert(intval($ct) === 1); + + $ct = DB::queryFirstField("SELECT COUNT(*) FROM accounts WHERE username=%s1 AND height=%d0 AND height=%d", 199.194, 'gonesoon'); + $this->assert(intval($ct) === 1); + + DB::delete('accounts', 'username=%s AND age=%i AND height=%d', 'gonesoon', '61', '199.194'); + $this->assert(DB::affectedRows() === 1); + + $ct = DB::queryFirstField("SELECT COUNT(*) FROM accounts WHERE username=%s AND height=%d", 'gonesoon', '199.194'); + $this->assert(intval($ct) === 0); + } + + function test_4_3_insertmany() { + $ins[] = array( + 'username' => '1ofmany', + 'password' => 'something', + 'age' => 23, + 'height' => 190.194 + ); + $ins[] = array( + 'password' => 'somethingelse', + 'username' => '2ofmany', + 'age' => 25, + 'height' => 190.194 + ); + $ins[] = array( + 'password' => NULL, + 'username' => '3ofmany', + 'age' => 15, + 'height' => 111.951 + ); + + DB::insert('accounts', $ins); + $this->assert(DB::affectedRows() === 3); + + $rows = DB::query("SELECT * FROM accounts WHERE height=%d ORDER BY age ASC", 190.194); + $this->assert(count($rows) === 2); + $this->assert($rows[0]['username'] === '1ofmany'); + $this->assert($rows[0]['age'] === '23'); + $this->assert($rows[1]['age'] === '25'); + $this->assert($rows[1]['password'] === 'somethingelse'); + $this->assert($rows[1]['username'] === '2ofmany'); + + $nullrow = DB::queryOneRow("SELECT * FROM accounts WHERE username LIKE %ss", '3ofman'); + $this->assert($nullrow['password'] === NULL); + $this->assert($nullrow['age'] === '15'); + } + + + + function test_5_insert_blobs() { + DB::query("CREATE TABLE `store data` ( + `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , + `picture` BLOB + ) ENGINE = InnoDB"); + + $columns = DB::columnList('store data'); + $this->assert(count($columns) === 2); + $this->assert($columns[1] === 'picture'); + + + $smile = file_get_contents('smile1.jpg'); + DB::insert('store data', array( + 'picture' => $smile, + )); + DB::queryOneRow("INSERT INTO %b (picture) VALUES (%s)", 'store data', $smile); + + $getsmile = DB::queryFirstField("SELECT picture FROM %b WHERE id=1", 'store data'); + $getsmile2 = DB::queryFirstField("SELECT picture FROM %b WHERE id=2", 'store data'); + $this->assert($smile === $getsmile); + $this->assert($smile === $getsmile2); + } + + function test_6_insert_ignore() { + DB::insertIgnore('accounts', array( + 'id' => 1, //duplicate primary key + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + )); + } + + function test_7_insert_update() { + $true = DB::insertUpdate('accounts', array( + 'id' => 2, //duplicate primary key + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + ), 'age = age + %i', 1); + + $this->assert($true === true); + $this->assert(DB::affectedRows() === 2); // a quirk of MySQL, even though only 1 row was updated + + $result = DB::query("SELECT * FROM accounts WHERE age = %i", 16); + $this->assert(count($result) === 1); + $this->assert($result[0]['height'] === '10.371'); + + DB::insertUpdate('accounts', array( + 'id' => 2, //duplicate primary key + 'username' => 'blahblahdude', + 'age' => 233, + 'height' => 199.194 + )); + + $result = DB::query("SELECT * FROM accounts WHERE age = %i", 233); + $this->assert(count($result) === 1); + $this->assert($result[0]['height'] === '199.194'); + $this->assert($result[0]['username'] === 'blahblahdude'); + + DB::insertUpdate('accounts', array( + 'id' => 2, //duplicate primary key + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + ), array( + 'age' => 74, + )); + + $result = DB::query("SELECT * FROM accounts WHERE age = %i", 74); + $this->assert(count($result) === 1); + $this->assert($result[0]['height'] === '199.194'); + $this->assert($result[0]['username'] === 'blahblahdude'); + + $multiples[] = array( + 'id' => 3, //duplicate primary key + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + ); + $multiples[] = array( + 'id' => 1, //duplicate primary key + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + ); + + DB::insertUpdate('accounts', $multiples, array('age' => 914)); + $this->assert(DB::affectedRows() === 4); + + $result = DB::query("SELECT * FROM accounts WHERE age=914 ORDER BY id ASC"); + $this->assert(count($result) === 2); + $this->assert($result[0]['username'] === 'Abe'); + $this->assert($result[1]['username'] === 'Charlie\'s Friend'); + + $true = DB::query("UPDATE accounts SET age=15, username='Bart' WHERE age=%i", 74); + $this->assert($true === true); + $this->assert(DB::affectedRows() === 1); + } + + function test_8_lb() { + $data = array( + 'username' => 'vookoo', + 'password' => 'dookoo', + ); + + $true = DB::query("INSERT into accounts %lb VALUES %ls", array_keys($data), array_values($data)); + $result = DB::query("SELECT * FROM accounts WHERE username=%s", 'vookoo'); + $this->assert($true === true); + $this->assert(count($result) === 1); + $this->assert($result[0]['password'] === 'dookoo'); + } + + function test_9_fullcolumns() { + $true = DB::insert('profile', array( + 'id' => 1, + 'signature' => 'u_suck' + )); + DB::query("UPDATE accounts SET profile_id=1 WHERE id=2"); + + $r = DB::queryFullColumns("SELECT accounts.*, profile.*, 1+1 FROM accounts + INNER JOIN profile ON accounts.profile_id=profile.id"); + + $this->assert($true === true); + $this->assert(count($r) === 1); + $this->assert($r[0]['accounts.id'] === '2'); + $this->assert($r[0]['profile.id'] === '1'); + $this->assert($r[0]['profile.signature'] === 'u_suck'); + $this->assert($r[0]['1+1'] === '2'); + } + + function test_901_updatewithspecialchar() { + $data = 'www.mysite.com/product?s=t-%s-%%3d%%3d%i&RCAID=24322'; + DB::update('profile', array('signature' => $data), 'id=%i', 1); + $signature = DB::queryFirstField("SELECT signature FROM profile WHERE id=%i", 1); + $this->assert($signature === $data); + + DB::update('profile',array('signature'=> "%li "),"id = %d",1); + $signature = DB::queryFirstField("SELECT signature FROM profile WHERE id=%i", 1); + $this->assert($signature === "%li "); + } + + function test_902_faketable() { + DB::insert('fake%s_table', array('name' => 'karen')); + $count = DB::queryFirstField("SELECT COUNT(*) FROM %b", 'fake%s_table'); + $this->assert($count === '1'); + DB::update('fake%s_table', array('name' => 'haren%s'), 'name=%s_name', array('name' => 'karen')); + DB::delete('fake%s_table', 'name=%s0', 'haren%s'); + $count = DB::queryFirstField("SELECT COUNT(*) FROM %b", 'fake%s_table'); + $this->assert($count === '0'); + } + + + +} + + +?> diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/CallTest.php b/vendor/sergeytsalkov/meekrodb/simpletest/CallTest.php new file mode 100644 index 0000000..f03eb1a --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/simpletest/CallTest.php @@ -0,0 +1,17 @@ +assert($r[0]['username'] === 'Abe'); + $this->assert($r[2]['age'] === '914'); + } + +} \ No newline at end of file diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/ErrorTest.php b/vendor/sergeytsalkov/meekrodb/simpletest/ErrorTest.php new file mode 100644 index 0000000..b230980 --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/simpletest/ErrorTest.php @@ -0,0 +1,83 @@ +assert($error_callback_worked === 1); + + DB::$error_handler = array('ErrorTest', 'static_error_callback'); + DB::query("SELET * FROM accounts"); + $this->assert($static_error_callback_worked === 1); + + DB::$error_handler = array($this, 'nonstatic_error_callback'); + DB::query("SELET * FROM accounts"); + $this->assert($nonstatic_error_callback_worked === 1); + + } + + public static function static_error_callback($params) { + global $static_error_callback_worked; + if (substr_count($params['error'], 'You have an error in your SQL syntax')) $static_error_callback_worked = 1; + } + + public function nonstatic_error_callback($params) { + global $nonstatic_error_callback_worked; + if (substr_count($params['error'], 'You have an error in your SQL syntax')) $nonstatic_error_callback_worked = 1; + } + + function test_2_exception_catch() { + $dbname = DB::$dbName; + DB::$error_handler = ''; + DB::$throw_exception_on_error = true; + try { + DB::query("SELET * FROM accounts"); + } catch(MeekroDBException $e) { + $this->assert(substr_count($e->getMessage(), 'You have an error in your SQL syntax')); + $this->assert($e->getQuery() === 'SELET * FROM accounts'); + $exception_was_caught = 1; + } + $this->assert($exception_was_caught === 1); + + try { + DB::insert("`$dbname`.`accounts`", array( + 'id' => 2, + 'username' => 'Another Dude\'s \'Mom"', + 'password' => 'asdfsdse', + 'age' => 35, + 'height' => 555.23 + )); + } catch(MeekroDBException $e) { + $this->assert(substr_count($e->getMessage(), 'Duplicate entry')); + $exception_was_caught = 2; + } + $this->assert($exception_was_caught === 2); + } + + function test_3_debugmode_handler() { + global $debug_callback_worked; + + DB::debugMode('my_debug_handler'); + DB::query("SELECT * FROM accounts WHERE username!=%s", "Charlie's Friend"); + + $this->assert($debug_callback_worked === 1); + + DB::debugMode(false); + } + +} + +?> diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/ErrorTest_53.php b/vendor/sergeytsalkov/meekrodb/simpletest/ErrorTest_53.php new file mode 100644 index 0000000..8aafe09 --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/simpletest/ErrorTest_53.php @@ -0,0 +1,19 @@ +assert($anonymous_error_callback_worked === 1); + + } + + +} + +?> diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/HelperTest.php b/vendor/sergeytsalkov/meekrodb/simpletest/HelperTest.php new file mode 100644 index 0000000..496c406 --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/simpletest/HelperTest.php @@ -0,0 +1,51 @@ +assert(count($names) === 5); + $this->assert($names[0] === 'Abe'); + + $ages = DBHelper::verticalSlice($all, 'age', 'username'); + $this->assert(count($ages) === 5); + $this->assert($ages['Abe'] === '700'); + } + + function test_2_reindex() { + $all = DB::query("SELECT * FROM accounts ORDER BY id ASC"); + $names = DBHelper::reIndex($all, 'username'); + $this->assert(count($names) === 5); + $this->assert($names['Bart']['username'] === 'Bart'); + $this->assert($names['Bart']['age'] === '15'); + + $names = DBHelper::reIndex($all, 'username', 'age'); + $this->assert($names['Bart']['15']['username'] === 'Bart'); + $this->assert($names['Bart']['15']['age'] === '15'); + } + + function test_3_empty() { + $none = DB::query("SELECT * FROM accounts WHERE username=%s", 'doesnotexist'); + $this->assert(is_array($none) && count($none) === 0); + $names = DBHelper::verticalSlice($none, 'username', 'age'); + $this->assert(is_array($names) && count($names) === 0); + + $names_other = DBHelper::reIndex($none, 'username', 'age'); + $this->assert(is_array($names_other) && count($names_other) === 0); + } + + function test_4_null() { + DB::query("UPDATE accounts SET password = NULL WHERE username=%s", 'Bart'); + + $all = DB::query("SELECT * FROM accounts ORDER BY id ASC"); + $ages = DBHelper::verticalSlice($all, 'age', 'password'); + $this->assert(count($ages) === 5); + $this->assert($ages[''] === '15'); + + $passwords = DBHelper::reIndex($all, 'password'); + $this->assert(count($passwords) === 5); + $this->assert($passwords['']['username'] === 'Bart'); + $this->assert($passwords['']['password'] === NULL); + } + +} +?> diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/ObjectTest.php b/vendor/sergeytsalkov/meekrodb/simpletest/ObjectTest.php new file mode 100644 index 0000000..87c82bb --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/simpletest/ObjectTest.php @@ -0,0 +1,312 @@ +mdb = new MeekroDB(); + + foreach ($this->mdb->tableList() as $table) { + $this->mdb->query("DROP TABLE %b", $table); + } + } + + + function test_1_create_table() { + $this->mdb->query("CREATE TABLE `accounts` ( + `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , + `username` VARCHAR( 255 ) NOT NULL , + `password` VARCHAR( 255 ) NULL , + `age` INT NOT NULL DEFAULT '10', + `height` DOUBLE NOT NULL DEFAULT '10.0', + `favorite_word` VARCHAR( 255 ) NULL DEFAULT 'hi' + ) ENGINE = InnoDB"); + } + + function test_1_5_empty_table() { + $counter = $this->mdb->queryFirstField("SELECT COUNT(*) FROM accounts"); + $this->assert($counter === strval(0)); + + $row = $this->mdb->queryFirstRow("SELECT * FROM accounts"); + $this->assert($row === null); + + $field = $this->mdb->queryFirstField("SELECT * FROM accounts"); + $this->assert($field === null); + + $field = $this->mdb->queryOneField('nothere', "SELECT * FROM accounts"); + $this->assert($field === null); + + $column = $this->mdb->queryFirstColumn("SELECT * FROM accounts"); + $this->assert(is_array($column) && count($column) === 0); + + $column = $this->mdb->queryOneColumn('nothere', "SELECT * FROM accounts"); //TODO: is this what we want? + $this->assert(is_array($column) && count($column) === 0); + } + + function test_2_insert_row() { + $this->mdb->insert('accounts', array( + 'username' => 'Abe', + 'password' => 'hello' + )); + + $this->assert($this->mdb->affectedRows() === 1); + + $counter = $this->mdb->queryFirstField("SELECT COUNT(*) FROM accounts"); + $this->assert($counter === strval(1)); + } + + function test_3_more_inserts() { + $this->mdb->insert('`accounts`', array( + 'username' => 'Bart', + 'password' => 'hello', + 'age' => 15, + 'height' => 10.371 + )); + $dbname = $this->mdb->dbName; + $this->mdb->insert("`$dbname`.`accounts`", array( + 'username' => 'Charlie\'s Friend', + 'password' => 'goodbye', + 'age' => 30, + 'height' => 155.23, + 'favorite_word' => null, + )); + + $this->assert($this->mdb->insertId() === 3); + + $counter = $this->mdb->queryFirstField("SELECT COUNT(*) FROM accounts"); + $this->assert($counter === strval(3)); + + $password = $this->mdb->queryFirstField("SELECT password FROM accounts WHERE favorite_word IS NULL"); + $this->assert($password === 'goodbye'); + + $this->mdb->param_char = '###'; + $bart = $this->mdb->queryFirstRow("SELECT * FROM accounts WHERE age IN ###li AND height IN ###ld AND username IN ###ls", + array(15, 25), array(10.371, 150.123), array('Bart', 'Barts')); + $this->assert($bart['username'] === 'Bart'); + $this->mdb->param_char = '%'; + + $charlie_password = $this->mdb->queryFirstField("SELECT password FROM accounts WHERE username IN %ls AND username = %s", + array('Charlie', 'Charlie\'s Friend'), 'Charlie\'s Friend'); + $this->assert($charlie_password === 'goodbye'); + + $charlie_password = $this->mdb->queryOneField('password', "SELECT * FROM accounts WHERE username IN %ls AND username = %s", + array('Charlie', 'Charlie\'s Friend'), 'Charlie\'s Friend'); + $this->assert($charlie_password === 'goodbye'); + + $passwords = $this->mdb->queryFirstColumn("SELECT password FROM accounts WHERE username=%s", 'Bart'); + $this->assert(count($passwords) === 1); + $this->assert($passwords[0] === 'hello'); + + $username = $password = $age = null; + list($age, $username, $password) = $this->mdb->queryOneList("SELECT age,username,password FROM accounts WHERE username=%s", 'Bart'); + $this->assert($username === 'Bart'); + $this->assert($password === 'hello'); + $this->assert($age == 15); + + $mysqli_result = $this->mdb->queryRaw("SELECT * FROM accounts WHERE favorite_word IS NULL"); + $this->assert($mysqli_result instanceof MySQLi_Result); + $row = $mysqli_result->fetch_assoc(); + $this->assert($row['password'] === 'goodbye'); + $this->assert($mysqli_result->fetch_assoc() === null); + } + + function test_4_query() { + $results = $this->mdb->query("SELECT * FROM accounts WHERE username=%s", 'Charlie\'s Friend'); + $this->assert(count($results) === 1); + $this->assert($results[0]['age'] == 30 && $results[0]['password'] == 'goodbye'); + + $results = $this->mdb->query("SELECT * FROM accounts WHERE username!=%s", "Charlie's Friend"); + $this->assert(count($results) === 2); + + $columnlist = $this->mdb->columnList('accounts'); + $this->assert(count($columnlist) === 6); + $this->assert($columnlist[0] === 'id'); + $this->assert($columnlist[4] === 'height'); + + $tablelist = $this->mdb->tableList(); + $this->assert(count($tablelist) === 1); + $this->assert($tablelist[0] === 'accounts'); + + $tablelist = null; + $tablelist = $this->mdb->tableList($this->mdb->dbName); + $this->assert(count($tablelist) === 1); + $this->assert($tablelist[0] === 'accounts'); + } + + function test_4_1_query() { + $this->mdb->insert('accounts', array( + 'username' => 'newguy', + 'password' => $this->mdb->sqleval("REPEAT('blah', %i)", '3'), + 'age' => $this->mdb->sqleval('171+1'), + 'height' => 111.15 + )); + + $row = $this->mdb->queryOneRow("SELECT * FROM accounts WHERE password=%s", 'blahblahblah'); + $this->assert($row['username'] === 'newguy'); + $this->assert($row['age'] === '172'); + + $this->mdb->update('accounts', array( + 'password' => $this->mdb->sqleval("REPEAT('blah', %i)", 4), + 'favorite_word' => null, + ), 'username=%s', 'newguy'); + + $row = null; + $row = $this->mdb->queryOneRow("SELECT * FROM accounts WHERE username=%s", 'newguy'); + $this->assert($row['password'] === 'blahblahblahblah'); + $this->assert($row['favorite_word'] === null); + + $this->mdb->query("DELETE FROM accounts WHERE password=%s", 'blahblahblahblah'); + $this->assert($this->mdb->affectedRows() === 1); + } + + function test_4_2_delete() { + $this->mdb->insert('accounts', array( + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + )); + + $ct = $this->mdb->queryFirstField("SELECT COUNT(*) FROM accounts WHERE username=%s AND height=%d", 'gonesoon', 199.194); + $this->assert(intval($ct) === 1); + + $ct = $this->mdb->queryFirstField("SELECT COUNT(*) FROM accounts WHERE username=%s1 AND height=%d0 AND height=%d", 199.194, 'gonesoon'); + $this->assert(intval($ct) === 1); + + $this->mdb->delete('accounts', 'username=%s AND age=%i AND height=%d', 'gonesoon', '61', '199.194'); + $this->assert($this->mdb->affectedRows() === 1); + + $ct = $this->mdb->queryFirstField("SELECT COUNT(*) FROM accounts WHERE username=%s AND height=%d", 'gonesoon', '199.194'); + $this->assert(intval($ct) === 0); + } + + function test_4_3_insertmany() { + $ins[] = array( + 'username' => '1ofmany', + 'password' => 'something', + 'age' => 23, + 'height' => 190.194 + ); + $ins[] = array( + 'password' => 'somethingelse', + 'username' => '2ofmany', + 'age' => 25, + 'height' => 190.194 + ); + + $this->mdb->insert('accounts', $ins); + $this->assert($this->mdb->affectedRows() === 2); + + $rows = $this->mdb->query("SELECT * FROM accounts WHERE height=%d ORDER BY age ASC", 190.194); + $this->assert(count($rows) === 2); + $this->assert($rows[0]['username'] === '1ofmany'); + $this->assert($rows[0]['age'] === '23'); + $this->assert($rows[1]['age'] === '25'); + $this->assert($rows[1]['password'] === 'somethingelse'); + $this->assert($rows[1]['username'] === '2ofmany'); + + } + + + + function test_5_insert_blobs() { + $this->mdb->query("CREATE TABLE `storedata` ( + `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY , + `picture` BLOB + ) ENGINE = InnoDB"); + + + $smile = file_get_contents('smile1.jpg'); + $this->mdb->insert('storedata', array( + 'picture' => $smile, + )); + $this->mdb->query("INSERT INTO storedata (picture) VALUES (%s)", $smile); + + $getsmile = $this->mdb->queryFirstField("SELECT picture FROM storedata WHERE id=1"); + $getsmile2 = $this->mdb->queryFirstField("SELECT picture FROM storedata WHERE id=2"); + $this->assert($smile === $getsmile); + $this->assert($smile === $getsmile2); + } + + function test_6_insert_ignore() { + $this->mdb->insertIgnore('accounts', array( + 'id' => 1, //duplicate primary key + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + )); + } + + function test_7_insert_update() { + $this->mdb->insertUpdate('accounts', array( + 'id' => 2, //duplicate primary key + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + ), 'age = age + %i', 1); + + $this->assert($this->mdb->affectedRows() === 2); // a quirk of MySQL, even though only 1 row was updated + + $result = $this->mdb->query("SELECT * FROM accounts WHERE age = %i", 16); + $this->assert(count($result) === 1); + $this->assert($result[0]['height'] === '10.371'); + + $this->mdb->insertUpdate('accounts', array( + 'id' => 2, //duplicate primary key + 'username' => 'blahblahdude', + 'age' => 233, + 'height' => 199.194 + )); + + $result = $this->mdb->query("SELECT * FROM accounts WHERE age = %i", 233); + $this->assert(count($result) === 1); + $this->assert($result[0]['height'] === '199.194'); + $this->assert($result[0]['username'] === 'blahblahdude'); + + $this->mdb->insertUpdate('accounts', array( + 'id' => 2, //duplicate primary key + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + ), array( + 'age' => 74, + )); + + $result = $this->mdb->query("SELECT * FROM accounts WHERE age = %i", 74); + $this->assert(count($result) === 1); + $this->assert($result[0]['height'] === '199.194'); + $this->assert($result[0]['username'] === 'blahblahdude'); + + $multiples[] = array( + 'id' => 3, //duplicate primary key + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + ); + $multiples[] = array( + 'id' => 1, //duplicate primary key + 'username' => 'gonesoon', + 'password' => 'something', + 'age' => 61, + 'height' => 199.194 + ); + + $this->mdb->insertUpdate('accounts', $multiples, array('age' => 914)); + $this->assert($this->mdb->affectedRows() === 4); + + $result = $this->mdb->query("SELECT * FROM accounts WHERE age=914 ORDER BY id ASC"); + $this->assert(count($result) === 2); + $this->assert($result[0]['username'] === 'Abe'); + $this->assert($result[1]['username'] === 'Charlie\'s Friend'); + + $this->mdb->query("UPDATE accounts SET age=15, username='Bart' WHERE age=%i", 74); + $this->assert($this->mdb->affectedRows() === 1); + } + +} + + +?> diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/TransactionTest.php b/vendor/sergeytsalkov/meekrodb/simpletest/TransactionTest.php new file mode 100644 index 0000000..76f1f23 --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/simpletest/TransactionTest.php @@ -0,0 +1,30 @@ +assert($depth === 1); + + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 700, 'Abe'); + $depth = DB::startTransaction(); + $this->assert($depth === 1); + + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 800, 'Abe'); + $depth = DB::rollback(); + $this->assert($depth === 0); + + $age = DB::queryFirstField("SELECT age FROM accounts WHERE username=%s", 'Abe'); + $this->assert($age == 700); + + $depth = DB::rollback(); + $this->assert($depth === 0); + + $age = DB::queryFirstField("SELECT age FROM accounts WHERE username=%s", 'Abe'); + $this->assert($age == 700); + } + +} +?> diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/TransactionTest_55.php b/vendor/sergeytsalkov/meekrodb/simpletest/TransactionTest_55.php new file mode 100644 index 0000000..a409098 --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/simpletest/TransactionTest_55.php @@ -0,0 +1,85 @@ +assert($depth === 1); + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 700, 'Abe'); + + $depth = DB::startTransaction(); + $this->assert($depth === 2); + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 800, 'Abe'); + + $depth = DB::startTransaction(); + $this->assert($depth === 3); + $this->assert(DB::transactionDepth() === 3); + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 500, 'Abe'); + $depth = DB::commit(); + + $this->assert($depth === 2); + + $age = DB::queryFirstField("SELECT age FROM accounts WHERE username=%s", 'Abe'); + $this->assert($age == 500); + + $depth = DB::rollback(); + $this->assert($depth === 1); + + $age = DB::queryFirstField("SELECT age FROM accounts WHERE username=%s", 'Abe'); + $this->assert($age == 700); + + $depth = DB::commit(); + $this->assert($depth === 0); + + $age = DB::queryFirstField("SELECT age FROM accounts WHERE username=%s", 'Abe'); + $this->assert($age == 700); + + + DB::$nested_transactions = false; + } + + function test_2_transactions() { + DB::$nested_transactions = true; + + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 600, 'Abe'); + + DB::startTransaction(); + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 700, 'Abe'); + DB::startTransaction(); + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 800, 'Abe'); + DB::rollback(); + + $age = DB::queryFirstField("SELECT age FROM accounts WHERE username=%s", 'Abe'); + $this->assert($age == 700); + + DB::rollback(); + + $age = DB::queryFirstField("SELECT age FROM accounts WHERE username=%s", 'Abe'); + $this->assert($age == 600); + + DB::$nested_transactions = false; + } + + function test_3_transaction_rollback_all() { + DB::$nested_transactions = true; + + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 200, 'Abe'); + + $depth = DB::startTransaction(); + $this->assert($depth === 1); + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 300, 'Abe'); + $depth = DB::startTransaction(); + $this->assert($depth === 2); + + DB::query("UPDATE accounts SET age=%i WHERE username=%s", 400, 'Abe'); + $depth = DB::rollback(true); + $this->assert($depth === 0); + + $age = DB::queryFirstField("SELECT age FROM accounts WHERE username=%s", 'Abe'); + $this->assert($age == 200); + + DB::$nested_transactions = false; + } + +} +?> diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/WhereClauseTest.php b/vendor/sergeytsalkov/meekrodb/simpletest/WhereClauseTest.php new file mode 100644 index 0000000..14ceee7 --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/simpletest/WhereClauseTest.php @@ -0,0 +1,83 @@ +add('username=%s', 'Bart'); + $where->add('password=%s', 'hello'); + + $result = DB::query("SELECT * FROM accounts WHERE %l", $where->text()); + $this->assert(count($result) === 1); + $this->assert($result[0]['age'] === '15'); + } + + function test_2_simple_grouping() { + $where = new WhereClause('and'); + $where->add('password=%s', 'hello'); + $subclause = $where->addClause('or'); + $subclause->add('age=%i', 15); + $subclause->add('age=%i', 14); + + $result = DB::query("SELECT * FROM accounts WHERE %l", $where->text()); + $this->assert(count($result) === 1); + $this->assert($result[0]['age'] === '15'); + } + + function test_3_negate_last() { + $where = new WhereClause('and'); + $where->add('password=%s', 'hello'); + $subclause = $where->addClause('or'); + $subclause->add('username!=%s', 'Bart'); + $subclause->negateLast(); + + $result = DB::query("SELECT * FROM accounts WHERE %l", $where->text()); + $this->assert(count($result) === 1); + $this->assert($result[0]['age'] === '15'); + } + + function test_4_negate_last_query() { + $where = new WhereClause('and'); + $where->add('password=%s', 'hello'); + $subclause = $where->addClause('or'); + $subclause->add('username!=%s', 'Bart'); + $where->negateLast(); + + $result = DB::query("SELECT * FROM accounts WHERE %l", $where); + $this->assert(count($result) === 1); + $this->assert($result[0]['age'] === '15'); + } + + function test_5_negate() { + $where = new WhereClause('and'); + $where->add('password=%s', 'hello'); + $subclause = $where->addClause('or'); + $subclause->add('username!=%s', 'Bart'); + $subclause->negate(); + + $result = DB::query("SELECT * FROM accounts WHERE %l", $where); + $this->assert(count($result) === 1); + $this->assert($result[0]['age'] === '15'); + } + + function test_6_negate_two() { + $where = new WhereClause('and'); + $where->add('password=%s', 'hello'); + $where->add('username=%s', 'Bart'); + $where->negate(); + + $result = DB::query("SELECT * FROM accounts WHERE %l", $where); + $this->assert(count($result) === 7); + } + + function test_7_or() { + $where = new WhereClause('or'); + $where->add('username=%s', 'Bart'); + $where->add('username=%s', 'Abe'); + + $result = DB::query("SELECT * FROM accounts WHERE %l", $where); + $this->assert(count($result) === 2); + } + + +} + +?> diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/smile1.jpg b/vendor/sergeytsalkov/meekrodb/simpletest/smile1.jpg new file mode 100644 index 0000000..6726496 Binary files /dev/null and b/vendor/sergeytsalkov/meekrodb/simpletest/smile1.jpg differ diff --git a/vendor/sergeytsalkov/meekrodb/simpletest/test.php b/vendor/sergeytsalkov/meekrodb/simpletest/test.php new file mode 100755 index 0000000..6c0ae69 --- /dev/null +++ b/vendor/sergeytsalkov/meekrodb/simpletest/test.php @@ -0,0 +1,87 @@ +#!/usr/bin/php +fail(); + } + + protected function fail($msg = '') { + echo "FAILURE! $msg\n"; + debug_print_backtrace(); + die; + } + + +} + +function microtime_float() +{ + list($usec, $sec) = explode(" ", microtime()); + return ((float)$usec + (float)$sec); +} + +if (phpversion() >= '5.3') $is_php_53 = true; +else $is_php_53 = false; + +ini_set('date.timezone', 'America/Los_Angeles'); + +error_reporting(E_ALL | E_STRICT); +require_once '../db.class.php'; +include 'test_setup.php'; //test config values go here +// WARNING: ALL tables in the database will be dropped before the tests, including non-test related tables. +DB::$user = $set_db_user; +DB::$password = $set_password; +DB::$dbName = $set_db; +DB::$host = $set_host; +DB::get(); //connect to mysql + +require_once 'BasicTest.php'; +require_once 'CallTest.php'; +require_once 'ObjectTest.php'; +require_once 'WhereClauseTest.php'; +require_once 'ErrorTest.php'; +require_once 'TransactionTest.php'; +require_once 'HelperTest.php'; + +$classes_to_test = array( + 'BasicTest', + 'CallTest', + 'WhereClauseTest', + 'ObjectTest', + 'ErrorTest', + 'TransactionTest', + 'HelperTest', +); + +if ($is_php_53) { + require_once 'ErrorTest_53.php'; + $classes_to_test[] = 'ErrorTest_53'; +} else { + echo "PHP 5.3 not detected, skipping 5.3 tests..\n"; +} + +$mysql_version = DB::serverVersion(); +if ($mysql_version >= '5.5') { + require_once 'TransactionTest_55.php'; + $classes_to_test[] = 'TransactionTest_55'; +} else { + echo "MySQL 5.5 not available (version is $mysql_version) -- skipping MySQL 5.5 tests\n"; +} + +$time_start = microtime_float(); +foreach ($classes_to_test as $class) { + $object = new $class(); + + foreach (get_class_methods($object) as $method) { + if (substr($method, 0, 4) != 'test') continue; + echo "Running $class::$method..\n"; + $object->$method(); + } +} +$time_end = microtime_float(); +$time = round($time_end - $time_start, 2); + +echo "Completed in $time seconds\n"; + + +?>