@param string $constantName

@return bool
170040
protected function isPropelQueryConstant(string $constantName): bool
    {
        $propelQueryConstantPattern = '/^PROPEL_QUERY_.+/';

        if (!preg_match($propelQueryConstantPattern, $constantName)) {
            return false;
        }

        return true;
    }
451795
public function checkTableExists(string $tableName): bool
    {
        try {
            $result = $this->pdo->query("SELECT 1 FROM $tableName LIMIT 1");
        } catch (\Exception $e) {
            return false;
        }

        return $result !== false;
    }
1254881
public function isLoaded($name)
    {
        $name = $this->_formatName($name);
        if ($this->_useStaticRegistry) {
            return isset(self::$_staticLoadedPlugins[$this->_useStaticRegistry][$name]);
        }

        return isset($this->_loadedPlugins[$name]);
    }
1370587
public function tableExists($tableName) {
        $tables = $this->query("SHOW TABLES");
        foreach ($tables as $k => $table) {
            $key = 'Tables_in_' . $this->config['table'];
            if (strtolower($table[$key]) == strtolower($this->getPrefix() . $tableName)) {
                return TRUE;
            }
        }
        return FALSE;
    }
341278
public static function Has($sName){
            $oThis = self::CreateInstanceIfNotExists();
            $sName = strtolower(str_replace(array("/", "\\", "--"), "-", $sName));//Bugfix        
            return array_key_exists($sName, $oThis->aEvents);
        }
1342609
public function isVirtual(string $propertyName): bool
    {
        $this->existsOrFail($propertyName);
        return $this->isExistingPropertyVirtual($propertyName);
    }
917675
public static function isSingleton($name)
    {
        if (!static::exists($name)) {
            return false;
        }
        if (empty(static::$classNames[$name]['singleton']) &&
            empty(static::$classAliases[$name]['singleton'])
        ) {
            return false;
        }

        return true;
    }
1106103
protected function hasConstantFromInterfaces($name)
    {
        if ($interfaces = $this->getImplementedInterfaceDefinitions()) {
            foreach ($interfaces as $interface) {
                if ($interface->hasConstant($name)) {
                    return true;
                }
            }
        }

        return false;
    }
175968
public function tableExists($tablename)
  {
    $fromdb = "";

    if ($pos = strpos($tablename, "."))
    {
      $fromdb = "from `".substr($tablename, 0, $pos)."`";
      $tablename = substr($tablename, $pos+1);
    }

    $query = "show tables $fromdb like ".$this->quote($tablename);
    $result = $this->q($query);

    $exists = mysqli_num_rows($result) != 0;
    mysqli_free_result($result);
    return $exists;
  }
1307514
public function isIndexable($refName)
    {
        return $this->getValue(
            $refName,
            'indexable',
            function ($page) {
                /* @var IndexableInterface $page */
                return false === $page instanceof IndexableInterface || $page->isIndexable();
            }
        );
    }
632239
public function hasConstant($name)
    {
        if (isset($this->constants[$name])) {
            return true;
        }

        $extendsClassDefinition = $this->getExtendsClassDefinition();
        if ($extendsClassDefinition) {
            if ($extendsClassDefinition->hasConstant($name)) {
                return true;
            }
        }

        /*
         * Check if constant is defined in interfaces
         */
        return $this->hasConstantFromInterfaces($name);
    }
8800
private static function constant(string $name)
    {
        $constant = static::class . '::' . $name;

        if (!defined($constant)) {
            $message = sprintf('Enum %s does not contain value named %s.', static::class, $name);
            throw new InvalidArgumentException($message);
        }

        return constant($constant);
    }
1283888
public function hasClass($className)
    {
        foreach ($this->meta['classes'] as $classInMeta) {
            if ($classInMeta === $className) {
                return true;
            }
        }

        return false;
    }
80394
public function has(string $name): bool
	{
		return isset($this->headers[$this->normalizeName($name)]);
	}
1250670
public function existTable(string $tableName): bool
    {
        [$dbName, $tableName] = $this->parseTableName($tableName);

        $sql = 'SELECT table_name
            FROM information_schema.tables
            WHERE table_schema = %s
            AND table_name = %s;';

        $sql = sprintf($sql, $dbName, $tableName);
        $row = $this->db->query($sql)->fetch(PDO::FETCH_ASSOC);

        return isset($row['table_name']);
    }
729684
public static function getNameByConstant($constant)
    {
        switch ($constant) {
            case self::SINGLE:
                return 'single';
            break;

            case self::MULTIPLE:
                return 'multiple';
            break;

            case self::ORDERED:
                return 'ordered';
            break;

            case self::RECORD:
                return 'record';
            break;

            default:
                return false;
            break;
        }
    }
282141
private static function noAmbiguousValues($constants)
    {
        foreach ($constants as $value) {
            $names = \array_keys($constants, $value, true);
            if (\count($names) > 1) {
                return false;
            }
        }

        return true;
    }