get the table name by passing this along to the underlying model
@param string $type
@return
177402
public function getTableName($type = 'plural')
    {
        $property = $type . 'TableName';
        if ($this->$property == null) {
            $this->model = $this->getModel();
            $this->$property = $this->model->getTableName($type);
        }
        return $this->$property;
    }
850729
public function getParamFormat(string $type): string
    {
        return ltrim(($this->containerPrefix.'.entity.'.$this->entityName.'.'.$type), '.');
    }
413949
protected function getType($type)
    {
        if (isset($this->typeAlias[$type])) {
            return $this->typeAlias[$type];
        }

        return $type;
    }
1329488
public function getConnection($type = Propel::CONNECTION_READ)
    {
        $databaseName = constant($this->getPeerClass() . '::DATABASE_NAME');

        return Propel::getConnection($databaseName, $type);
    }
169656
public function getEntityName($type)
    {
        $event = new NodeResolveEntityNameEvent($type);
        $this->dispatcher
            ->dispatch(NodeEvents::RESOLVE_ENTITY_NAME, $event);

        return $event->getEntityName();
    }
684783
public static function getName(int $type) : string
    {
        $names = [self::UNKNOWN => 'unknown', self::STANDARD => 'standard', self::FULL => 'full', self::LITE => 'lite'];
        return $names[$type] ?? 'invalid';
    }
509266
public function getModelFieldType($type)
    {
        $type = preg_replace('/\(.*/', '', strtolower($type)); // remove parenthesis

        if (substr($type, 0, 7) == 'varchar' || substr($type, 0, 4) == 'char' || substr($type, 0, 4) == 'enum') {
            $type = null;
        }

        if ($type == 'tinyint') {
            $type = 'boolean';
        }

        if ($type == 'int') {
            $type = 'integer';
        }

        if ($type == 'decimal') {
            $type = 'float';
        }

        if ($type == 'longtext' || $type == 'longblob') {
            $type = 'text';
        }

        return $type;
    }
207842
public static function getTypeName($type)
    {
        switch ($type) {
            case self::IFD0:
                return '0';
            case self::IFD1:
                return '1';
            case self::EXIF:
                return 'Exif';
            case self::GPS:
                return 'GPS';
            case self::INTEROPERABILITY:
                return 'Interoperability';
            case self::CANON_MAKER_NOTES:
                return 'Canon Maker Notes';
            case self::CANON_CAMERA_SETTINGS:
                return 'Canon Camera Settings';
            case self::CANON_SHOT_INFO:
                return 'Canon Shot Information';
            case self::CANON_PANORAMA:
                return 'Canon Panorama Information';
            case self::CANON_PICTURE_INFO:
                return 'Canon Picture Information';
            case self::CANON_FILE_INFO:
                return 'Canon File Information';
            case self::CANON_CUSTOM_FUNCTIONS:
                return 'Canon Custom Functions';
            default:
                throw new PelIfdException('Unknown IFD type: %d', $type);
        }
    }
653747
static public function getStorableType( $type )
    {
        switch ( $type )
        {
            case 'google':      return self::TYPE_GOOGLE;
            case 'facebook':    return self::TYPE_FACEBOOK;
            case 'yahoo':       return self::TYPE_YAHOO;
            case 'twitter':     return self::TYPE_TWITTER;
        }
    }
674613
public function getMediaModelName($type)
    {
        return isset($this->modelTypes[$type]) ?
            $this->modelTypes[$type] :
            $this->getDefaultMediaModelName();
    }
1207426
public function getTableName() {
        if(empty($this->trueTableName)) {
            $tableName  =   array();
            $models     =   $this->modelList;
            foreach($models as $model){
                $tableName[]    =   M($model)->getTableName().' '.$model;
            }
            $this->trueTableName    =   implode(',',$tableName);
        }
        return $this->trueTableName;
    }
873796
public function getFieldNameByBaseType($base_type)
    {
        $this->getTableInfo();
        $field = null;
        if (isset($this['fields'])) {
            if (isset($this['fields'][$base_type])) {
                $field = $base_type;
            }
            foreach ($this['fields'] as $v) {
                if (isset($v['base_type']) && $v['base_type'] == $base_type) {
                    $field = $v['field_name'];
                    break;
                }
            }
        }
        
        return $field;
    }
996465
public static function getInstance($type)
    {
        self::checkType($type);

        if (!isset(self::$instances[$type])) {
            self::$instances[$type] = new \Tx_Oelib_Session($type);
        }

        return self::$instances[$type];
    }
872724
protected function getResultsByType($type)
    {
        $instance = $this->createModelByType($type);

        $key = $instance->getKeyName();

        $query = $instance->newQuery();

        $query = $this->useWithTrashed($query);

        return $query->whereIn($key, $this->gatherKeysByType($type)->all())->get();
    }
1108560
private function getTypeTranslation($type)
    {
        if (!array_key_exists($type, $this->typeConfiguration)) {
            return ucfirst($type);
        }

        $typeTranslationKey = $this->typeConfiguration[$type]['translation_key'];

        return $this->translator->trans($typeTranslationKey, [], 'backend');
    }
894087
public function getTableName(): string
    {
        if ($this->tableName === null)
        {
            $this->tableName = (new \ReflectionClass($this))->getShortName();
        }

        return $this->tableName;
    }
941740
protected static function getConnection($type) {
    $mapper = self::getMapper($type);
    $conn = $mapper->getConnection();
    return $conn;
  }