Grow the tables.
195745
private void growTable() {

        final int oldLength      = states.length;
        final int[] oldKeys      = keys;
        final float[] oldValues = values;
        final byte[] oldStates   = states;

        final int newLength = RESIZE_MULTIPLIER * oldLength;
        final int[] newKeys = new int[newLength];
        final float[] newValues = new float[newLength];
        final byte[] newStates = new byte[newLength];
        final int newMask = newLength - 1;
        for (int i = 0; i < oldLength; ++i) {
            if (oldStates[i] == FULL) {
                final int key = oldKeys[i];
                final int index = findInsertionIndex(newKeys, newStates, key, newMask);
                newKeys[index]   = key;
                newValues[index] = oldValues[i];
                newStates[index] = FULL;
            }
        }

        mask   = newMask;
        keys   = newKeys;
        values = newValues;
        states = newStates;

    }
881706
public void newColumns()
    {
        column = new Table(0);
        columns = 1;
        table.newRow();
        table.addCell(column);
        table.cell().top();
    }
143039
def _create_table(self):
        '''
        
        '''
        self._cursor.execute('''
            CREATE TABLE IF NOT EXISTS %(name)s ( %(fields)s )
        ''' % {
            'name': self._name,
            'fields': ','.join('%s %s' % (k, v) for (k, v) in self._fields)
        })
        self._connection.commit()
1219049
public T grow() {
		if( size >= data.length) {
			T a = createInstance();
			add(a);
			return a;
		} else {
			T a = data[(start+size)%data.length];
			if( a == null ) {
				data[(start+size)%data.length] = a = createInstance();
			}
			size++;
			return a;
		}
	}
1001729
public function grow(Labeled $dataset) : void
    {
        $this->root = Coordinate::split($dataset);

        $stack = [$this->root];

        while ($stack) {
            $current = array_pop($stack);

            if (!$current instanceof Coordinate) {
                continue 1;
            }

            [$left, $right] = $current->groups();

            if ($left->numRows() > $this->maxLeafSize) {
                $node = Coordinate::split($left);
    
                $current->attachLeft($node);

                $stack[] = $node;
            } else {
                $current->attachLeft(Neighborhood::terminate($left));
            }
    
            if ($right->numRows() > $this->maxLeafSize) {
                $node = Coordinate::split($right);
    
                $current->attachRight($node);

                $stack[] = $node;
            } else {
                $current->attachRight(Neighborhood::terminate($right));
            }

            $current->cleanup();
        }
    }
727231
private void grow() {
        final Activation[] elements = new Activation[this.elements.length * 2];
        System.arraycopy( this.elements,
                          0,
                          elements,
                          0,
                          this.elements.length );
        this.elements = elements;
    }
848278
void grow(int neededSize) {
    if (neededSize < 0) {
      throw new IllegalArgumentException(
        "Cannot grow BufferHolder by size " + neededSize + " because the size is negative");
    }
    if (neededSize > ARRAY_MAX - totalSize()) {
      throw new IllegalArgumentException(
        "Cannot grow BufferHolder by size " + neededSize + " because the size after growing " +
          "exceeds size limitation " + ARRAY_MAX);
    }
    final int length = totalSize() + neededSize;
    if (buffer.length < length) {
      // This will not happen frequently, because the buffer is re-used.
      int newLength = length < ARRAY_MAX / 2 ? length * 2 : ARRAY_MAX;
      int roundedSize = ByteArrayMethods.roundNumberOfBytesToNearestWord(newLength);
      final byte[] tmp = new byte[roundedSize];
      Platform.copyMemory(
        buffer,
        Platform.BYTE_ARRAY_OFFSET,
        tmp,
        Platform.BYTE_ARRAY_OFFSET,
        totalSize());
      buffer = tmp;
      row.pointTo(buffer, buffer.length);
    }
  }
975582
protected function processTables()
	{
		foreach ($this->tables as $table)
		{
			$this->table = $table;
			$this->processCurrentTable();
		}
	}
623147
def create(self):
        """"""

        if not self.exists():
            self._create_path()
            self.create_tables()
            return True

        return False
1153290
def advance(self, height, ignore_overflow=False):
        """"""
        if height <= self.remaining_height:
            self._self_cursor.grow(height)
        elif ignore_overflow:
            self._self_cursor.grow(float(self.remaining_height))
        else:
            raise ContainerOverflow(self.page.number)
982607
protected void growAtomContainerArray() {
        growArraySize = atomContainers.length;
        IAtomContainer[] newatomContainers = new IAtomContainer[atomContainers.length + growArraySize];
        System.arraycopy(atomContainers, 0, newatomContainers, 0, atomContainers.length);
        atomContainers = newatomContainers;
        Double[] newMultipliers = new Double[multipliers.length + growArraySize];
        System.arraycopy(multipliers, 0, newMultipliers, 0, multipliers.length);
        multipliers = newMultipliers;
    }
415266
def set_table(self, table):
        
        super(MultiField, self).set_table(table)
        if self.field and self.field.table is None:
            self.field.set_table(self.table)
893226
def resizeColumnsToContents(self):
        """"""
        self._autosized_cols = set()
        self._resizeColumnsToContents(self.table_level,
                                      self.table_index, self._max_autosize_ms)
        self._update_layout()
1124783
private void growReactionArray() {
        growArraySize = reactions.length;
        IReaction[] newreactions = new IReaction[reactions.length + growArraySize];
        System.arraycopy(reactions, 0, newreactions, 0, reactions.length);
        reactions = newreactions;
    }
854095
private final void growIfNeeded(int minimumDesired) {
        if (buffer.b().remaining() < minimumDesired) {
            // Compute the size of the new buffer
            int newCapacity = buffer.b().capacity();
            int newRemaining = newCapacity - buffer.b().position();
            while (newRemaining < minimumDesired) {
                newRemaining += newCapacity;
                newCapacity *= 2;
            }

            // Allocate and copy
            BBContainer next;
            if (isDirect) {
                next = DBBPool.allocateDirect(newCapacity);
            } else {
                next = DBBPool.wrapBB(ByteBuffer.allocate(newCapacity));
            }
            buffer.b().flip();
            next.b().put(buffer.b());
            assert next.b().remaining() == newRemaining;
            buffer.discard();
            buffer = next;
            if (callback != null) callback.onBufferGrow(this);
            assert(buffer.b().order() == ByteOrder.BIG_ENDIAN);
        }
    }
1271506
private void grow() {
        /* Double the size of the topmost array. */
        T[][] newArrays = (T[][]) new Object[mArrays.length * 2][];

        /* The new arrays each have size 2^(n + 1).  We need 2^(n - 1) of them
         * to hold the old elements.  Allocate those here and copy everything
         * over.
         */
        for (int i = 0; i < mArrays.length; i += 2) {
            /* Allocate the array. */
            newArrays[i / 2] = (T[]) new Object[newArrays.length];

            /* Use System.arraycopy to move everything over. */
            System.arraycopy(mArrays[i], 0, newArrays[i / 2], 0, mArrays.length);
            System.arraycopy(mArrays[i + 1], 0, newArrays[i / 2], mArrays.length, mArrays.length);

            /* Null out the old arrays to be nice to the GC during this
             * potentially stressful time.
             */
            mArrays[i] = mArrays[i + 1] = null;
        }

        /* Switch out this new array for the old. */
        mArrays = newArrays;

        /* Bump up lg2 of the size. */
        ++mLgSize;
    }
113770
def create_all_tables(self):
        """"""
        for klass in self.__get_classes():
            if not klass.exists():
                klass.create_table(read_capacity_units=1, write_capacity_units=1, wait=True)