Returns model table name

@return string
336124
public function getTableName()
    {
        if (is_null($this->_tableName)) {
            $this->_tableName = $this->getDescriptor()->getEntity()
                ->getTableName();
        }
        return $this->_tableName;
    }
1268368
public static function getTable()
    {
        $attribute = 'table';

        if (!static::hasClassAttribute($attribute)) {
            $name = !isset(static::$table)
                ? static::getClassName()
                : static::$table;

            $conventionName = Functions::applyConventions(
                static::getClassConfig('table-name-conventions'),
                $name
            );

            $tableName = static::getDatabase()->getPrefix($conventionName);

            static::setClassAttribute($attribute, $tableName);
        }

        return static::getClassAttribute($attribute);
    }
316486
public function getForeignTableName()
    {
        $platform = $this->getPlatform();
        if ($this->foreignSchemaName && $platform->supportsSchemas()) {
            return $this->foreignSchemaName
                . $platform->getSchemaDelimiter()
                . $this->foreignTableCommonName
            ;
        }

        $database = $this->getDatabase();
        if ($database && ($schema = $this->parentTable->guessSchemaName()) && $platform->supportsSchemas()) {
            return $schema
                . $platform->getSchemaDelimiter()
                . $this->foreignTableCommonName
            ;
        }

        return $this->foreignTableCommonName;
    }
1071402
public function getTable() {

		if(null === $this -> table) {

			$path  = $this -> getNamespace($this, ['directory', 'entity'], ['directory', 'entity']) . Application :: get(['prefix', 'entity']);
			$path  = str_replace(DIRECTORY_SEPARATOR, '\\', $path);
			$class = new \ReflectionClass(get_class($this));
			
			$this -> table = NameConvert :: toSnakecase(str_replace($path, '', $class -> name));
		}

		return $this -> table;
	}
827628
public static function getTableName()
    {
        $r = new \ReflectionClass(static::class);
        $classNameUpperCamelCase = $r->getShortName();
        $classNameLower = strtolower($classNameUpperCamelCase);


        return $classNameLower . 's';
    }
935202
protected function getModelShortName() {
        if (!$this->_modelShortName) {
            $m = explode('\\', $this->modelClass);
            $this->_modelShortName = $m[count($m) - 1];
        }
        return $this->_modelShortName;
    }
672445
private function buildTableName(): string
    {
        $table = '{db_prefix}' . $this->table;
        
        $no_alias_methods = [
            'REPLACE',
            'INSERT'
        ];
        
        if (in_array($this->method, $no_alias_methods)) {
            return $table;
        }
        
        if (! empty($this->alias)) {
            $table .= ' AS ' . $this->alias;
        }
        
        return $table;
    }
1260139
private function determineTableName()
    {
        $annotations = $this->inspector->getClassAnnotations();
        $name = self::parseTableName($this->entity);
        if ($annotations->hasAnnotation('@table')) {
            $name = $annotations->getAnnotation('@table')->getValue();
        }
        return $name;
    }
445952
protected function fetchTableNamesDb() {
        // Get the table names.
        $tables = $this->get(
            new Identifier('sqlite_master'),
            [
                'type' => 'table',
                'name' => [Db::OP_LIKE => $this->escapeLike($this->getPx()).'%']
            ],
            [
                'columns' => ['name']
            ]
        )->fetchAll(PDO::FETCH_COLUMN);

        // Remove internal tables.
        $tables = array_filter($tables, function ($name) {
            return substr($name, 0, 7) !== 'sqlite_';
        });

        return $tables;
    }
99385
public function getTablesNames()
    {
        $aTables      = array_keys($this->getTablesCreateSql());
        $prefixTables = $this->getTablePrefix();

        $return = array();
        foreach ($aTables as $table) {
            $return[] = $prefixTables . $table;
        }

        return $return;
    }
1137453
public function getTableName() {
        if(empty($this->trueTableName)) {
            $tableName  = !empty($this->tablePrefix) ? $this->tablePrefix : '';
            if(!empty($this->tableName)) {
                $tableName .= $this->tableName;
            }else{
                $tableName .= parse_name($this->name);
            }
            $this->trueTableName    =   strtolower($tableName);
        }
        return (!empty($this->dbName)?$this->dbName.'.':'').$this->trueTableName;
    }
894087
public function getTableName(): string
    {
        if ($this->tableName === null)
        {
            $this->tableName = (new \ReflectionClass($this))->getShortName();
        }

        return $this->tableName;
    }
998145
public function getTable()
    {
        // If the table is set manually, return it.
        if(isset($this->table))
        {
            return $this->table;
        }

        // Return only the class name in snake case.
        return snake_case(array_pop( explode('\\', get_class($this))));
    }
1020040
public function getClassName()
    {
        return ($this->tableName() === null) ? self::pluralize(self::stripclassName()) : $this->tableName();
    }
467640
public function getModelDisplayName()
    {
        $instance = $this->getModelInstance();
        $display = isset($instance->display) ? $instance->display : ucfirst($this->model);

        return $display;
    }
1056634
public function getModelTables()
    {
        if ($this->tables === null) {
            $this->setModelTables($this->loadModelTables());
        }

        return $this->tables;
    }
654188
public function getTableName()
    {
        if (is_null($this->_tableName)) {
            $parts = explode('\\', $this->getClassName());
            $name = end($parts);
            $this->_tableName = Text::plural(strtolower($name));
        }
        return $this->_tableName;
    }