{@inheritDoc}

@param string $tableName
@throws GdgCommonsInvalidArgumentException
429420
public function setTableName($tableName = "")
    {
        if (empty($tableName)) {
            throw new GdgCommonsInvalidArgumentException("Table name must not be null or empty");
        }
        
        if (!is_string($tableName)) {
            throw new GdgCommonsInvalidArgumentException("Table name must be string");
        }
        
        $this->_tableName = $tableName;
    }
1231329
protected function skipTable($tableName)
    {
        // Check if select options is set and table name is not selected
        if (count($this->option('select')) > 0 && !in_array($tableName, $this->option('select'), true)) {
            return true;
        }

        // Check if table name is ignored
        if (in_array($tableName, $this->option('ignore'), true)) {
            return true;
        }

        return false;
    }
121538
public function handle(string $tableName)
    {
        $recordFinder = GeneralUtility::makeInstance(RecordFinder::class);
        $pidOfMainTable = $recordFinder->findPidOfMainTableRecord($tableName);
        $recordData = GeneralUtility::makeInstance(RecordData::class);

        $childRelationUids = [];
        $numberOfChildRelationsToCreate = 2;
        $numberOfChildRows = 4;
        $connectionPool = GeneralUtility::makeInstance(ConnectionPool::class);
        for ($i = 0; $i < $numberOfChildRows; $i ++) {
            $fieldValues = [
                'pid' => $pidOfMainTable,
            ];
            $connection = $connectionPool->getConnectionForTable('tx_styleguide_inline_mn_child');
            $connection->insert('tx_styleguide_inline_mn_child', $fieldValues);
            $fieldValues['uid'] = $connection->lastInsertId('tx_styleguide_inline_mn_child');
            if (count($childRelationUids) < $numberOfChildRelationsToCreate) {
                $childRelationUids[] = $fieldValues['uid'];
            }
            $fieldValues = $recordData->generate('tx_styleguide_inline_mn_child', $fieldValues);
            $connection->update(
                'tx_styleguide_inline_mn_child',
                $fieldValues,
                [ 'uid' => (int)$fieldValues['uid'] ]
            );
        }

        $fieldValues = [
            'pid' => $pidOfMainTable,
            'inline_1' => $numberOfChildRelationsToCreate,
        ];
        $connection = $connectionPool->getConnectionForTable($tableName);
        $connection->insert($tableName, $fieldValues);
        $parentid = $fieldValues['uid'] = $connection->lastInsertId($tableName);
        $fieldValues = $recordData->generate($tableName, $fieldValues);
        $connection->update(
            $tableName,
            $fieldValues,
            [ 'uid' => (int)$fieldValues['uid'] ]
        );

        $this->generateTranslatedRecords($tableName, $fieldValues);

        foreach ($childRelationUids as $uid) {
            $mmFieldValues = [
                'pid' => $pidOfMainTable,
                'parentid' => $parentid,
                'childid' => $uid,
            ];
            $connection = $connectionPool->getConnectionForTable('tx_styleguide_inline_mn_mm');
            $connection->insert('tx_styleguide_inline_mn_mm', $mmFieldValues);
        }
    }
12703
public function dropTable($tableName)
    {
        $this->db->query('SET FOREIGN_KEY_CHECKS = 0;');
        $this->db->query("DROP TABLE IF EXISTS `{$this->getTableNamePrefix($tableName)}`;");
        $this->db->query('SET FOREIGN_KEY_CHECKS = 1;');  
    }
435440
private function _createContentTable(string $tableName)
    {
        $migration = new CreateSuperTableContentTable([
            'tableName' => $tableName
        ]);

        ob_start();
        $migration->up();
        ob_end_clean();
    }
1055834
public function validateProperty(string $propertyName): void
    {
        $errors = $this->validator->validateProperty($this->dataObject, $propertyName);
        $this->throwExceptionIfErrors($errors);
    }
530513
protected function validateTableName($tableName = null)
    {
        $tableName = $tableName === null ? $this->tableName : $tableName;

        if ($tableName === null) {
            throw new DbExporterException('Table name is null');
        }

        return $tableName;
    }
1220528
public function tableName($tableName = null)
    {
        if ($tableName === null)
        {
            return $this->_tableName;
        }
        $this->_tableName = $tableName;

        return $this;
    }
348161
public function setTable($table)
    {
        if (is_array($table)) {
            if (!isset($table['name'])) {
                throw new \InvalidArgumentException('A name key is required when passing an array to setTable()');
            }
            $this->table = $table['name'];
        } else {
            $this->table = $table;
        }
    }
1187348
protected function checkTableArgument($table = null)
    {
        if ($table !== null) {
            if (!is_string($table) || trim($table) == '') {
                throw new Exception\InvalidArgumentException(__METHOD__ . ' Table name must be a valid string or an empty string detected');
            }
        }
    }
65681
protected function generateCreateTableSql( $tableName, ezcDbSchemaTable $tableDefinition )
    {
        $this->context['skip_primary'] = false;
        parent::generateCreateTableSql( $tableName, $tableDefinition );
    }
380512
public function insert($tableName, array $data) 
    {
        $this->count++;
        try {
            return $this->persistence->insert($tableName, $data);
        } catch (\PDOException $e) {
            \common_Logger::w('Failed insertion on table : '.$tableName);
            throw $e;
        }
    }
1105972
protected function verifyRowName($rowName) {
    if (1
      && !isset($this->rows[$rowName])
      && !isset($this->rowGroups[$rowName])
      && '' !== $rowName
    ) {
      throw new \Exception("Unknown row name '$rowName'.");
    }
  }
37785
public static function checkTableExists(string $tableName): bool
  {
    $query = sprintf('
select 1
from   information_schema.TABLES
where table_schema = database()
and   table_name   = %s', self::$dl->quoteString($tableName));

    return !empty(self::executeSingleton0($query));
  }
1106351
protected function tableExist($tableName)
    {
        /** @var \Doctrine\DBAL\Schema\AbstractSchemaManager $sm */
        $sm = $this->dbHandler->getConnection()->getSchemaManager();
        foreach ($sm->listTables() as $table) {
            if ($table->getName() == $tableName) {
                return true;
            }
        }

        return false;
    }
378594
public static function dropTemporaryTable(string $tableName): void
  {
    $query = sprintf('drop temporary table `%s`', $tableName);

    self::executeNone($query);
  }
1321993
protected static function checkColumn($tableName, $columnName, $con=NULL)
    {
        $connection = self::checkConnection($con);

            $result = $connection->prepare("SELECT {$columnName} FROM {$tableName}");
            $result->execute();
            if (! $result->columnCount())
            {
                throw new ColumnNotExistExeption();
            }
            return $columnName;
    }