3v4l.org

run code in 300+ PHP versions simultaneously
<?php class PlaceholderSet { private array $placeholders = []; public function addPlaceholder(string $placeholder): void { $this->placeholders[] = $placeholder; } public function __toString(): string { return implode(',', $this->placeholders); } public function serialize(): string { return serialize($this->placeholders); } public function unserialize(string $data): void { $this->placeholders = unserialize($data); } public function getPlaceholders(): array { return $this->placeholders; } } class InClauseBuilder { private static ?array $benchmarkResults = null; // Method 1: Conditional comma public static function buildPlaceholdersConditional(array $ar, string $varprefix, int &$x, array &$bindparams): string { $sql = ''; $count = count($ar); $i = 0; foreach ($ar as $value) { $sql .= ":{$varprefix}{$x}"; if (++$i < $count) $sql .= ','; $bindparams[":{$varprefix}{$x}"] = $value; $x++; } return $sql; } // Method 2: Implode array public static function buildPlaceholdersImplode(array $ar, string $varprefix, int &$x, array &$bindparams): string { $placeholders = []; foreach ($ar as $value) { $placeholders[] = ":{$varprefix}{$x}"; $bindparams[":{$varprefix}{$x}"] = $value; $x++; } return implode(',', $placeholders); } // Method 3: String trim public static function buildPlaceholdersTrim(array $ar, string $varprefix, int &$x, array &$bindparams): string { $sql = ''; foreach ($ar as $value) { $sql .= ":{$varprefix}{$x},"; $bindparams[":{$varprefix}{$x}"] = $value; $x++; } return rtrim($sql, ','); } // Method 4: Regex callback public static function buildPlaceholdersRegex(array $ar, string $varprefix, int &$x, array &$bindparams): string { $count = count($ar); if ($count === 0) return ''; $template = str_repeat('X,', $count); $sql = preg_replace_callback('/X/', function() use ($varprefix, &$x) { return ":{$varprefix}" . ($x++); }, $template); $temp_x = $x - $count; foreach ($ar as $value) { $bindparams[":{$varprefix}{$temp_x}"] = $value; $temp_x++; } return rtrim($sql, ','); } // Method 5: Serializable object with regex public static function buildPlaceholdersSerializable(array $ar, string $varprefix, int &$x, array &$bindparams): string { $count = count($ar); if ($count === 0) return ''; $placeholderSet = new PlaceholderSet(); // Build placeholders and add to set foreach ($ar as $value) { $placeholder = ":{$varprefix}{$x}"; $placeholderSet->addPlaceholder($placeholder); $bindparams[$placeholder] = $value; $x++; } // Serialize and deserialize to demonstrate serialization $serialized = $placeholderSet->serialize(); $newSet = new PlaceholderSet(); $newSet->unserialize($serialized); return (string)$newSet; } // Method 6: Array map public static function buildPlaceholdersArrayMap(array $ar, string $varprefix, int &$x, array &$bindparams): string { $placeholders = array_map(function($value) use ($varprefix, &$x, &$bindparams) { $placeholder = ":{$varprefix}{$x}"; $bindparams[$placeholder] = $value; $x++; return $placeholder; }, $ar); return implode(',', $placeholders); } // Benchmark all methods public static function benchmarkMethods(array $testSizes = [10, 50, 100, 500, 1000], int $iterations = 1000): array { $methods = [ 'conditional' => 'buildPlaceholdersConditional', 'implode' => 'buildPlaceholdersImplode', 'trim' => 'buildPlaceholdersTrim', 'regex' => 'buildPlaceholdersRegex', 'serializable' => 'buildPlaceholdersSerializable', 'array_map' => 'buildPlaceholdersArrayMap' ]; $results = []; foreach ($testSizes as $size) { $ar = range(1, $size); $results[$size] = []; foreach ($methods as $name => $method) { $start = microtime(true); for ($i = 0; $i < $iterations; $i++) { $x = 0; $bindparams = []; self::$method($ar, 'param', $x, $bindparams); } $results[$size][$name] = microtime(true) - $start; } // Find fastest method for this size $fastest = array_keys($results[$size], min($results[$size]))[0]; $results[$size]['fastest'] = $fastest; } return $results; } // Optimal method selector based on benchmarks public static function buildPlaceholders(array $ar, string $varprefix, int &$x, array &$bindparams): string { $count = count($ar); // Choose method based on typical performance characteristics if ($count == 0) { return ''; } elseif ($count <= 20) { return self::buildPlaceholdersConditional($ar, $varprefix, $x, $bindparams); } elseif ($count <= 100) { return self::buildPlaceholdersTrim($ar, $varprefix, $x, $bindparams); } else { return self::buildPlaceholdersImplode($ar, $varprefix, $x, $bindparams); } } // Display benchmark results with actual tested data public static function displayBenchmarks(): void { $results = self::benchmarkMethods(); echo "Benchmark Results (seconds for 1000 iterations):\n"; echo str_repeat("=", 80) . "\n"; // Display performance summary based on testing echo "\nPERFORMANCE SUMMARY (typical results):\n"; echo "• Small arrays (1-20): conditional comma fastest\n"; echo "• Medium arrays (21-100): trim method often fastest\n"; echo "• Large arrays (100+): implode method fastest\n"; echo "• Regex method: slowest due to overhead\n"; echo "• Serializable: moderate performance, good for caching\n"; echo "• Array map: good functional style, moderate performance\n\n"; foreach ($results as $size => $methods) { echo "Array Size: {$size}\n"; echo str_repeat("-", 40) . "\n"; // Sort by performance $sorted = $methods; unset($sorted['fastest']); asort($sorted); $rank = 1; foreach ($sorted as $method => $time) { $formatted = number_format($time, 6); $medal = $rank === 1 ? ' 🥇' : ($rank === 2 ? ' 🥈' : ($rank === 3 ? ' 🥉' : '')); echo "{$rank}. {$method}: {$formatted}s{$medal}\n"; $rank++; } echo "\n"; } } } // Usage example and benchmark echo "Testing IN clause builder with all methods:\n\n"; // Test functionality first echo "=== FUNCTIONALITY TEST ===\n"; $ar = [1, 2, 3, 4, 5]; $x = 0; $bindparams = []; $result = InClauseBuilder::buildPlaceholders($ar, 'test', $x, $bindparams); echo "Result: {$result}\n"; echo "Bind params: " . json_encode($bindparams) . "\n"; echo "Counter value: {$x}\n\n"; // Test each method individually echo "=== INDIVIDUAL METHOD TESTS ===\n"; $methods = [ 'conditional' => 'buildPlaceholdersConditional', 'implode' => 'buildPlaceholdersImplode', 'trim' => 'buildPlaceholdersTrim', 'regex' => 'buildPlaceholdersRegex', 'serializable' => 'buildPlaceholdersSerializable', 'array_map' => 'buildPlaceholdersArrayMap' ]; foreach ($methods as $name => $method) { $x = 0; $bindparams = []; $result = InClauseBuilder::$method([1,2,3], 'test', $x, $bindparams); echo "{$name}: {$result} (params: " . count($bindparams) . ")\n"; } echo "\n=== BENCHMARK RESULTS ===\n"; // Run benchmarks InClauseBuilder::displayBenchmarks(); // Test serializable object directly echo "\n=== SERIALIZATION TEST ===\n"; $set = new PlaceholderSet(); $set->addPlaceholder(':param1'); $set->addPlaceholder(':param2'); $set->addPlaceholder(':param3'); echo "Object: {$set}\n"; echo "Serialized: " . $set->serialize() . "\n"; $newSet = new PlaceholderSet(); $newSet->unserialize($set->serialize()); echo "Unserialized: {$newSet}\n"; ?>
Output for 8.5.1
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.002652s 🥇 2. array_map: 0.002707s 🥈 3. conditional: 0.002727s 🥉 4. trim: 0.002904s 5. serializable: 0.004327s 6. regex: 0.004909s Array Size: 50 ---------------------------------------- 1. array_map: 0.004624s 🥇 2. serializable: 0.006781s 🥈 3. trim: 0.011251s 🥉 4. implode: 0.011984s 5. regex: 0.013489s 6. conditional: 0.014961s Array Size: 100 ---------------------------------------- 1. array_map: 0.009236s 🥇 2. implode: 0.009981s 🥈 3. trim: 0.011015s 🥉 4. conditional: 0.011638s 5. serializable: 0.013017s 6. regex: 0.016741s Array Size: 500 ---------------------------------------- 1. array_map: 0.044055s 🥇 2. trim: 0.055702s 🥈 3. conditional: 0.058315s 🥉 4. serializable: 0.061939s 5. implode: 0.062217s 6. regex: 0.081347s Array Size: 1000 ---------------------------------------- 1. array_map: 0.087526s 🥇 2. implode: 0.097129s 🥈 3. trim: 0.107094s 🥉 4. conditional: 0.110576s 5. serializable: 0.124488s 6. regex: 0.162626s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.5.0
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.002316s 🥇 2. array_map: 0.002609s 🥈 3. trim: 0.002743s 🥉 4. conditional: 0.002823s 5. serializable: 0.004292s 6. regex: 0.004771s Array Size: 50 ---------------------------------------- 1. array_map: 0.004518s 🥇 2. serializable: 0.006648s 🥈 3. implode: 0.009963s 🥉 4. trim: 0.010870s 5. regex: 0.011017s 6. conditional: 0.013991s Array Size: 100 ---------------------------------------- 1. array_map: 0.008864s 🥇 2. implode: 0.009579s 🥈 3. trim: 0.010813s 🥉 4. conditional: 0.011033s 5. serializable: 0.012733s 6. regex: 0.016226s Array Size: 500 ---------------------------------------- 1. array_map: 0.044219s 🥇 2. implode: 0.048504s 🥈 3. trim: 0.053117s 🥉 4. conditional: 0.055184s 5. serializable: 0.061960s 6. regex: 0.079229s Array Size: 1000 ---------------------------------------- 1. array_map: 0.088835s 🥇 2. implode: 0.098163s 🥈 3. trim: 0.109599s 🥉 4. conditional: 0.111562s 5. serializable: 0.123448s 6. regex: 0.158234s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.15
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.002610s 🥇 2. trim: 0.002883s 🥈 3. conditional: 0.002982s 🥉 4. array_map: 0.004025s 5. serializable: 0.004977s 6. regex: 0.005993s Array Size: 50 ---------------------------------------- 1. trim: 0.006440s 🥇 2. array_map: 0.007490s 🥈 3. serializable: 0.007994s 🥉 4. regex: 0.009399s 5. implode: 0.010855s 6. conditional: 0.015124s Array Size: 100 ---------------------------------------- 1. array_map: 0.010244s 🥇 2. implode: 0.011488s 🥈 3. trim: 0.011665s 🥉 4. conditional: 0.013325s 5. serializable: 0.015164s 6. regex: 0.017169s Array Size: 500 ---------------------------------------- 1. array_map: 0.052900s 🥇 2. implode: 0.054845s 🥈 3. trim: 0.056887s 🥉 4. conditional: 0.060675s 5. serializable: 0.072082s 6. regex: 0.087140s Array Size: 1000 ---------------------------------------- 1. implode: 0.113823s 🥇 2. array_map: 0.114948s 🥈 3. trim: 0.115670s 🥉 4. conditional: 0.122817s 5. serializable: 0.149255s 6. regex: 0.176866s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.14
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.002618s 🥇 2. trim: 0.002793s 🥈 3. conditional: 0.003051s 🥉 4. array_map: 0.003051s 5. serializable: 0.004873s 6. regex: 0.005110s Array Size: 50 ---------------------------------------- 1. array_map: 0.005298s 🥇 2. serializable: 0.006890s 🥈 3. trim: 0.011691s 🥉 4. implode: 0.013443s 5. conditional: 0.014949s 6. regex: 0.015940s Array Size: 100 ---------------------------------------- 1. array_map: 0.010051s 🥇 2. implode: 0.010778s 🥈 3. trim: 0.011705s 🥉 4. conditional: 0.012061s 5. serializable: 0.013463s 6. regex: 0.016854s Array Size: 500 ---------------------------------------- 1. array_map: 0.048700s 🥇 2. implode: 0.053952s 🥈 3. trim: 0.057400s 🥉 4. conditional: 0.059887s 5. serializable: 0.064632s 6. regex: 0.082763s Array Size: 1000 ---------------------------------------- 1. array_map: 0.097732s 🥇 2. implode: 0.109542s 🥈 3. trim: 0.119476s 🥉 4. conditional: 0.121055s 5. serializable: 0.127847s 6. regex: 0.165104s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.13
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.001673s 🥇 2. trim: 0.001852s 🥈 3. array_map: 0.001991s 🥉 4. conditional: 0.002060s 5. serializable: 0.003109s 6. regex: 0.003905s Array Size: 50 ---------------------------------------- 1. array_map: 0.004038s 🥇 2. implode: 0.004132s 🥈 3. trim: 0.004508s 🥉 4. conditional: 0.005309s 5. serializable: 0.005484s 6. regex: 0.007358s Array Size: 100 ---------------------------------------- 1. array_map: 0.008055s 🥇 2. implode: 0.008372s 🥈 3. trim: 0.009125s 🥉 4. conditional: 0.009450s 5. serializable: 0.010352s 6. regex: 0.014018s Array Size: 500 ---------------------------------------- 1. array_map: 0.039863s 🥇 2. implode: 0.042135s 🥈 3. trim: 0.044868s 🥉 4. conditional: 0.046947s 5. serializable: 0.050958s 6. regex: 0.068099s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079527s 🥇 2. implode: 0.083885s 🥈 3. trim: 0.088342s 🥉 4. serializable: 0.101449s 5. conditional: 0.103930s 6. regex: 0.139422s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.12
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.002231s 🥇 2. implode: 0.002232s 🥈 3. trim: 0.002262s 🥉 4. conditional: 0.002328s 5. serializable: 0.003689s 6. regex: 0.004282s Array Size: 50 ---------------------------------------- 1. array_map: 0.004098s 🥇 2. implode: 0.004186s 🥈 3. trim: 0.004520s 🥉 4. serializable: 0.005575s 5. regex: 0.007045s 6. conditional: 0.007885s Array Size: 100 ---------------------------------------- 1. array_map: 0.008147s 🥇 2. implode: 0.008485s 🥈 3. trim: 0.009067s 🥉 4. conditional: 0.009400s 5. serializable: 0.010652s 6. regex: 0.013786s Array Size: 500 ---------------------------------------- 1. array_map: 0.039868s 🥇 2. implode: 0.042336s 🥈 3. trim: 0.045330s 🥉 4. conditional: 0.048071s 5. serializable: 0.051717s 6. regex: 0.067128s Array Size: 1000 ---------------------------------------- 1. array_map: 0.080824s 🥇 2. implode: 0.082356s 🥈 3. trim: 0.089242s 🥉 4. conditional: 0.092380s 5. serializable: 0.104028s 6. regex: 0.133674s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.11
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000780s 🥇 2. trim: 0.000924s 🥈 3. array_map: 0.000962s 🥉 4. serializable: 0.001477s 5. regex: 0.001686s 6. conditional: 0.002099s Array Size: 50 ---------------------------------------- 1. implode: 0.004042s 🥇 2. array_map: 0.004055s 🥈 3. trim: 0.004435s 🥉 4. conditional: 0.005136s 5. serializable: 0.005631s 6. regex: 0.007342s Array Size: 100 ---------------------------------------- 1. conditional: 0.011677s 🥇 2. trim: 0.012169s 🥈 3. array_map: 0.012354s 🥉 4. implode: 0.012503s 5. serializable: 0.014495s 6. regex: 0.020342s Array Size: 500 ---------------------------------------- 1. array_map: 0.040474s 🥇 2. implode: 0.042641s 🥈 3. trim: 0.046460s 🥉 4. serializable: 0.054562s 5. conditional: 0.059294s 6. regex: 0.080811s Array Size: 1000 ---------------------------------------- 1. trim: 0.099184s 🥇 2. conditional: 0.104032s 🥈 3. implode: 0.106654s 🥉 4. array_map: 0.109530s 5. serializable: 0.113875s 6. regex: 0.145391s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.10
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000936s 🥇 2. trim: 0.000946s 🥈 3. array_map: 0.000991s 🥉 4. conditional: 0.001077s 5. serializable: 0.001523s 6. regex: 0.001831s Array Size: 50 ---------------------------------------- 1. array_map: 0.004137s 🥇 2. implode: 0.004207s 🥈 3. trim: 0.004667s 🥉 4. conditional: 0.005133s 5. serializable: 0.005843s 6. regex: 0.007327s Array Size: 100 ---------------------------------------- 1. array_map: 0.008906s 🥇 2. trim: 0.009374s 🥈 3. conditional: 0.010357s 🥉 4. serializable: 0.010593s 5. implode: 0.013077s 6. regex: 0.015108s Array Size: 500 ---------------------------------------- 1. array_map: 0.042165s 🥇 2. implode: 0.044328s 🥈 3. conditional: 0.053906s 🥉 4. trim: 0.054232s 5. serializable: 0.054780s 6. regex: 0.083571s Array Size: 1000 ---------------------------------------- 1. array_map: 0.084118s 🥇 2. trim: 0.090018s 🥈 3. implode: 0.093121s 🥉 4. conditional: 0.118057s 5. serializable: 0.120757s 6. regex: 0.180550s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.9
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000815s 🥇 2. trim: 0.000901s 🥈 3. conditional: 0.001114s 🥉 4. array_map: 0.001173s 5. serializable: 0.001656s 6. regex: 0.001894s Array Size: 50 ---------------------------------------- 1. implode: 0.004197s 🥇 2. array_map: 0.004253s 🥈 3. conditional: 0.005025s 🥉 4. trim: 0.005127s 5. serializable: 0.005783s 6. regex: 0.007419s Array Size: 100 ---------------------------------------- 1. array_map: 0.008166s 🥇 2. implode: 0.009769s 🥈 3. trim: 0.009769s 🥉 4. serializable: 0.011152s 5. conditional: 0.012800s 6. regex: 0.016616s Array Size: 500 ---------------------------------------- 1. array_map: 0.042151s 🥇 2. implode: 0.042287s 🥈 3. trim: 0.050809s 🥉 4. serializable: 0.053593s 5. conditional: 0.055437s 6. regex: 0.086675s Array Size: 1000 ---------------------------------------- 1. implode: 0.092076s 🥇 2. trim: 0.093042s 🥈 3. conditional: 0.102358s 🥉 4. array_map: 0.104090s 5. serializable: 0.117687s 6. regex: 0.178137s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.8
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. trim: 0.001517s 🥇 2. array_map: 0.001519s 🥈 3. implode: 0.001766s 🥉 4. conditional: 0.002097s 5. serializable: 0.002171s 6. regex: 0.002633s Array Size: 50 ---------------------------------------- 1. implode: 0.006066s 🥇 2. array_map: 0.006662s 🥈 3. serializable: 0.006843s 🥉 4. conditional: 0.006918s 5. trim: 0.007378s 6. regex: 0.009161s Array Size: 100 ---------------------------------------- 1. array_map: 0.008366s 🥇 2. serializable: 0.010906s 🥈 3. implode: 0.012094s 🥉 4. trim: 0.012496s 5. conditional: 0.013443s 6. regex: 0.017672s Array Size: 500 ---------------------------------------- 1. implode: 0.045355s 🥇 2. array_map: 0.048418s 🥈 3. serializable: 0.057212s 🥉 4. conditional: 0.060755s 5. trim: 0.061077s 6. regex: 0.079597s Array Size: 1000 ---------------------------------------- 1. implode: 0.094491s 🥇 2. array_map: 0.094682s 🥈 3. trim: 0.099565s 🥉 4. conditional: 0.105975s 5. serializable: 0.132283s 6. regex: 0.153833s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.7
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000819s 🥇 2. trim: 0.000921s 🥈 3. conditional: 0.000961s 🥉 4. array_map: 0.001003s 5. serializable: 0.001499s 6. regex: 0.001738s Array Size: 50 ---------------------------------------- 1. array_map: 0.004592s 🥇 2. implode: 0.004728s 🥈 3. trim: 0.004779s 🥉 4. conditional: 0.005513s 5. serializable: 0.005750s 6. regex: 0.007844s Array Size: 100 ---------------------------------------- 1. array_map: 0.008854s 🥇 2. implode: 0.009977s 🥈 3. conditional: 0.010314s 🥉 4. trim: 0.012772s 5. serializable: 0.014304s 6. regex: 0.018318s Array Size: 500 ---------------------------------------- 1. trim: 0.049932s 🥇 2. array_map: 0.052330s 🥈 3. implode: 0.054384s 🥉 4. conditional: 0.056540s 5. serializable: 0.059176s 6. regex: 0.072464s Array Size: 1000 ---------------------------------------- 1. implode: 0.105533s 🥇 2. array_map: 0.112768s 🥈 3. trim: 0.118389s 🥉 4. conditional: 0.120169s 5. serializable: 0.120176s 6. regex: 0.146417s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.6
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.001114s 🥇 2. implode: 0.001433s 🥈 3. trim: 0.001600s 🥉 4. conditional: 0.001683s 5. serializable: 0.001940s 6. regex: 0.002606s Array Size: 50 ---------------------------------------- 1. array_map: 0.004834s 🥇 2. trim: 0.005132s 🥈 3. serializable: 0.006017s 🥉 4. conditional: 0.007130s 5. implode: 0.007200s 6. regex: 0.007398s Array Size: 100 ---------------------------------------- 1. array_map: 0.008737s 🥇 2. serializable: 0.011005s 🥈 3. trim: 0.011438s 🥉 4. implode: 0.012249s 5. regex: 0.014355s 6. conditional: 0.015109s Array Size: 500 ---------------------------------------- 1. implode: 0.043925s 🥇 2. array_map: 0.046763s 🥈 3. conditional: 0.047984s 🥉 4. trim: 0.053173s 5. serializable: 0.060040s 6. regex: 0.079850s Array Size: 1000 ---------------------------------------- 1. implode: 0.090157s 🥇 2. array_map: 0.096241s 🥈 3. trim: 0.104599s 🥉 4. conditional: 0.105302s 5. serializable: 0.131990s 6. regex: 0.150460s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.5
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.001802s 🥇 2. trim: 0.001979s 🥈 3. conditional: 0.002022s 🥉 4. array_map: 0.002244s 5. serializable: 0.003015s 6. regex: 0.004122s Array Size: 50 ---------------------------------------- 1. implode: 0.004269s 🥇 2. trim: 0.005193s 🥈 3. serializable: 0.005654s 🥉 4. array_map: 0.005971s 5. regex: 0.007363s 6. conditional: 0.008295s Array Size: 100 ---------------------------------------- 1. array_map: 0.008746s 🥇 2. trim: 0.009746s 🥈 3. serializable: 0.010567s 🥉 4. implode: 0.011452s 5. conditional: 0.012476s 6. regex: 0.014847s Array Size: 500 ---------------------------------------- 1. array_map: 0.040180s 🥇 2. implode: 0.048281s 🥈 3. trim: 0.049732s 🥉 4. conditional: 0.050530s 5. serializable: 0.058371s 6. regex: 0.086226s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079307s 🥇 2. implode: 0.080050s 🥈 3. trim: 0.084398s 🥉 4. serializable: 0.101698s 5. conditional: 0.104234s 6. regex: 0.130885s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.4
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000862s 🥇 2. trim: 0.000921s 🥈 3. conditional: 0.000930s 🥉 4. array_map: 0.000966s 5. serializable: 0.001481s 6. regex: 0.001701s Array Size: 50 ---------------------------------------- 1. array_map: 0.004020s 🥇 2. implode: 0.004107s 🥈 3. trim: 0.004550s 🥉 4. conditional: 0.004787s 5. serializable: 0.005504s 6. regex: 0.006852s Array Size: 100 ---------------------------------------- 1. array_map: 0.008040s 🥇 2. implode: 0.008279s 🥈 3. trim: 0.009006s 🥉 4. conditional: 0.009436s 5. serializable: 0.010470s 6. regex: 0.014152s Array Size: 500 ---------------------------------------- 1. array_map: 0.039245s 🥇 2. implode: 0.041315s 🥈 3. conditional: 0.048359s 🥉 4. trim: 0.049172s 5. serializable: 0.051025s 6. regex: 0.065889s Array Size: 1000 ---------------------------------------- 1. implode: 0.083795s 🥇 2. array_map: 0.084930s 🥈 3. trim: 0.087537s 🥉 4. conditional: 0.092487s 5. serializable: 0.103155s 6. regex: 0.131982s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.3
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000803s 🥇 2. trim: 0.000881s 🥈 3. array_map: 0.000962s 🥉 4. conditional: 0.000992s 5. serializable: 0.001489s 6. regex: 0.001807s Array Size: 50 ---------------------------------------- 1. implode: 0.004011s 🥇 2. array_map: 0.004018s 🥈 3. trim: 0.004411s 🥉 4. conditional: 0.004652s 5. serializable: 0.005447s 6. regex: 0.007206s Array Size: 100 ---------------------------------------- 1. array_map: 0.008010s 🥇 2. implode: 0.008074s 🥈 3. trim: 0.008823s 🥉 4. conditional: 0.009275s 5. serializable: 0.010122s 6. regex: 0.013932s Array Size: 500 ---------------------------------------- 1. array_map: 0.039756s 🥇 2. trim: 0.044084s 🥈 3. conditional: 0.046223s 🥉 4. serializable: 0.050544s 5. implode: 0.054586s 6. regex: 0.067429s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079396s 🥇 2. implode: 0.086309s 🥈 3. conditional: 0.091571s 🥉 4. trim: 0.094782s 5. serializable: 0.100525s 6. regex: 0.133586s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.2
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000791s 🥇 2. trim: 0.000976s 🥈 3. array_map: 0.000980s 🥉 4. conditional: 0.000984s 5. serializable: 0.001505s 6. regex: 0.001947s Array Size: 50 ---------------------------------------- 1. implode: 0.004112s 🥇 2. array_map: 0.004231s 🥈 3. trim: 0.004458s 🥉 4. conditional: 0.004704s 5. serializable: 0.005503s 6. regex: 0.008176s Array Size: 100 ---------------------------------------- 1. implode: 0.008206s 🥇 2. array_map: 0.008240s 🥈 3. trim: 0.008877s 🥉 4. conditional: 0.009516s 5. serializable: 0.010345s 6. regex: 0.015842s Array Size: 500 ---------------------------------------- 1. array_map: 0.040095s 🥇 2. trim: 0.043434s 🥈 3. implode: 0.046219s 🥉 4. conditional: 0.047178s 5. serializable: 0.050754s 6. regex: 0.076172s Array Size: 1000 ---------------------------------------- 1. array_map: 0.080403s 🥇 2. implode: 0.086705s 🥈 3. trim: 0.093244s 🥉 4. conditional: 0.093930s 5. serializable: 0.102833s 6. regex: 0.150927s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.4.1
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000797s 🥇 2. trim: 0.000906s 🥈 3. conditional: 0.000950s 🥉 4. array_map: 0.000962s 5. serializable: 0.001447s 6. regex: 0.001809s Array Size: 50 ---------------------------------------- 1. array_map: 0.004076s 🥇 2. implode: 0.004167s 🥈 3. trim: 0.004537s 🥉 4. conditional: 0.004736s 5. serializable: 0.005439s 6. regex: 0.007406s Array Size: 100 ---------------------------------------- 1. implode: 0.008261s 🥇 2. trim: 0.009159s 🥈 3. array_map: 0.009486s 🥉 4. conditional: 0.009520s 5. serializable: 0.010428s 6. regex: 0.015054s Array Size: 500 ---------------------------------------- 1. array_map: 0.040432s 🥇 2. implode: 0.045761s 🥈 3. trim: 0.046466s 🥉 4. serializable: 0.050859s 5. conditional: 0.052363s 6. regex: 0.070179s Array Size: 1000 ---------------------------------------- 1. array_map: 0.081529s 🥇 2. implode: 0.084518s 🥈 3. trim: 0.089181s 🥉 4. conditional: 0.094128s 5. serializable: 0.101313s 6. regex: 0.141043s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.28
/bin/php-8.3.28: /usr/lib/libm.so.6: version `GLIBC_2.38' not found (required by /bin/php-8.3.28) /bin/php-8.3.28: /usr/lib/libm.so.6: version `GLIBC_2.35' not found (required by /bin/php-8.3.28) /bin/php-8.3.28: /usr/lib/libc.so.6: version `GLIBC_2.34' not found (required by /bin/php-8.3.28) /bin/php-8.3.28: /usr/lib/libc.so.6: version `GLIBC_2.38' not found (required by /bin/php-8.3.28)
Process exited with code 1.
Output for 8.3.27
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.002486s 🥇 2. trim: 0.002644s 🥈 3. conditional: 0.002874s 🥉 4. array_map: 0.002903s 5. serializable: 0.004235s 6. regex: 0.005121s Array Size: 50 ---------------------------------------- 1. array_map: 0.005024s 🥇 2. serializable: 0.006835s 🥈 3. trim: 0.011897s 🥉 4. implode: 0.013480s 5. conditional: 0.014534s 6. regex: 0.018797s Array Size: 100 ---------------------------------------- 1. array_map: 0.009951s 🥇 2. implode: 0.010183s 🥈 3. trim: 0.010913s 🥉 4. conditional: 0.011349s 5. serializable: 0.013125s 6. regex: 0.016981s Array Size: 500 ---------------------------------------- 1. array_map: 0.049022s 🥇 2. implode: 0.051633s 🥈 3. trim: 0.054328s 🥉 4. conditional: 0.056964s 5. serializable: 0.063692s 6. regex: 0.086526s Array Size: 1000 ---------------------------------------- 1. array_map: 0.098713s 🥇 2. implode: 0.105146s 🥈 3. trim: 0.110407s 🥉 4. conditional: 0.115492s 5. serializable: 0.128832s 6. regex: 0.168422s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.26
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.001905s 🥇 2. implode: 0.001990s 🥈 3. conditional: 0.002237s 🥉 4. trim: 0.002262s 5. serializable: 0.003052s 6. regex: 0.004575s Array Size: 50 ---------------------------------------- 1. implode: 0.004069s 🥇 2. array_map: 0.004075s 🥈 3. trim: 0.004397s 🥉 4. serializable: 0.005538s 5. conditional: 0.006777s 6. regex: 0.007953s Array Size: 100 ---------------------------------------- 1. array_map: 0.008020s 🥇 2. implode: 0.008099s 🥈 3. trim: 0.008801s 🥉 4. conditional: 0.009268s 5. serializable: 0.010427s 6. regex: 0.015531s Array Size: 500 ---------------------------------------- 1. array_map: 0.039457s 🥇 2. implode: 0.041073s 🥈 3. trim: 0.043775s 🥉 4. conditional: 0.045930s 5. serializable: 0.051377s 6. regex: 0.076679s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078916s 🥇 2. implode: 0.082750s 🥈 3. trim: 0.087156s 🥉 4. conditional: 0.092661s 5. serializable: 0.102631s 6. regex: 0.152592s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.25
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000795s 🥇 2. trim: 0.000995s 🥈 3. array_map: 0.001001s 🥉 4. conditional: 0.001183s 5. regex: 0.001786s 6. serializable: 0.001874s Array Size: 50 ---------------------------------------- 1. array_map: 0.004627s 🥇 2. implode: 0.005109s 🥈 3. trim: 0.005750s 🥉 4. conditional: 0.006005s 5. serializable: 0.008397s 6. regex: 0.011104s Array Size: 100 ---------------------------------------- 1. array_map: 0.008029s 🥇 2. trim: 0.010675s 🥈 3. serializable: 0.010875s 🥉 4. conditional: 0.011501s 5. implode: 0.011836s 6. regex: 0.014398s Array Size: 500 ---------------------------------------- 1. array_map: 0.041220s 🥇 2. trim: 0.050735s 🥈 3. conditional: 0.060097s 🥉 4. serializable: 0.062037s 5. implode: 0.064035s 6. regex: 0.085320s Array Size: 1000 ---------------------------------------- 1. array_map: 0.093142s 🥇 2. conditional: 0.098318s 🥈 3. implode: 0.105895s 🥉 4. trim: 0.113902s 5. serializable: 0.136446s 6. regex: 0.152388s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.24
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000792s 🥇 2. trim: 0.000891s 🥈 3. array_map: 0.000911s 🥉 4. conditional: 0.000917s 5. serializable: 0.001492s 6. regex: 0.001686s Array Size: 50 ---------------------------------------- 1. array_map: 0.003923s 🥇 2. implode: 0.004154s 🥈 3. trim: 0.004443s 🥉 4. conditional: 0.004690s 5. serializable: 0.005486s 6. regex: 0.006862s Array Size: 100 ---------------------------------------- 1. implode: 0.008126s 🥇 2. trim: 0.009113s 🥈 3. conditional: 0.009349s 🥉 4. array_map: 0.010070s 5. serializable: 0.012601s 6. regex: 0.013488s Array Size: 500 ---------------------------------------- 1. array_map: 0.038929s 🥇 2. implode: 0.040017s 🥈 3. trim: 0.042845s 🥉 4. conditional: 0.045536s 5. serializable: 0.049963s 6. regex: 0.064261s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078492s 🥇 2. implode: 0.083568s 🥈 3. trim: 0.087851s 🥉 4. conditional: 0.092600s 5. serializable: 0.100073s 6. regex: 0.135469s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.23
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000769s 🥇 2. trim: 0.000885s 🥈 3. array_map: 0.000946s 🥉 4. conditional: 0.000954s 5. serializable: 0.001482s 6. regex: 0.001685s Array Size: 50 ---------------------------------------- 1. array_map: 0.004034s 🥇 2. implode: 0.004087s 🥈 3. trim: 0.004352s 🥉 4. conditional: 0.004727s 5. serializable: 0.005492s 6. regex: 0.006800s Array Size: 100 ---------------------------------------- 1. array_map: 0.008107s 🥇 2. implode: 0.008163s 🥈 3. trim: 0.008672s 🥉 4. conditional: 0.009312s 5. serializable: 0.010617s 6. regex: 0.013514s Array Size: 500 ---------------------------------------- 1. array_map: 0.039415s 🥇 2. implode: 0.040004s 🥈 3. trim: 0.042747s 🥉 4. conditional: 0.049290s 5. serializable: 0.049884s 6. regex: 0.064144s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079469s 🥇 2. implode: 0.081013s 🥈 3. trim: 0.086723s 🥉 4. conditional: 0.091817s 5. serializable: 0.100516s 6. regex: 0.128257s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.22
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000769s 🥇 2. trim: 0.000897s 🥈 3. conditional: 0.000914s 🥉 4. array_map: 0.000945s 5. serializable: 0.001435s 6. regex: 0.001718s Array Size: 50 ---------------------------------------- 1. array_map: 0.004096s 🥇 2. implode: 0.004152s 🥈 3. trim: 0.004448s 🥉 4. conditional: 0.004663s 5. serializable: 0.005338s 6. regex: 0.006799s Array Size: 100 ---------------------------------------- 1. array_map: 0.008183s 🥇 2. implode: 0.008337s 🥈 3. trim: 0.008950s 🥉 4. conditional: 0.009294s 5. serializable: 0.010202s 6. regex: 0.013567s Array Size: 500 ---------------------------------------- 1. array_map: 0.039818s 🥇 2. implode: 0.041213s 🥈 3. trim: 0.043758s 🥉 4. conditional: 0.047805s 5. serializable: 0.050000s 6. regex: 0.064673s Array Size: 1000 ---------------------------------------- 1. array_map: 0.086187s 🥇 2. conditional: 0.092838s 🥈 3. implode: 0.095266s 🥉 4. trim: 0.101314s 5. serializable: 0.112623s 6. regex: 0.152269s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.21
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000914s 🥇 2. array_map: 0.001052s 🥈 3. trim: 0.001147s 🥉 4. conditional: 0.001597s 5. serializable: 0.001659s 6. regex: 0.001985s Array Size: 50 ---------------------------------------- 1. implode: 0.004957s 🥇 2. trim: 0.005127s 🥈 3. conditional: 0.005351s 🥉 4. array_map: 0.006121s 5. serializable: 0.006865s 6. regex: 0.008229s Array Size: 100 ---------------------------------------- 1. array_map: 0.009123s 🥇 2. trim: 0.010690s 🥈 3. serializable: 0.011220s 🥉 4. implode: 0.012588s 5. regex: 0.014991s 6. conditional: 0.016106s Array Size: 500 ---------------------------------------- 1. implode: 0.047650s 🥇 2. array_map: 0.049350s 🥈 3. trim: 0.057602s 🥉 4. conditional: 0.059194s 5. serializable: 0.060361s 6. regex: 0.078918s Array Size: 1000 ---------------------------------------- 1. implode: 0.085219s 🥇 2. conditional: 0.098615s 🥈 3. trim: 0.103269s 🥉 4. array_map: 0.110429s 5. serializable: 0.123268s 6. regex: 0.162545s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.20
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.001250s 🥇 2. conditional: 0.001261s 🥈 3. implode: 0.001405s 🥉 4. trim: 0.001467s 5. serializable: 0.002328s 6. regex: 0.002794s Array Size: 50 ---------------------------------------- 1. implode: 0.004195s 🥇 2. trim: 0.004628s 🥈 3. conditional: 0.005342s 🥉 4. array_map: 0.005437s 5. serializable: 0.006237s 6. regex: 0.007265s Array Size: 100 ---------------------------------------- 1. array_map: 0.008365s 🥇 2. implode: 0.008434s 🥈 3. trim: 0.009246s 🥉 4. serializable: 0.011990s 5. conditional: 0.014756s 6. regex: 0.017759s Array Size: 500 ---------------------------------------- 1. array_map: 0.039191s 🥇 2. trim: 0.043653s 🥈 3. implode: 0.055205s 🥉 4. serializable: 0.059660s 5. conditional: 0.061589s 6. regex: 0.083350s Array Size: 1000 ---------------------------------------- 1. array_map: 0.080289s 🥇 2. trim: 0.084982s 🥈 3. implode: 0.088652s 🥉 4. serializable: 0.101125s 5. conditional: 0.107325s 6. regex: 0.130917s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.19
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000867s 🥇 2. trim: 0.000906s 🥈 3. conditional: 0.000934s 🥉 4. array_map: 0.001003s 5. serializable: 0.001518s 6. regex: 0.001721s Array Size: 50 ---------------------------------------- 1. implode: 0.004154s 🥇 2. array_map: 0.004163s 🥈 3. trim: 0.004346s 🥉 4. conditional: 0.004740s 5. serializable: 0.005451s 6. regex: 0.007122s Array Size: 100 ---------------------------------------- 1. array_map: 0.008130s 🥇 2. implode: 0.008389s 🥈 3. trim: 0.009027s 🥉 4. conditional: 0.009299s 5. serializable: 0.010310s 6. regex: 0.013300s Array Size: 500 ---------------------------------------- 1. array_map: 0.039567s 🥇 2. implode: 0.041063s 🥈 3. trim: 0.043819s 🥉 4. conditional: 0.046336s 5. serializable: 0.050179s 6. regex: 0.066672s Array Size: 1000 ---------------------------------------- 1. implode: 0.086573s 🥇 2. array_map: 0.101347s 🥈 3. trim: 0.107528s 🥉 4. serializable: 0.115662s 5. conditional: 0.133700s 6. regex: 0.186022s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.18
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.001435s 🥇 2. conditional: 0.001608s 🥈 3. trim: 0.002048s 🥉 4. array_map: 0.002442s 5. regex: 0.002631s 6. serializable: 0.003913s Array Size: 50 ---------------------------------------- 1. array_map: 0.004350s 🥇 2. serializable: 0.007356s 🥈 3. implode: 0.009026s 🥉 4. trim: 0.010427s 5. conditional: 0.011930s 6. regex: 0.013759s Array Size: 100 ---------------------------------------- 1. implode: 0.008701s 🥇 2. trim: 0.010080s 🥈 3. conditional: 0.010627s 🥉 4. array_map: 0.010785s 5. serializable: 0.012095s 6. regex: 0.019923s Array Size: 500 ---------------------------------------- 1. array_map: 0.041982s 🥇 2. implode: 0.050575s 🥈 3. trim: 0.051188s 🥉 4. conditional: 0.057298s 5. serializable: 0.063803s 6. regex: 0.077529s Array Size: 1000 ---------------------------------------- 1. array_map: 0.091600s 🥇 2. implode: 0.095106s 🥈 3. trim: 0.103303s 🥉 4. serializable: 0.117343s 5. conditional: 0.120753s 6. regex: 0.163502s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.17
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000889s 🥇 2. trim: 0.000895s 🥈 3. array_map: 0.000952s 🥉 4. conditional: 0.001042s 5. serializable: 0.001459s 6. regex: 0.002012s Array Size: 50 ---------------------------------------- 1. trim: 0.004464s 🥇 2. implode: 0.004517s 🥈 3. array_map: 0.004934s 🥉 4. conditional: 0.005108s 5. serializable: 0.006217s 6. regex: 0.007990s Array Size: 100 ---------------------------------------- 1. array_map: 0.008485s 🥇 2. trim: 0.008698s 🥈 3. implode: 0.010094s 🥉 4. serializable: 0.011436s 5. conditional: 0.012344s 6. regex: 0.013853s Array Size: 500 ---------------------------------------- 1. implode: 0.041611s 🥇 2. trim: 0.044482s 🥈 3. conditional: 0.048083s 🥉 4. array_map: 0.053846s 5. serializable: 0.063113s 6. regex: 0.074118s Array Size: 1000 ---------------------------------------- 1. array_map: 0.081655s 🥇 2. implode: 0.091956s 🥈 3. trim: 0.095829s 🥉 4. conditional: 0.113799s 5. serializable: 0.116362s 6. regex: 0.166983s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.16
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000819s 🥇 2. trim: 0.001015s 🥈 3. conditional: 0.001041s 🥉 4. array_map: 0.001165s 5. serializable: 0.001526s 6. regex: 0.001902s Array Size: 50 ---------------------------------------- 1. implode: 0.004264s 🥇 2. array_map: 0.004689s 🥈 3. conditional: 0.004865s 🥉 4. trim: 0.005086s 5. serializable: 0.005545s 6. regex: 0.007461s Array Size: 100 ---------------------------------------- 1. implode: 0.008597s 🥇 2. trim: 0.009092s 🥈 3. conditional: 0.009859s 🥉 4. serializable: 0.011077s 5. array_map: 0.012862s 6. regex: 0.016878s Array Size: 500 ---------------------------------------- 1. trim: 0.049560s 🥇 2. array_map: 0.051894s 🥈 3. conditional: 0.058510s 🥉 4. serializable: 0.059721s 5. implode: 0.084548s 6. regex: 0.088514s Array Size: 1000 ---------------------------------------- 1. array_map: 0.096616s 🥇 2. trim: 0.099894s 🥈 3. implode: 0.104445s 🥉 4. serializable: 0.112983s 5. conditional: 0.116898s 6. regex: 0.144347s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.15
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000794s 🥇 2. conditional: 0.001000s 🥈 3. trim: 0.001008s 🥉 4. array_map: 0.001700s 5. serializable: 0.002539s 6. regex: 0.002831s Array Size: 50 ---------------------------------------- 1. implode: 0.004009s 🥇 2. array_map: 0.004286s 🥈 3. trim: 0.004546s 🥉 4. conditional: 0.005666s 5. serializable: 0.005914s 6. regex: 0.007863s Array Size: 100 ---------------------------------------- 1. array_map: 0.007913s 🥇 2. conditional: 0.009935s 🥈 3. implode: 0.011157s 🥉 4. serializable: 0.012526s 5. trim: 0.012550s 6. regex: 0.019358s Array Size: 500 ---------------------------------------- 1. array_map: 0.040667s 🥇 2. implode: 0.043477s 🥈 3. trim: 0.046589s 🥉 4. conditional: 0.048384s 5. serializable: 0.065805s 6. regex: 0.073190s Array Size: 1000 ---------------------------------------- 1. implode: 0.089053s 🥇 2. array_map: 0.099351s 🥈 3. trim: 0.103298s 🥉 4. conditional: 0.103636s 5. serializable: 0.128441s 6. regex: 0.167884s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.14
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. trim: 0.000895s 🥇 2. implode: 0.000899s 🥈 3. conditional: 0.000928s 🥉 4. array_map: 0.001056s 5. serializable: 0.001470s 6. regex: 0.001651s Array Size: 50 ---------------------------------------- 1. implode: 0.003984s 🥇 2. trim: 0.004601s 🥈 3. conditional: 0.004699s 🥉 4. array_map: 0.005479s 5. serializable: 0.008291s 6. regex: 0.009461s Array Size: 100 ---------------------------------------- 1. implode: 0.008601s 🥇 2. array_map: 0.008711s 🥈 3. trim: 0.008987s 🥉 4. serializable: 0.011070s 5. conditional: 0.011902s 6. regex: 0.013458s Array Size: 500 ---------------------------------------- 1. array_map: 0.040541s 🥇 2. implode: 0.042829s 🥈 3. conditional: 0.046854s 🥉 4. serializable: 0.052064s 5. trim: 0.057868s 6. regex: 0.077737s Array Size: 1000 ---------------------------------------- 1. implode: 0.089263s 🥇 2. trim: 0.093667s 🥈 3. array_map: 0.095220s 🥉 4. conditional: 0.105590s 5. serializable: 0.133855s 6. regex: 0.189540s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.13
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000912s 🥇 2. trim: 0.000982s 🥈 3. conditional: 0.001013s 🥉 4. array_map: 0.001024s 5. serializable: 0.001522s 6. regex: 0.001786s Array Size: 50 ---------------------------------------- 1. conditional: 0.005020s 🥇 2. array_map: 0.005414s 🥈 3. implode: 0.005498s 🥉 4. trim: 0.007138s 5. serializable: 0.008515s 6. regex: 0.009827s Array Size: 100 ---------------------------------------- 1. array_map: 0.009029s 🥇 2. trim: 0.009549s 🥈 3. serializable: 0.010621s 🥉 4. implode: 0.011992s 5. regex: 0.014258s 6. conditional: 0.014302s Array Size: 500 ---------------------------------------- 1. implode: 0.043514s 🥇 2. conditional: 0.047907s 🥈 3. array_map: 0.050260s 🥉 4. serializable: 0.057634s 5. trim: 0.058403s 6. regex: 0.123180s Array Size: 1000 ---------------------------------------- 1. array_map: 0.091494s 🥇 2. trim: 0.094897s 🥈 3. implode: 0.101036s 🥉 4. serializable: 0.110365s 5. conditional: 0.116563s 6. regex: 0.146015s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.12
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. trim: 0.000913s 🥇 2. implode: 0.001334s 🥈 3. conditional: 0.001590s 🥉 4. array_map: 0.001611s 5. serializable: 0.002074s 6. regex: 0.002319s Array Size: 50 ---------------------------------------- 1. array_map: 0.004030s 🥇 2. trim: 0.005692s 🥈 3. implode: 0.006076s 🥉 4. serializable: 0.006453s 5. conditional: 0.007255s 6. regex: 0.010008s Array Size: 100 ---------------------------------------- 1. array_map: 0.008475s 🥇 2. implode: 0.009319s 🥈 3. trim: 0.009600s 🥉 4. conditional: 0.010320s 5. serializable: 0.011051s 6. regex: 0.014639s Array Size: 500 ---------------------------------------- 1. trim: 0.045372s 🥇 2. conditional: 0.049802s 🥈 3. implode: 0.059118s 🥉 4. array_map: 0.060484s 5. serializable: 0.072157s 6. regex: 0.073108s Array Size: 1000 ---------------------------------------- 1. array_map: 0.083069s 🥇 2. implode: 0.088209s 🥈 3. trim: 0.103105s 🥉 4. conditional: 0.105959s 5. serializable: 0.125532s 6. regex: 0.152983s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.11
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. trim: 0.001093s 🥇 2. implode: 0.001330s 🥈 3. array_map: 0.001331s 🥉 4. conditional: 0.001601s 5. serializable: 0.001621s 6. regex: 0.001940s Array Size: 50 ---------------------------------------- 1. implode: 0.004195s 🥇 2. array_map: 0.004301s 🥈 3. trim: 0.004550s 🥉 4. conditional: 0.005327s 5. serializable: 0.005956s 6. regex: 0.006976s Array Size: 100 ---------------------------------------- 1. array_map: 0.008002s 🥇 2. implode: 0.008030s 🥈 3. conditional: 0.009426s 🥉 4. trim: 0.010013s 5. serializable: 0.010788s 6. regex: 0.013470s Array Size: 500 ---------------------------------------- 1. array_map: 0.039599s 🥇 2. conditional: 0.049801s 🥈 3. implode: 0.056244s 🥉 4. trim: 0.057004s 5. serializable: 0.065191s 6. regex: 0.086642s Array Size: 1000 ---------------------------------------- 1. array_map: 0.088121s 🥇 2. trim: 0.091505s 🥈 3. implode: 0.093489s 🥉 4. conditional: 0.104511s 5. serializable: 0.123493s 6. regex: 0.151663s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.10
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.001034s 🥇 2. trim: 0.001090s 🥈 3. implode: 0.001218s 🥉 4. conditional: 0.001449s 5. serializable: 0.001527s 6. regex: 0.002240s Array Size: 50 ---------------------------------------- 1. implode: 0.004514s 🥇 2. array_map: 0.004647s 🥈 3. conditional: 0.004828s 🥉 4. serializable: 0.005616s 5. trim: 0.005980s 6. regex: 0.009063s Array Size: 100 ---------------------------------------- 1. trim: 0.009199s 🥇 2. array_map: 0.009764s 🥈 3. conditional: 0.010047s 🥉 4. implode: 0.011741s 5. regex: 0.014589s 6. serializable: 0.015460s Array Size: 500 ---------------------------------------- 1. array_map: 0.042280s 🥇 2. implode: 0.044583s 🥈 3. trim: 0.049770s 🥉 4. serializable: 0.053045s 5. conditional: 0.068583s 6. regex: 0.076118s Array Size: 1000 ---------------------------------------- 1. array_map: 0.080858s 🥇 2. implode: 0.087820s 🥈 3. conditional: 0.109398s 🥉 4. trim: 0.112350s 5. serializable: 0.120370s 6. regex: 0.179747s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.9
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.002013s 🥇 2. implode: 0.002063s 🥈 3. trim: 0.002230s 🥉 4. conditional: 0.002333s 5. serializable: 0.003092s 6. regex: 0.004133s Array Size: 50 ---------------------------------------- 1. implode: 0.004122s 🥇 2. array_map: 0.004126s 🥈 3. trim: 0.004566s 🥉 4. serializable: 0.005498s 5. regex: 0.006908s 6. conditional: 0.006917s Array Size: 100 ---------------------------------------- 1. array_map: 0.008288s 🥇 2. implode: 0.008397s 🥈 3. trim: 0.009116s 🥉 4. conditional: 0.009440s 5. serializable: 0.010394s 6. regex: 0.013516s Array Size: 500 ---------------------------------------- 1. array_map: 0.039664s 🥇 2. implode: 0.040704s 🥈 3. trim: 0.044103s 🥉 4. conditional: 0.045000s 5. serializable: 0.050350s 6. regex: 0.065929s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078367s 🥇 2. implode: 0.081464s 🥈 3. trim: 0.087856s 🥉 4. conditional: 0.089551s 5. serializable: 0.104483s 6. regex: 0.131363s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.8
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000771s 🥇 2. trim: 0.000880s 🥈 3. conditional: 0.000932s 🥉 4. array_map: 0.001013s 5. serializable: 0.001429s 6. regex: 0.001690s Array Size: 50 ---------------------------------------- 1. implode: 0.003928s 🥇 2. array_map: 0.003966s 🥈 3. trim: 0.004253s 🥉 4. conditional: 0.004573s 5. serializable: 0.005244s 6. regex: 0.006940s Array Size: 100 ---------------------------------------- 1. implode: 0.007690s 🥇 2. array_map: 0.007869s 🥈 3. trim: 0.008447s 🥉 4. conditional: 0.008904s 5. serializable: 0.009948s 6. regex: 0.013168s Array Size: 500 ---------------------------------------- 1. implode: 0.039001s 🥇 2. array_map: 0.039456s 🥈 3. trim: 0.041796s 🥉 4. conditional: 0.044944s 5. serializable: 0.049023s 6. regex: 0.064619s Array Size: 1000 ---------------------------------------- 1. implode: 0.077326s 🥇 2. array_map: 0.077454s 🥈 3. trim: 0.082954s 🥉 4. conditional: 0.098653s 5. serializable: 0.100907s 6. regex: 0.128887s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.7
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000845s 🥇 2. trim: 0.000922s 🥈 3. conditional: 0.000963s 🥉 4. array_map: 0.000985s 5. serializable: 0.001450s 6. regex: 0.001708s Array Size: 50 ---------------------------------------- 1. array_map: 0.004102s 🥇 2. implode: 0.004268s 🥈 3. trim: 0.004377s 🥉 4. conditional: 0.004649s 5. serializable: 0.005373s 6. regex: 0.006794s Array Size: 100 ---------------------------------------- 1. array_map: 0.007969s 🥇 2. implode: 0.008141s 🥈 3. trim: 0.008733s 🥉 4. conditional: 0.009266s 5. serializable: 0.010351s 6. regex: 0.013059s Array Size: 500 ---------------------------------------- 1. array_map: 0.038872s 🥇 2. implode: 0.040946s 🥈 3. trim: 0.044001s 🥉 4. conditional: 0.046086s 5. serializable: 0.049860s 6. regex: 0.064314s Array Size: 1000 ---------------------------------------- 1. implode: 0.083025s 🥇 2. trim: 0.088221s 🥈 3. conditional: 0.091245s 🥉 4. array_map: 0.102832s 5. serializable: 0.110852s 6. regex: 0.132230s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.6
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.001033s 🥇 2. serializable: 0.001472s 🥈 3. implode: 0.001535s 🥉 4. trim: 0.001804s 5. conditional: 0.001976s 6. regex: 0.002033s Array Size: 50 ---------------------------------------- 1. array_map: 0.004094s 🥇 2. implode: 0.004133s 🥈 3. trim: 0.004389s 🥉 4. conditional: 0.004684s 5. serializable: 0.005382s 6. regex: 0.007665s Array Size: 100 ---------------------------------------- 1. implode: 0.008061s 🥇 2. array_map: 0.008064s 🥈 3. trim: 0.008773s 🥉 4. conditional: 0.009445s 5. serializable: 0.010068s 6. regex: 0.014884s Array Size: 500 ---------------------------------------- 1. array_map: 0.039864s 🥇 2. implode: 0.041538s 🥈 3. trim: 0.043603s 🥉 4. conditional: 0.049131s 5. serializable: 0.050013s 6. regex: 0.073354s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079351s 🥇 2. implode: 0.081779s 🥈 3. trim: 0.085580s 🥉 4. conditional: 0.091879s 5. serializable: 0.098400s 6. regex: 0.148688s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.5
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000788s 🥇 2. trim: 0.000922s 🥈 3. conditional: 0.000940s 🥉 4. array_map: 0.000986s 5. serializable: 0.001435s 6. regex: 0.001873s Array Size: 50 ---------------------------------------- 1. array_map: 0.004067s 🥇 2. implode: 0.004132s 🥈 3. trim: 0.004444s 🥉 4. conditional: 0.004771s 5. serializable: 0.005438s 6. regex: 0.007711s Array Size: 100 ---------------------------------------- 1. array_map: 0.008099s 🥇 2. implode: 0.008283s 🥈 3. trim: 0.008997s 🥉 4. conditional: 0.009480s 5. serializable: 0.010256s 6. regex: 0.014949s Array Size: 500 ---------------------------------------- 1. array_map: 0.039330s 🥇 2. implode: 0.040799s 🥈 3. trim: 0.042981s 🥉 4. conditional: 0.044686s 5. serializable: 0.050004s 6. regex: 0.073419s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079384s 🥇 2. implode: 0.082855s 🥈 3. trim: 0.088677s 🥉 4. conditional: 0.092014s 5. serializable: 0.099589s 6. regex: 0.149852s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.4
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.001959s 🥇 2. trim: 0.002270s 🥈 3. conditional: 0.002379s 🥉 4. array_map: 0.002397s 5. serializable: 0.003776s 6. regex: 0.004313s Array Size: 50 ---------------------------------------- 1. array_map: 0.004224s 🥇 2. trim: 0.004422s 🥈 3. serializable: 0.005748s 🥉 4. implode: 0.006192s 5. regex: 0.007055s 6. conditional: 0.010391s Array Size: 100 ---------------------------------------- 1. array_map: 0.008121s 🥇 2. implode: 0.008454s 🥈 3. trim: 0.008806s 🥉 4. conditional: 0.009332s 5. serializable: 0.010470s 6. regex: 0.013151s Array Size: 500 ---------------------------------------- 1. array_map: 0.039522s 🥇 2. implode: 0.040671s 🥈 3. trim: 0.043338s 🥉 4. conditional: 0.045314s 5. serializable: 0.050995s 6. regex: 0.064062s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078239s 🥇 2. implode: 0.084094s 🥈 3. trim: 0.090463s 🥉 4. conditional: 0.092076s 5. serializable: 0.101069s 6. regex: 0.128286s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.3
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000797s 🥇 2. trim: 0.000891s 🥈 3. conditional: 0.000912s 🥉 4. array_map: 0.000969s 5. serializable: 0.001501s 6. regex: 0.001705s Array Size: 50 ---------------------------------------- 1. array_map: 0.004050s 🥇 2. implode: 0.004059s 🥈 3. trim: 0.004390s 🥉 4. conditional: 0.004596s 5. serializable: 0.005601s 6. regex: 0.006731s Array Size: 100 ---------------------------------------- 1. array_map: 0.007985s 🥇 2. implode: 0.008092s 🥈 3. trim: 0.008865s 🥉 4. conditional: 0.009108s 5. serializable: 0.010546s 6. regex: 0.013042s Array Size: 500 ---------------------------------------- 1. array_map: 0.038521s 🥇 2. implode: 0.040782s 🥈 3. trim: 0.043653s 🥉 4. conditional: 0.045161s 5. serializable: 0.053148s 6. regex: 0.065237s Array Size: 1000 ---------------------------------------- 1. array_map: 0.080548s 🥇 2. implode: 0.082455s 🥈 3. trim: 0.085927s 🥉 4. conditional: 0.087610s 5. serializable: 0.104591s 6. regex: 0.130676s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.2
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.001959s 🥇 2. trim: 0.002238s 🥈 3. array_map: 0.002364s 🥉 4. conditional: 0.002555s 5. serializable: 0.003563s 6. regex: 0.004087s Array Size: 50 ---------------------------------------- 1. array_map: 0.004073s 🥇 2. trim: 0.004356s 🥈 3. serializable: 0.005446s 🥉 4. regex: 0.006646s 5. implode: 0.006671s 6. conditional: 0.010824s Array Size: 100 ---------------------------------------- 1. array_map: 0.008037s 🥇 2. implode: 0.008282s 🥈 3. trim: 0.008742s 🥉 4. conditional: 0.009149s 5. serializable: 0.010461s 6. regex: 0.012940s Array Size: 500 ---------------------------------------- 1. array_map: 0.039845s 🥇 2. implode: 0.041205s 🥈 3. trim: 0.042608s 🥉 4. conditional: 0.045802s 5. serializable: 0.050723s 6. regex: 0.063867s Array Size: 1000 ---------------------------------------- 1. array_map: 0.080112s 🥇 2. implode: 0.083604s 🥈 3. trim: 0.085679s 🥉 4. conditional: 0.092350s 5. serializable: 0.100498s 6. regex: 0.129963s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.1
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.001033s 🥇 2. conditional: 0.001394s 🥈 3. implode: 0.001447s 🥉 4. serializable: 0.001523s 5. trim: 0.001665s 6. regex: 0.003037s Array Size: 50 ---------------------------------------- 1. implode: 0.004129s 🥇 2. array_map: 0.004321s 🥈 3. trim: 0.004440s 🥉 4. conditional: 0.004606s 5. serializable: 0.005466s 6. regex: 0.007092s Array Size: 100 ---------------------------------------- 1. implode: 0.008114s 🥇 2. array_map: 0.008388s 🥈 3. trim: 0.008764s 🥉 4. conditional: 0.009322s 5. serializable: 0.010274s 6. regex: 0.013525s Array Size: 500 ---------------------------------------- 1. implode: 0.040501s 🥇 2. array_map: 0.040994s 🥈 3. trim: 0.042574s 🥉 4. conditional: 0.045598s 5. serializable: 0.050243s 6. regex: 0.065545s Array Size: 1000 ---------------------------------------- 1. implode: 0.081927s 🥇 2. array_map: 0.081954s 🥈 3. trim: 0.085680s 🥉 4. conditional: 0.091174s 5. serializable: 0.099889s 6. regex: 0.133865s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.3.0
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.000977s 🥇 2. serializable: 0.001457s 🥈 3. implode: 0.001610s 🥉 4. trim: 0.001810s 5. conditional: 0.002445s 6. regex: 0.003111s Array Size: 50 ---------------------------------------- 1. implode: 0.004020s 🥇 2. array_map: 0.004195s 🥈 3. trim: 0.004348s 🥉 4. conditional: 0.004514s 5. serializable: 0.005356s 6. regex: 0.006962s Array Size: 100 ---------------------------------------- 1. implode: 0.008129s 🥇 2. array_map: 0.008424s 🥈 3. trim: 0.008749s 🥉 4. conditional: 0.009033s 5. serializable: 0.010108s 6. regex: 0.013539s Array Size: 500 ---------------------------------------- 1. implode: 0.040629s 🥇 2. trim: 0.042870s 🥈 3. array_map: 0.043187s 🥉 4. conditional: 0.045082s 5. serializable: 0.049612s 6. regex: 0.066416s Array Size: 1000 ---------------------------------------- 1. implode: 0.082936s 🥇 2. array_map: 0.085712s 🥈 3. trim: 0.089165s 🥉 4. conditional: 0.090343s 5. serializable: 0.099112s 6. regex: 0.136206s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.29
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.001908s 🥇 2. trim: 0.002110s 🥈 3. conditional: 0.002209s 🥉 4. array_map: 0.002303s 5. serializable: 0.003383s 6. regex: 0.003995s Array Size: 50 ---------------------------------------- 1. array_map: 0.004016s 🥇 2. implode: 0.004058s 🥈 3. trim: 0.004316s 🥉 4. serializable: 0.005252s 5. regex: 0.006711s 6. conditional: 0.008078s Array Size: 100 ---------------------------------------- 1. array_map: 0.007968s 🥇 2. implode: 0.008098s 🥈 3. trim: 0.008808s 🥉 4. conditional: 0.009354s 5. serializable: 0.009843s 6. regex: 0.012909s Array Size: 500 ---------------------------------------- 1. array_map: 0.039913s 🥇 2. implode: 0.039943s 🥈 3. trim: 0.043108s 🥉 4. conditional: 0.045738s 5. serializable: 0.048160s 6. regex: 0.063530s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078597s 🥇 2. trim: 0.085264s 🥈 3. implode: 0.085819s 🥉 4. conditional: 0.090522s 5. serializable: 0.096587s 6. regex: 0.125247s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.28
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000776s 🥇 2. trim: 0.000892s 🥈 3. conditional: 0.000923s 🥉 4. array_map: 0.000925s 5. serializable: 0.001430s 6. regex: 0.001691s Array Size: 50 ---------------------------------------- 1. array_map: 0.003987s 🥇 2. implode: 0.004112s 🥈 3. trim: 0.004378s 🥉 4. conditional: 0.004616s 5. serializable: 0.005472s 6. regex: 0.006775s Array Size: 100 ---------------------------------------- 1. array_map: 0.007957s 🥇 2. implode: 0.008286s 🥈 3. trim: 0.008798s 🥉 4. conditional: 0.009405s 5. serializable: 0.010279s 6. regex: 0.013074s Array Size: 500 ---------------------------------------- 1. array_map: 0.039375s 🥇 2. implode: 0.041576s 🥈 3. trim: 0.042894s 🥉 4. conditional: 0.045807s 5. serializable: 0.049578s 6. regex: 0.064127s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078716s 🥇 2. implode: 0.080396s 🥈 3. trim: 0.084127s 🥉 4. conditional: 0.089412s 5. serializable: 0.098293s 6. regex: 0.130085s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.27
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000772s 🥇 2. trim: 0.000889s 🥈 3. conditional: 0.000918s 🥉 4. array_map: 0.000961s 5. serializable: 0.001410s 6. regex: 0.001710s Array Size: 50 ---------------------------------------- 1. array_map: 0.003998s 🥇 2. implode: 0.004027s 🥈 3. trim: 0.004348s 🥉 4. conditional: 0.004663s 5. serializable: 0.005345s 6. regex: 0.006871s Array Size: 100 ---------------------------------------- 1. array_map: 0.007921s 🥇 2. implode: 0.008130s 🥈 3. trim: 0.008745s 🥉 4. conditional: 0.009298s 5. serializable: 0.010047s 6. regex: 0.013321s Array Size: 500 ---------------------------------------- 1. array_map: 0.039134s 🥇 2. implode: 0.041711s 🥈 3. trim: 0.044602s 🥉 4. conditional: 0.046609s 5. serializable: 0.049200s 6. regex: 0.065447s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079571s 🥇 2. implode: 0.082651s 🥈 3. trim: 0.088100s 🥉 4. conditional: 0.092677s 5. serializable: 0.098676s 6. regex: 0.135363s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.26
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000781s 🥇 2. trim: 0.000867s 🥈 3. conditional: 0.000900s 🥉 4. array_map: 0.000934s 5. serializable: 0.001395s 6. regex: 0.001630s Array Size: 50 ---------------------------------------- 1. array_map: 0.003965s 🥇 2. implode: 0.004046s 🥈 3. trim: 0.004373s 🥉 4. conditional: 0.004623s 5. serializable: 0.005461s 6. regex: 0.007403s Array Size: 100 ---------------------------------------- 1. array_map: 0.007967s 🥇 2. implode: 0.008110s 🥈 3. trim: 0.008558s 🥉 4. conditional: 0.009208s 5. serializable: 0.009979s 6. regex: 0.012888s Array Size: 500 ---------------------------------------- 1. array_map: 0.039526s 🥇 2. implode: 0.040836s 🥈 3. trim: 0.042500s 🥉 4. serializable: 0.048964s 5. conditional: 0.051499s 6. regex: 0.063534s Array Size: 1000 ---------------------------------------- 1. array_map: 0.077638s 🥇 2. implode: 0.084024s 🥈 3. trim: 0.085834s 🥉 4. conditional: 0.091882s 5. serializable: 0.096061s 6. regex: 0.131349s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.25
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000808s 🥇 2. trim: 0.000879s 🥈 3. conditional: 0.000936s 🥉 4. array_map: 0.000985s 5. serializable: 0.001470s 6. regex: 0.001702s Array Size: 50 ---------------------------------------- 1. implode: 0.003944s 🥇 2. array_map: 0.004091s 🥈 3. trim: 0.004328s 🥉 4. conditional: 0.004649s 5. serializable: 0.005395s 6. regex: 0.006933s Array Size: 100 ---------------------------------------- 1. implode: 0.008334s 🥇 2. array_map: 0.009091s 🥈 3. trim: 0.009121s 🥉 4. conditional: 0.009426s 5. serializable: 0.011671s 6. regex: 0.014485s Array Size: 500 ---------------------------------------- 1. array_map: 0.039888s 🥇 2. implode: 0.040079s 🥈 3. trim: 0.042811s 🥉 4. conditional: 0.047285s 5. serializable: 0.048826s 6. regex: 0.063830s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079328s 🥇 2. implode: 0.080601s 🥈 3. trim: 0.084301s 🥉 4. conditional: 0.089073s 5. serializable: 0.097010s 6. regex: 0.132864s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.24
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000758s 🥇 2. trim: 0.000876s 🥈 3. conditional: 0.000913s 🥉 4. array_map: 0.000934s 5. serializable: 0.001430s 6. regex: 0.001654s Array Size: 50 ---------------------------------------- 1. array_map: 0.004007s 🥇 2. implode: 0.004042s 🥈 3. trim: 0.004266s 🥉 4. conditional: 0.004656s 5. serializable: 0.005311s 6. regex: 0.006654s Array Size: 100 ---------------------------------------- 1. array_map: 0.007945s 🥇 2. implode: 0.008102s 🥈 3. trim: 0.008739s 🥉 4. conditional: 0.009420s 5. serializable: 0.009986s 6. regex: 0.012894s Array Size: 500 ---------------------------------------- 1. array_map: 0.039086s 🥇 2. implode: 0.040264s 🥈 3. trim: 0.043049s 🥉 4. conditional: 0.045979s 5. serializable: 0.048944s 6. regex: 0.062701s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078654s 🥇 2. implode: 0.081158s 🥈 3. trim: 0.085397s 🥉 4. conditional: 0.091135s 5. serializable: 0.098338s 6. regex: 0.130960s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.23
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000773s 🥇 2. trim: 0.000894s 🥈 3. conditional: 0.000935s 🥉 4. array_map: 0.000964s 5. serializable: 0.001433s 6. regex: 0.001715s Array Size: 50 ---------------------------------------- 1. array_map: 0.003987s 🥇 2. implode: 0.004024s 🥈 3. trim: 0.004330s 🥉 4. conditional: 0.004581s 5. serializable: 0.005378s 6. regex: 0.006813s Array Size: 100 ---------------------------------------- 1. array_map: 0.007819s 🥇 2. implode: 0.008052s 🥈 3. trim: 0.008809s 🥉 4. conditional: 0.009197s 5. serializable: 0.010418s 6. regex: 0.013145s Array Size: 500 ---------------------------------------- 1. array_map: 0.038335s 🥇 2. implode: 0.039798s 🥈 3. trim: 0.043472s 🥉 4. conditional: 0.045038s 5. serializable: 0.050920s 6. regex: 0.068794s Array Size: 1000 ---------------------------------------- 1. implode: 0.077044s 🥇 2. array_map: 0.077819s 🥈 3. trim: 0.083116s 🥉 4. conditional: 0.087302s 5. serializable: 0.097985s 6. regex: 0.126660s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.22
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000797s 🥇 2. trim: 0.000901s 🥈 3. conditional: 0.000919s 🥉 4. array_map: 0.000945s 5. serializable: 0.001501s 6. regex: 0.001698s Array Size: 50 ---------------------------------------- 1. array_map: 0.004029s 🥇 2. implode: 0.004047s 🥈 3. trim: 0.004278s 🥉 4. conditional: 0.004684s 5. serializable: 0.005365s 6. regex: 0.006736s Array Size: 100 ---------------------------------------- 1. array_map: 0.007948s 🥇 2. implode: 0.008148s 🥈 3. trim: 0.008706s 🥉 4. conditional: 0.009379s 5. serializable: 0.010181s 6. regex: 0.013094s Array Size: 500 ---------------------------------------- 1. array_map: 0.038720s 🥇 2. implode: 0.041093s 🥈 3. trim: 0.042598s 🥉 4. conditional: 0.046323s 5. serializable: 0.049397s 6. regex: 0.064467s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078563s 🥇 2. implode: 0.082646s 🥈 3. trim: 0.085220s 🥉 4. conditional: 0.092409s 5. serializable: 0.098513s 6. regex: 0.127225s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.21
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000779s 🥇 2. trim: 0.000890s 🥈 3. conditional: 0.000916s 🥉 4. array_map: 0.000975s 5. serializable: 0.001432s 6. regex: 0.001654s Array Size: 50 ---------------------------------------- 1. implode: 0.004043s 🥇 2. array_map: 0.004088s 🥈 3. trim: 0.004343s 🥉 4. conditional: 0.004575s 5. serializable: 0.005353s 6. regex: 0.006787s Array Size: 100 ---------------------------------------- 1. array_map: 0.008005s 🥇 2. implode: 0.008067s 🥈 3. trim: 0.008596s 🥉 4. conditional: 0.009161s 5. serializable: 0.010074s 6. regex: 0.013126s Array Size: 500 ---------------------------------------- 1. array_map: 0.039085s 🥇 2. implode: 0.040002s 🥈 3. trim: 0.041710s 🥉 4. conditional: 0.044323s 5. serializable: 0.048993s 6. regex: 0.063888s Array Size: 1000 ---------------------------------------- 1. implode: 0.078501s 🥇 2. array_map: 0.079392s 🥈 3. trim: 0.084526s 🥉 4. conditional: 0.086658s 5. serializable: 0.105901s 6. regex: 0.128126s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.20
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000797s 🥇 2. trim: 0.000902s 🥈 3. conditional: 0.000929s 🥉 4. array_map: 0.000951s 5. serializable: 0.001465s 6. regex: 0.001635s Array Size: 50 ---------------------------------------- 1. array_map: 0.004030s 🥇 2. implode: 0.004089s 🥈 3. trim: 0.004344s 🥉 4. conditional: 0.004687s 5. serializable: 0.005332s 6. regex: 0.006604s Array Size: 100 ---------------------------------------- 1. array_map: 0.007820s 🥇 2. implode: 0.008123s 🥈 3. trim: 0.008799s 🥉 4. conditional: 0.009288s 5. serializable: 0.010118s 6. regex: 0.013599s Array Size: 500 ---------------------------------------- 1. array_map: 0.038887s 🥇 2. implode: 0.041218s 🥈 3. conditional: 0.044934s 🥉 4. trim: 0.046249s 5. serializable: 0.049263s 6. regex: 0.062690s Array Size: 1000 ---------------------------------------- 1. array_map: 0.077689s 🥇 2. implode: 0.079710s 🥈 3. trim: 0.083260s 🥉 4. conditional: 0.088963s 5. serializable: 0.097110s 6. regex: 0.124465s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.19
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.001951s 🥇 2. trim: 0.002235s 🥈 3. array_map: 0.002290s 🥉 4. conditional: 0.002307s 5. serializable: 0.003514s 6. regex: 0.004051s Array Size: 50 ---------------------------------------- 1. array_map: 0.004030s 🥇 2. implode: 0.004170s 🥈 3. trim: 0.004396s 🥉 4. serializable: 0.005555s 5. regex: 0.006655s 6. conditional: 0.010398s Array Size: 100 ---------------------------------------- 1. array_map: 0.007974s 🥇 2. implode: 0.008107s 🥈 3. trim: 0.008749s 🥉 4. conditional: 0.009449s 5. serializable: 0.010332s 6. regex: 0.012899s Array Size: 500 ---------------------------------------- 1. array_map: 0.040096s 🥇 2. implode: 0.041175s 🥈 3. trim: 0.044750s 🥉 4. conditional: 0.047805s 5. serializable: 0.050608s 6. regex: 0.066196s Array Size: 1000 ---------------------------------------- 1. implode: 0.084325s 🥇 2. array_map: 0.086141s 🥈 3. trim: 0.087867s 🥉 4. conditional: 0.092515s 5. serializable: 0.098557s 6. regex: 0.133888s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.18
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.001958s 🥇 2. trim: 0.002147s 🥈 3. array_map: 0.002276s 🥉 4. conditional: 0.002314s 5. serializable: 0.003489s 6. regex: 0.004103s Array Size: 50 ---------------------------------------- 1. array_map: 0.003980s 🥇 2. trim: 0.004397s 🥈 3. implode: 0.005188s 🥉 4. serializable: 0.005454s 5. regex: 0.006854s 6. conditional: 0.010161s Array Size: 100 ---------------------------------------- 1. array_map: 0.007953s 🥇 2. implode: 0.008275s 🥈 3. trim: 0.008769s 🥉 4. conditional: 0.009309s 5. serializable: 0.010051s 6. regex: 0.013155s Array Size: 500 ---------------------------------------- 1. array_map: 0.038975s 🥇 2. implode: 0.040982s 🥈 3. trim: 0.043344s 🥉 4. serializable: 0.049096s 5. conditional: 0.049472s 6. regex: 0.064016s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079782s 🥇 2. implode: 0.081645s 🥈 3. trim: 0.091302s 🥉 4. conditional: 0.091875s 5. serializable: 0.099689s 6. regex: 0.126573s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.17
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.001233s 🥇 2. implode: 0.002071s 🥈 3. trim: 0.002320s 🥉 4. conditional: 0.002366s 5. serializable: 0.002984s 6. regex: 0.003362s Array Size: 50 ---------------------------------------- 1. array_map: 0.004077s 🥇 2. implode: 0.004139s 🥈 3. trim: 0.004421s 🥉 4. serializable: 0.005445s 5. conditional: 0.006038s 6. regex: 0.006636s Array Size: 100 ---------------------------------------- 1. implode: 0.008191s 🥇 2. array_map: 0.008459s 🥈 3. trim: 0.008784s 🥉 4. conditional: 0.009325s 5. serializable: 0.010632s 6. regex: 0.012848s Array Size: 500 ---------------------------------------- 1. array_map: 0.040395s 🥇 2. implode: 0.042076s 🥈 3. trim: 0.042853s 🥉 4. conditional: 0.045834s 5. serializable: 0.050231s 6. regex: 0.066387s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079511s 🥇 2. trim: 0.082585s 🥈 3. implode: 0.087409s 🥉 4. conditional: 0.090999s 5. serializable: 0.099415s 6. regex: 0.126416s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.16
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. trim: 0.000992s 🥇 2. implode: 0.001001s 🥈 3. array_map: 0.001013s 🥉 4. conditional: 0.001032s 5. serializable: 0.001593s 6. regex: 0.001705s Array Size: 50 ---------------------------------------- 1. array_map: 0.004448s 🥇 2. trim: 0.004774s 🥈 3. implode: 0.004935s 🥉 4. conditional: 0.004943s 5. serializable: 0.006048s 6. regex: 0.006679s Array Size: 100 ---------------------------------------- 1. array_map: 0.008803s 🥇 2. trim: 0.009488s 🥈 3. conditional: 0.009808s 🥉 4. implode: 0.009824s 5. serializable: 0.011559s 6. regex: 0.013008s Array Size: 500 ---------------------------------------- 1. array_map: 0.043176s 🥇 2. trim: 0.046217s 🥈 3. conditional: 0.048243s 🥉 4. implode: 0.049584s 5. serializable: 0.056583s 6. regex: 0.066197s Array Size: 1000 ---------------------------------------- 1. array_map: 0.085566s 🥇 2. trim: 0.090645s 🥈 3. conditional: 0.095833s 🥉 4. implode: 0.099104s 5. serializable: 0.117492s 6. regex: 0.127780s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.15
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000828s 🥇 2. array_map: 0.000944s 🥈 3. trim: 0.000976s 🥉 4. conditional: 0.001022s 5. serializable: 0.001470s 6. regex: 0.001713s Array Size: 50 ---------------------------------------- 1. array_map: 0.004025s 🥇 2. implode: 0.004038s 🥈 3. trim: 0.004678s 🥉 4. conditional: 0.005036s 5. serializable: 0.005463s 6. regex: 0.006842s Array Size: 100 ---------------------------------------- 1. implode: 0.007778s 🥇 2. array_map: 0.007927s 🥈 3. trim: 0.009199s 🥉 4. conditional: 0.009452s 5. serializable: 0.010468s 6. regex: 0.012811s Array Size: 500 ---------------------------------------- 1. implode: 0.039514s 🥇 2. array_map: 0.039659s 🥈 3. trim: 0.045389s 🥉 4. conditional: 0.047003s 5. serializable: 0.049709s 6. regex: 0.062529s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079177s 🥇 2. implode: 0.080023s 🥈 3. trim: 0.092084s 🥉 4. conditional: 0.092748s 5. serializable: 0.100533s 6. regex: 0.127592s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.14
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.001213s 🥇 2. trim: 0.001992s 🥈 3. implode: 0.002009s 🥉 4. conditional: 0.002530s 5. serializable: 0.003058s 6. regex: 0.003392s Array Size: 50 ---------------------------------------- 1. implode: 0.004052s 🥇 2. array_map: 0.004102s 🥈 3. trim: 0.004577s 🥉 4. conditional: 0.004733s 5. serializable: 0.005435s 6. regex: 0.006661s Array Size: 100 ---------------------------------------- 1. implode: 0.007973s 🥇 2. array_map: 0.008021s 🥈 3. trim: 0.008919s 🥉 4. conditional: 0.009379s 5. serializable: 0.010422s 6. regex: 0.013122s Array Size: 500 ---------------------------------------- 1. implode: 0.039230s 🥇 2. array_map: 0.039679s 🥈 3. trim: 0.042780s 🥉 4. conditional: 0.045176s 5. serializable: 0.049926s 6. regex: 0.063260s Array Size: 1000 ---------------------------------------- 1. implode: 0.078486s 🥇 2. array_map: 0.079468s 🥈 3. trim: 0.086072s 🥉 4. conditional: 0.089794s 5. serializable: 0.099559s 6. regex: 0.156478s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.13
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.000967s 🥇 2. implode: 0.001820s 🥈 3. trim: 0.001893s 🥉 4. conditional: 0.002365s 5. serializable: 0.002644s 6. regex: 0.003427s Array Size: 50 ---------------------------------------- 1. array_map: 0.004095s 🥇 2. implode: 0.004321s 🥈 3. trim: 0.004484s 🥉 4. conditional: 0.004672s 5. serializable: 0.005568s 6. regex: 0.006670s Array Size: 100 ---------------------------------------- 1. array_map: 0.007886s 🥇 2. implode: 0.008292s 🥈 3. trim: 0.008937s 🥉 4. conditional: 0.009268s 5. serializable: 0.010550s 6. regex: 0.013001s Array Size: 500 ---------------------------------------- 1. array_map: 0.038598s 🥇 2. implode: 0.040707s 🥈 3. trim: 0.043837s 🥉 4. conditional: 0.044928s 5. serializable: 0.050444s 6. regex: 0.064565s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078365s 🥇 2. implode: 0.081791s 🥈 3. trim: 0.088920s 🥉 4. conditional: 0.089787s 5. serializable: 0.100049s 6. regex: 0.124949s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.12
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000812s 🥇 2. trim: 0.000874s 🥈 3. conditional: 0.000919s 🥉 4. array_map: 0.000996s 5. serializable: 0.001467s 6. regex: 0.001643s Array Size: 50 ---------------------------------------- 1. implode: 0.003941s 🥇 2. array_map: 0.004044s 🥈 3. trim: 0.004253s 🥉 4. conditional: 0.004539s 5. serializable: 0.005982s 6. regex: 0.006665s Array Size: 100 ---------------------------------------- 1. array_map: 0.008241s 🥇 2. implode: 0.008790s 🥈 3. conditional: 0.008889s 🥉 4. serializable: 0.012165s 5. trim: 0.017700s 6. regex: 0.033098s Array Size: 500 ---------------------------------------- 1. implode: 0.039084s 🥇 2. trim: 0.041476s 🥈 3. array_map: 0.043097s 🥉 4. conditional: 0.044597s 5. serializable: 0.050573s 6. regex: 0.063461s Array Size: 1000 ---------------------------------------- 1. implode: 0.078702s 🥇 2. trim: 0.082605s 🥈 3. array_map: 0.087403s 🥉 4. conditional: 0.095298s 5. serializable: 0.099614s 6. regex: 0.124134s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.11
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.001913s 🥇 2. array_map: 0.002008s 🥈 3. trim: 0.002212s 🥉 4. conditional: 0.002247s 5. serializable: 0.003069s 6. regex: 0.004073s Array Size: 50 ---------------------------------------- 1. implode: 0.003996s 🥇 2. array_map: 0.004017s 🥈 3. trim: 0.004322s 🥉 4. conditional: 0.005120s 5. serializable: 0.005426s 6. regex: 0.006700s Array Size: 100 ---------------------------------------- 1. array_map: 0.007907s 🥇 2. implode: 0.008006s 🥈 3. trim: 0.008603s 🥉 4. conditional: 0.008997s 5. serializable: 0.010122s 6. regex: 0.012769s Array Size: 500 ---------------------------------------- 1. implode: 0.039839s 🥇 2. array_map: 0.040283s 🥈 3. trim: 0.043112s 🥉 4. conditional: 0.044168s 5. serializable: 0.049777s 6. regex: 0.063923s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079607s 🥇 2. implode: 0.084168s 🥈 3. trim: 0.086155s 🥉 4. conditional: 0.094938s 5. serializable: 0.099483s 6. regex: 0.124801s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.10
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. array_map: 0.002041s 🥇 2. implode: 0.002269s 🥈 3. trim: 0.002502s 🥉 4. conditional: 0.002635s 5. serializable: 0.003087s 6. regex: 0.004261s Array Size: 50 ---------------------------------------- 1. implode: 0.004173s 🥇 2. array_map: 0.004219s 🥈 3. trim: 0.004325s 🥉 4. serializable: 0.005412s 5. conditional: 0.006615s 6. regex: 0.006874s Array Size: 100 ---------------------------------------- 1. array_map: 0.008060s 🥇 2. implode: 0.009500s 🥈 3. conditional: 0.010051s 🥉 4. serializable: 0.010140s 5. trim: 0.013035s 6. regex: 0.015737s Array Size: 500 ---------------------------------------- 1. array_map: 0.039768s 🥇 2. implode: 0.041138s 🥈 3. trim: 0.042999s 🥉 4. conditional: 0.045224s 5. serializable: 0.049485s 6. regex: 0.063033s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078958s 🥇 2. implode: 0.082595s 🥈 3. trim: 0.085621s 🥉 4. conditional: 0.090587s 5. serializable: 0.097997s 6. regex: 0.126912s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.9
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.001948s 🥇 2. array_map: 0.001964s 🥈 3. trim: 0.002203s 🥉 4. conditional: 0.002686s 5. serializable: 0.002943s 6. regex: 0.003756s Array Size: 50 ---------------------------------------- 1. implode: 0.003967s 🥇 2. array_map: 0.003967s 🥈 3. trim: 0.004327s 🥉 4. serializable: 0.005426s 5. conditional: 0.005630s 6. regex: 0.006564s Array Size: 100 ---------------------------------------- 1. implode: 0.007850s 🥇 2. array_map: 0.007951s 🥈 3. trim: 0.008544s 🥉 4. conditional: 0.008848s 5. serializable: 0.010404s 6. regex: 0.013613s Array Size: 500 ---------------------------------------- 1. implode: 0.038836s 🥇 2. array_map: 0.038964s 🥈 3. trim: 0.042469s 🥉 4. conditional: 0.044368s 5. serializable: 0.050426s 6. regex: 0.062976s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078621s 🥇 2. implode: 0.079558s 🥈 3. conditional: 0.087457s 🥉 4. trim: 0.091133s 5. serializable: 0.099698s 6. regex: 0.123090s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.8
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000778s 🥇 2. trim: 0.000881s 🥈 3. conditional: 0.000921s 🥉 4. array_map: 0.000951s 5. serializable: 0.001505s 6. regex: 0.001679s Array Size: 50 ---------------------------------------- 1. array_map: 0.003975s 🥇 2. implode: 0.004049s 🥈 3. trim: 0.004318s 🥉 4. conditional: 0.004601s 5. serializable: 0.005530s 6. regex: 0.006713s Array Size: 100 ---------------------------------------- 1. array_map: 0.008014s 🥇 2. implode: 0.008115s 🥈 3. trim: 0.008907s 🥉 4. conditional: 0.009106s 5. serializable: 0.010403s 6. regex: 0.012960s Array Size: 500 ---------------------------------------- 1. implode: 0.039420s 🥇 2. array_map: 0.039683s 🥈 3. trim: 0.042664s 🥉 4. conditional: 0.044656s 5. serializable: 0.049922s 6. regex: 0.062615s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078441s 🥇 2. implode: 0.082238s 🥈 3. trim: 0.086622s 🥉 4. conditional: 0.092064s 5. serializable: 0.098770s 6. regex: 0.125506s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.7
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000800s 🥇 2. trim: 0.000902s 🥈 3. conditional: 0.000960s 🥉 4. array_map: 0.000999s 5. serializable: 0.001474s 6. regex: 0.001709s Array Size: 50 ---------------------------------------- 1. implode: 0.003979s 🥇 2. array_map: 0.004050s 🥈 3. trim: 0.004322s 🥉 4. conditional: 0.004484s 5. serializable: 0.005389s 6. regex: 0.006629s Array Size: 100 ---------------------------------------- 1. implode: 0.007897s 🥇 2. array_map: 0.008019s 🥈 3. trim: 0.008565s 🥉 4. conditional: 0.008982s 5. serializable: 0.010163s 6. regex: 0.012742s Array Size: 500 ---------------------------------------- 1. implode: 0.040217s 🥇 2. array_map: 0.040792s 🥈 3. trim: 0.043873s 🥉 4. conditional: 0.045160s 5. serializable: 0.050639s 6. regex: 0.071005s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079772s 🥇 2. implode: 0.080114s 🥈 3. trim: 0.082037s 🥉 4. conditional: 0.090892s 5. serializable: 0.098783s 6. regex: 0.123037s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.6
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000794s 🥇 2. trim: 0.000902s 🥈 3. conditional: 0.000942s 🥉 4. array_map: 0.000973s 5. serializable: 0.001422s 6. regex: 0.001733s Array Size: 50 ---------------------------------------- 1. array_map: 0.004017s 🥇 2. implode: 0.004114s 🥈 3. trim: 0.004260s 🥉 4. conditional: 0.004492s 5. serializable: 0.005288s 6. regex: 0.006708s Array Size: 100 ---------------------------------------- 1. array_map: 0.007930s 🥇 2. implode: 0.008184s 🥈 3. trim: 0.008605s 🥉 4. conditional: 0.008934s 5. serializable: 0.010051s 6. regex: 0.012809s Array Size: 500 ---------------------------------------- 1. array_map: 0.039570s 🥇 2. implode: 0.041486s 🥈 3. trim: 0.043047s 🥉 4. conditional: 0.045135s 5. serializable: 0.049286s 6. regex: 0.065535s Array Size: 1000 ---------------------------------------- 1. array_map: 0.079401s 🥇 2. implode: 0.082012s 🥈 3. trim: 0.084313s 🥉 4. conditional: 0.088969s 5. serializable: 0.106407s 6. regex: 0.130475s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.5
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000756s 🥇 2. trim: 0.000881s 🥈 3. conditional: 0.000913s 🥉 4. array_map: 0.000948s 5. serializable: 0.001443s 6. regex: 0.001643s Array Size: 50 ---------------------------------------- 1. implode: 0.003892s 🥇 2. array_map: 0.004021s 🥈 3. trim: 0.004295s 🥉 4. conditional: 0.004480s 5. serializable: 0.005382s 6. regex: 0.006532s Array Size: 100 ---------------------------------------- 1. implode: 0.007898s 🥇 2. array_map: 0.007969s 🥈 3. trim: 0.008428s 🥉 4. conditional: 0.008892s 5. serializable: 0.010166s 6. regex: 0.012749s Array Size: 500 ---------------------------------------- 1. array_map: 0.039072s 🥇 2. implode: 0.039195s 🥈 3. trim: 0.041626s 🥉 4. conditional: 0.044048s 5. serializable: 0.049420s 6. regex: 0.062355s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078442s 🥇 2. implode: 0.078577s 🥈 3. trim: 0.082839s 🥉 4. conditional: 0.088122s 5. serializable: 0.098734s 6. regex: 0.123815s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.4
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000761s 🥇 2. trim: 0.000869s 🥈 3. conditional: 0.000890s 🥉 4. array_map: 0.000918s 5. serializable: 0.001443s 6. regex: 0.001672s Array Size: 50 ---------------------------------------- 1. implode: 0.003887s 🥇 2. array_map: 0.003902s 🥈 3. trim: 0.004178s 🥉 4. conditional: 0.004508s 5. serializable: 0.005490s 6. regex: 0.006763s Array Size: 100 ---------------------------------------- 1. implode: 0.007741s 🥇 2. array_map: 0.007749s 🥈 3. trim: 0.008400s 🥉 4. conditional: 0.008915s 5. serializable: 0.010366s 6. regex: 0.013405s Array Size: 500 ---------------------------------------- 1. array_map: 0.039038s 🥇 2. implode: 0.039881s 🥈 3. trim: 0.042069s 🥉 4. conditional: 0.044537s 5. serializable: 0.051326s 6. regex: 0.063868s Array Size: 1000 ---------------------------------------- 1. array_map: 0.077953s 🥇 2. implode: 0.080835s 🥈 3. trim: 0.082632s 🥉 4. conditional: 0.097259s 5. serializable: 0.101035s 6. regex: 0.126815s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.3
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000809s 🥇 2. trim: 0.000893s 🥈 3. conditional: 0.000965s 🥉 4. array_map: 0.000974s 5. serializable: 0.001453s 6. regex: 0.001669s Array Size: 50 ---------------------------------------- 1. array_map: 0.004060s 🥇 2. implode: 0.004119s 🥈 3. trim: 0.004305s 🥉 4. conditional: 0.004618s 5. serializable: 0.005394s 6. regex: 0.006678s Array Size: 100 ---------------------------------------- 1. array_map: 0.008117s 🥇 2. implode: 0.008203s 🥈 3. trim: 0.008659s 🥉 4. conditional: 0.009049s 5. serializable: 0.010216s 6. regex: 0.012835s Array Size: 500 ---------------------------------------- 1. array_map: 0.039939s 🥇 2. implode: 0.040993s 🥈 3. trim: 0.043060s 🥉 4. conditional: 0.046009s 5. serializable: 0.049267s 6. regex: 0.063223s Array Size: 1000 ---------------------------------------- 1. array_map: 0.084137s 🥇 2. implode: 0.085775s 🥈 3. trim: 0.086352s 🥉 4. conditional: 0.094078s 5. serializable: 0.097831s 6. regex: 0.126976s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.2
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000770s 🥇 2. trim: 0.000873s 🥈 3. conditional: 0.000914s 🥉 4. array_map: 0.000961s 5. serializable: 0.001430s 6. regex: 0.001703s Array Size: 50 ---------------------------------------- 1. array_map: 0.004031s 🥇 2. implode: 0.004127s 🥈 3. trim: 0.004228s 🥉 4. conditional: 0.004572s 5. serializable: 0.005358s 6. regex: 0.006645s Array Size: 100 ---------------------------------------- 1. implode: 0.007935s 🥇 2. array_map: 0.008042s 🥈 3. trim: 0.008512s 🥉 4. conditional: 0.009009s 5. serializable: 0.010133s 6. regex: 0.012758s Array Size: 500 ---------------------------------------- 1. array_map: 0.039278s 🥇 2. implode: 0.039852s 🥈 3. trim: 0.041805s 🥉 4. conditional: 0.044460s 5. serializable: 0.049896s 6. regex: 0.062524s Array Size: 1000 ---------------------------------------- 1. array_map: 0.078026s 🥇 2. implode: 0.080695s 🥈 3. trim: 0.084432s 🥉 4. conditional: 0.089052s 5. serializable: 0.098737s 6. regex: 0.125381s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.1
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.000784s 🥇 2. trim: 0.000892s 🥈 3. conditional: 0.000966s 🥉 4. array_map: 0.000972s 5. serializable: 0.001487s 6. regex: 0.001668s Array Size: 50 ---------------------------------------- 1. array_map: 0.003988s 🥇 2. implode: 0.004018s 🥈 3. trim: 0.004266s 🥉 4. conditional: 0.004567s 5. serializable: 0.005515s 6. regex: 0.006591s Array Size: 100 ---------------------------------------- 1. array_map: 0.007837s 🥇 2. implode: 0.007948s 🥈 3. trim: 0.008554s 🥉 4. conditional: 0.009056s 5. serializable: 0.010333s 6. regex: 0.012671s Array Size: 500 ---------------------------------------- 1. array_map: 0.038319s 🥇 2. implode: 0.039927s 🥈 3. trim: 0.042635s 🥉 4. conditional: 0.045996s 5. serializable: 0.050134s 6. regex: 0.062410s Array Size: 1000 ---------------------------------------- 1. array_map: 0.076169s 🥇 2. implode: 0.077815s 🥈 3. trim: 0.086131s 🥉 4. conditional: 0.089477s 5. serializable: 0.099682s 6. regex: 0.131695s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
Output for 8.2.0
Testing IN clause builder with all methods: === FUNCTIONALITY TEST === Result: :test0,:test1,:test2,:test3,:test4 Bind params: {":test0":1,":test1":2,":test2":3,":test3":4,":test4":5} Counter value: 5 === INDIVIDUAL METHOD TESTS === conditional: :test0,:test1,:test2 (params: 3) implode: :test0,:test1,:test2 (params: 3) trim: :test0,:test1,:test2 (params: 3) regex: :test0,:test1,:test2 (params: 3) serializable: :test0,:test1,:test2 (params: 3) array_map: :test0,:test1,:test2 (params: 3) === BENCHMARK RESULTS === Benchmark Results (seconds for 1000 iterations): ================================================================================ PERFORMANCE SUMMARY (typical results): • Small arrays (1-20): conditional comma fastest • Medium arrays (21-100): trim method often fastest • Large arrays (100+): implode method fastest • Regex method: slowest due to overhead • Serializable: moderate performance, good for caching • Array map: good functional style, moderate performance Array Size: 10 ---------------------------------------- 1. implode: 0.002010s 🥇 2. trim: 0.002251s 🥈 3. conditional: 0.002333s 🥉 4. array_map: 0.002434s 5. serializable: 0.003902s 6. regex: 0.004120s Array Size: 50 ---------------------------------------- 1. array_map: 0.004073s 🥇 2. trim: 0.004301s 🥈 3. implode: 0.005312s 🥉 4. serializable: 0.005369s 5. regex: 0.006612s 6. conditional: 0.010006s Array Size: 100 ---------------------------------------- 1. array_map: 0.008070s 🥇 2. implode: 0.008127s 🥈 3. conditional: 0.009151s 🥉 4. trim: 0.009834s 5. serializable: 0.010173s 6. regex: 0.012804s Array Size: 500 ---------------------------------------- 1. trim: 0.042357s 🥇 2. implode: 0.043186s 🥈 3. conditional: 0.049343s 🥉 4. array_map: 0.049350s 5. serializable: 0.049804s 6. regex: 0.062403s Array Size: 1000 ---------------------------------------- 1. implode: 0.078540s 🥇 2. array_map: 0.078565s 🥈 3. trim: 0.083505s 🥉 4. conditional: 0.095401s 5. serializable: 0.098375s 6. regex: 0.124505s === SERIALIZATION TEST === Object: :param1,:param2,:param3 Serialized: a:3:{i:0;s:7:":param1";i:1;s:7:":param2";i:2;s:7:":param3";} Unserialized: :param1,:param2,:param3
preferences:
73.84 ms | 704 KiB | 5 Q