Creates and returns a copy of this table object.

@return cloned table
963433
public Table cloneTable()
    {
        Table ret = null;
        try {
            ret = (Table) super.clone();
        } catch (final CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return ret;
    }
390285
protected function exportCreateTable()
    {
        $table = new Table(self::TABLE_NAME, array(), array(), array(), false, array());
        $table->addColumn('id', 'string', array('length' => 64, 'notnull' => true));
        $table->setPrimaryKey(array('id'));
        $table->addColumn('value', 'string', array('length' => 64));

        $sql = $this->getConnection()
            ->getDatabasePlatform()
            ->getCreateTableSQL($table, AbstractPlatform::CREATE_INDEXES)
        ;

        return array_pop($sql).';'.PHP_EOL;
    }
1022514
protected function getTable()
    {
        $schema = $this->connection->getSchemaManager();

        if (!$schema->tablesExist($this->table)) {
            $schema->createTable($this->getTableDefinition());
        }

        return $this->getConnection()->createQueryBuilder();
    }
31149
public function getTable()
    {
        if (!isset($this->table)) {
            return str_replace('\\', '', Str::snake(Str::plural(class_basename($this))));
        }

        return $this->table;
    }
1032254
private function createTable()
    {
        $sql = "CREATE TABLE `" . $this->schemaName . "` (";

        $definitions = [];

        foreach ($this->columns as $columnName => $column) {
            // The column might be using a more generic type for it's storage.
            $storageColumns = $column->createStorageColumns();

            foreach ($storageColumns as $storageColumn) {
                // And if so that column will be a generic column type - we need to upgrade it.
                $storageColumn = $storageColumn->getRepositorySpecificColumn("MySql");
                $definitions[] = $storageColumn->getDefinition();
            }
        }

        foreach ($this->indexes as $indexName => $index) {
            $indexDefinition = $index->getDefinition();
            if ($indexDefinition) {
                $definitions[] = $indexDefinition;
            }
        }

        $sql .= implode(",", $definitions);
        $sql .= "
			)";

        /** @var MySql $repos */
        $repos = Repository::getDefaultRepositoryClassName();
        $repos::executeStatement($sql);
    }
842265
public function copy() {
        $copied = clone $this;

        $worksheetCount = count($this->_workSheetCollection);
        for ($i = 0; $i < $worksheetCount; ++$i) {
            $this->_workSheetCollection[$i] = $this->_workSheetCollection[$i]->copy();
            $this->_workSheetCollection[$i]->rebindParent($this);
        }

        return $copied;
    }
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))));
    }
1258724
public function copy()
	{
		$view = $this->getView();

		$view->selectionData = $this->toArray( $view->item, true );
		$view->selectionBody = '';

		foreach( $this->getSubClients() as $client ) {
			$view->selectionBody .= $client->copy();
		}

		return $this->render( $view );
	}
631795
public function getTable()
    {
        if ($this->_table === null) {
            $table = namespaceSplit(get_class($this));
            $table = substr(end($table), 0, -5);
            if (!$table) {
                $table = $this->getAlias();
            }
            $this->_table = Inflector::underscore($table);
        }

        return $this->_table;
    }
229641
public function CloneInstance()
	{
		$result = new ChildNodeIterator();
		$result->AssignFrom( $this );
		$result->excludeComments = $this->excludeComments;
		$result->excludeWhitespace = $this->excludeWhitespace;
		return $result;
	}
409731
public function copy(string $newTableName = null): Table {
		if (null === $newTableName) {
			$newTableName = $this->getName();
		}
		
		$newTable = new MysqlTable($newTableName);
		
		$newTable->applyColumnsFrom($this);
		$newTable->applyIndexesFrom($this);
		return $newTable;
	}
483807
public CmsDetailPageTable copy() {

        List<CmsDetailPageInfo> infos = toList();
        CmsDetailPageTable result = new CmsDetailPageTable();
        for (CmsDetailPageInfo info : infos) {
            result.add(info);
        }
        return result;
    }
1219601
public function create()
    {
        $sm = $this->em->getConnection()->getSchemaManager();
        $table = $this->em->getClassMetadata(self::$entityName)->getTableName();

        return $sm->tablesExist(array($table));
    }
939200
public TableColumn copyBox()
    {
        TableColumn ret = new TableColumn(el, g, ctx);
        ret.copyValues(this);
        return ret;
    }
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;
	}
462211
public Polygon copy() {
		float[] copyPoints = new float[points.length];
		System.arraycopy(points, 0, copyPoints, 0, copyPoints.length);
		
		return new Polygon(copyPoints);
	}
67951
public TableGenerator<OrmDescriptor> getOrCreateTableGenerator()
   {
      List<Node> nodeList = model.get("table-generator");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new TableGeneratorImpl<OrmDescriptor>(this, "table-generator", model, nodeList.get(0));
      }
      return createTableGenerator();
   }