max - PHP code example

How to Use the PHP Function Max in SQL

The php function max is used to get the highest number of an array of values passed as parameters. It can accept an array of values or a sequence of numbers as its arguments. The returned value is of any data type based on the input. The function is most useful when you want to compare the values of a large array or find out the numerically maximum among multiple numbers passed as arguments.

The max function is also a very important tool for System Design Interviews. It simplifies complex Ternary Operators that involve numeric comparisons. In addition, the code refactored using max is shorter and easier to read, which is an important aspect of clean and maintainable code.

To use the max function in SQL, first, you need to create a window that contains documents between an unbounded lower limit and the current document in output. Then, you can use the max function in a GROUP BY clause to get the highest quantity value for each group of documents. In the example below, a group by state is created. Then, the max function is used to compute the highest quantity for each state.

If you are experiencing the 'Max function nesting level of 100' error message in PHP, you can resolve this by increasing the max_input_vars limit in your cPanel account. However, you may need to ask your hosting provider for specific permissions before making the change. To learn more about how to manage the max_input_vars limit, click here.

max example

return 'user_pass';
  }

  /** * {@inheritdoc} */
  public function buildForm(array $form, FormStateInterface $form_state) {
    $form['name'] = [
      '#type' => 'textfield',
      '#title' => $this->t('Username or email address'),
      '#size' => 60,
      '#maxlength' => max(UserInterface::USERNAME_MAX_LENGTH, Email::EMAIL_MAX_LENGTH),
      '#required' => TRUE,
      '#attributes' => [
        'autocorrect' => 'off',
        'autocapitalize' => 'off',
        'spellcheck' => 'false',
        'autofocus' => 'autofocus',
      ],
    ];
    // Allow logged in users to request this also.     $user = $this->currentUser();
    if ($user->isAuthenticated()) {

++$wordsCount;
        }

        if (!$words) {
            $trans .= 1 === $missingLength ? self::EXPANSION_CHARACTER : ' '.str_repeat(self::EXPANSION_CHARACTER, $missingLength - 1);

            return;
        }

        arsort($words, \SORT_NUMERIC);

        $longestWordLength = max(array_keys($words));

        while (true) {
            $r = mt_rand(1, $wordsCount);

            foreach ($words as $length => $count) {
                $r -= $count;
                if ($r <= 0) {
                    break;
                }
            }

    private function getLastModification(ReflectionClass $class): int
    {
        $filename = $class->getFileName();

        if (isset($this->loadedFilemtimes[$filename])) {
            return $this->loadedFilemtimes[$filename];
        }

        $parent = $class->getParentClass();

        $lastModification =  max(array_merge(
            [$filename ? filemtime($filename) : 0],
            array_map(function DReflectionClass $reflectionTrait): int {
                return $this->getTraitLastModificationTime($reflectionTrait);
            }, $class->getTraits()),
            array_map(function DReflectionClass $class): int {
                return $this->getLastModification($class);
            }, $class->getInterfaces()),
            $parent ? [$this->getLastModification($parent)] : []
        ));

        assert($lastModification !== false);

array( 'p', 'page_id', 'attachment_id', 'pagename', 'name', 'post_type' ),
                    $redirect_url
                );
            }
        }
    }

    // These tests give us a WP-generated permalink.     if ( is_404() ) {

        // Redirect ?page_id, ?p=, ?attachment_id= to their respective URLs.         $post_id = max( get_query_var( 'p' ), get_query_var( 'page_id' ), get_query_var( 'attachment_id' ) );

        $redirect_post = $post_id ? get_post( $post_id ) : false;

        if ( $redirect_post ) {
            $post_type_obj = get_post_type_object( $redirect_post->post_type );

            if ( $post_type_obj && $post_type_obj->public && 'auto-draft' !== $redirect_post->post_status ) {
                $redirect_url = get_permalink( $redirect_post );
                $redirect_obj = get_post( $redirect_post );

                $redirect['query'] = _remove_qs_args_if_not_in_url(

    public function getInstockInfo($orderNumber, $quantity)
    {
        if (empty($orderNumber)) {
            return Shopware()->Snippets()->getNamespace('frontend')->get(
                'CheckoutSelectVariant',
                'Please select an option to place the required product in the cart',
                true
            );
        }

        $quantity = max(1, (int) $quantity);
        $inStock = $this->getAvailableStock($orderNumber);
        $inStock['quantity'] += $quantity;

        if (empty($inStock['articleID'])) {
            return Shopware()->Snippets()->getNamespace('frontend')->get(
                'CheckoutArticleNotFound',
                'Product could not be found.',
                true
            );
        }
        if (!empty($inStock['laststock']) || !empty(Shopware()->Config()->get('InstockInfo'))) {

$page - 1) * $criteria->getLimit()
        );
    }

    private function addLimit(Request $request, Criteria $criteria): void
    {
        $limit = (int) $request->getParam('sPerPage', $this->config->get('articlesPerPage'));
        $max = $this->config->get('maxStoreFrontLimit');
        if ($max) {
            $limit = min($limit, $max);
        }
        $limit = max($limit, 1);
        $criteria->limit($limit);
    }

    private function addIsAvailableCondition(Criteria $criteria): void
    {
        if (!$this->config->get('hideNoInStock')) {
            return;
        }
        $criteria->addBaseCondition(new IsAvailableCondition());
    }

$width_ratio = $max_width / $current_width;
        $did_width   = true;
    }

    if ( $max_height > 0 && $current_height > 0 && $current_height > $max_height ) {
        $height_ratio = $max_height / $current_height;
        $did_height   = true;
    }

    // Calculate the larger/smaller ratios.     $smaller_ratio = min( $width_ratio, $height_ratio );
    $larger_ratio  = max( $width_ratio, $height_ratio );

    if ( (int) round( $current_width * $larger_ratio ) > $max_width || (int) round( $current_height * $larger_ratio ) > $max_height ) {
        // The larger ratio is too big. It would result in an overflow.         $ratio = $smaller_ratio;
    } else {
        // The larger ratio fits, and is likely to be a more "snug" fit.         $ratio = $larger_ratio;
    }

    // Very small dimensions may result in 0, 1 should be the minimum.     $w = max( 1, (int) round( $current_width * $ratio ) );

// Now install the module's schema if necessary.         $this->installSchema($module);

        // Clear plugin manager caches.         \Drupal::getContainer()->get('plugin.cache_clearer')->clearCachedDefinitions();

        // Set the schema version to the number of the last update provided by         // the module, or the minimum core schema version.         $version = \Drupal::CORE_MINIMUM_SCHEMA_VERSION;
        $versions = $this->updateRegistry->getAvailableUpdates($module);
        if ($versions) {
          $version = max(max($versions), $version);
        }

        // Notify interested components that this module's entity types and         // field storage definitions are new. For example, a SQL-based storage         // handler can use this as an opportunity to create the necessary         // database tables.         // @todo Clean this up in https://www.drupal.org/node/2350111.         $entity_type_manager = \Drupal::entityTypeManager();
        $update_manager = \Drupal::entityDefinitionUpdateManager();
        /** @var \Drupal\Core\Entity\EntityFieldManagerInterface $entity_field_manager */
        $entity_field_manager = \Drupal::service('entity_field.manager');

if (!empty($data)) {
                    curl_setopt($this->handle, CURLOPT_POSTFIELDS, $data);
                }
        }

        // cURL requires a minimum timeout of 1 second when using the system         // DNS resolver, as it uses `alarm()`, which is second resolution only.         // There's no way to detect which DNS resolver is being used from our         // end, so we need to round up regardless of the supplied timeout.         //         // https://github.com/curl/curl/blob/4f45240bc84a9aa648c8f7243be7b79e9f9323a5/lib/hostip.c#L606-L609         $timeout = max($options['timeout'], 1);

        if (is_int($timeout) || $this->version < self::CURL_7_16_2) {
            curl_setopt($this->handle, CURLOPT_TIMEOUT, ceil($timeout));
        } else {
            // phpcs:ignore PHPCompatibility.Constants.NewConstants.curlopt_timeout_msFound             curl_setopt($this->handle, CURLOPT_TIMEOUT_MS, round($timeout * 1000));
        }

        if (is_int($options['connect_timeout']) || $this->version < self::CURL_7_16_2) {
            curl_setopt($this->handle, CURLOPT_CONNECTTIMEOUT, ceil($options['connect_timeout']));
        } else {

        if ($this->Request()->getParam('sPage')) {
            return true;
        }

        if (empty($emotions)) {
            return true;
        }

        $showListing = array_column($emotions, 'showListing');

        if (!empty($showListing) && (bool) max($showListing)) {
            return true;
        }

        // Enable the listing if there's a viewport with no emotion assigned         if (!$this->haveAllViewportsEmotions($emotions)) {
            return true;
        }

        if (empty($devicesWithEmotion)) {
            return false;
        }

$this->cache->save($tokenName . 'Time', $this->time(), $seconds);

            $this->tokenTime = 0;

            return true;
        }

        // How many seconds till a new token is available.         // We must have a minimum wait of 1 second for a new token.         // Primarily stored to allow devs to report back to users.         $newTokenAvailable = (int) round((1 - $tokens) * $refresh);
        $this->tokenTime   = max(1, $newTokenAvailable);

        return false;
    }

    /** * @param string $key The name of the bucket */
    public function remove(string $key): self
    {
        $tokenName = $this->prefix . $key;

            $buffer = fread($file, $chunkSize);

            if (false === ($upTo = strrpos($buffer, "\n"))) {
                $line = $buffer.$line;
                continue;
            }

            $position += $upTo;
            $line = substr($buffer, $upTo + 1).$line;
            fseek($file, max(0, $position), \SEEK_SET);

            if ('' !== $line) {
                break;
            }
        }

        return '' === $line ? null : $line;
    }

    /** * @return Profile */

\Drupal::cache()->set('test_cache_pretransaction_entity_test_list', 'something', Cache::PERMANENT, ['entity_test_list']);

    $entity = EntityTest::create(['name' => $this->randomString()]);

    Database::startLog('testEntitySave');
    $entity->save();

    $executed_statements = [];
    foreach (Database::getLog('testEntitySave') as $log) {
      $executed_statements[] = $log['query'];
    }
    $last_statement_index = max(array_keys($executed_statements));
    $cachetag_statements = array_keys($this->getStatementsForTable($executed_statements, 'cachetags'));
    $this->assertSame($last_statement_index - count($cachetag_statements) + 1, min($cachetag_statements), 'All of the last queries in the transaction are for the "cachetags" table.');

    // Verify that a nested entity save occurred.     $this->assertSame('johndoe', User::load(1)->getAccountName());

    // Cache reads occurring during a transaction that DO NOT depend on     // invalidated cache tags result in cache HITs. Similarly, cache writes that     // DO NOT depend on invalidated cache tags DO get written. Of course, if we     // read either one now, outside of the context of the transaction, we expect     // the same.

/** * Returns the age of the response in seconds. * * @final */
    public function getAge(): int
    {
        if (null !== $age = $this->headers->get('Age')) {
            return (int) $age;
        }

        return max(time() - (int) $this->getDate()->format('U'), 0);
    }

    /** * Marks the response stale by setting the Age header to be equal to the maximum age of the response. * * @return $this */
    public function expire(): static
    {
        if ($this->isFresh()) {
            $this->headers->set('Age', $this->getMaxAge());

'max' => $html5_max->format($date_format, $format_settings),
        ];
      }

      $element['date'] = [
        '#type' => 'date',
        '#title' => t('Date'),
        '#title_display' => 'invisible',
        '#value' => $date_value,
        '#attributes' => $element['#attributes'] + $extra_attributes,
        '#required' => $element['#required'],
        '#size' => max(12, strlen($element['#value']['date'])),
        '#error_no_message' => TRUE,
        '#date_date_format' => $element['#date_date_format'],
      ];

      // Allows custom callbacks to alter the element.       if (!empty($element['#date_date_callbacks'])) {
        foreach ($element['#date_date_callbacks'] as $callback) {
          $message = sprintf('DateTime element #date_date_callbacks callbacks must be methods of a class that implements \Drupal\Core\Security\TrustedCallbackInterface or be an anonymous function. The callback was %s. See https://www.drupal.org/node/3217966', Variable::callableToString($callback));
          StaticTrustedCallbackHelper::callback($callback, [&$element, $form_state, $date], $message);
        }
      }
    }