Inserts a new row. No gap row is inserted  before this row.
433375
public TableLayoutBuilder row() {
        ++currentRow;
        lastCC = null;
        maxColumns = Math.max(maxColumns, currentCol);
        currentCol = 0;
        return this;
    }
336294
def insert(
            self, M_c, T, X_L_list, X_D_list, new_rows=None, N_GRID=31,
            CT_KERNEL=0):
        """"""
        if new_rows is None:
            raise ValueError("new_row must exist")

        if not isinstance(new_rows, list):
            raise TypeError('new_rows must be list of lists')
            if not isinstance(new_rows[0], list):
                raise TypeError('new_rows must be list of lists')

        X_L_list, X_D_list, was_multistate = su.ensure_multistate(
            X_L_list, X_D_list)

        # get insert arg tuples
        arg_tuples = self.get_insert_arg_tuples(
            M_c, T, X_L_list, X_D_list, new_rows, N_GRID, CT_KERNEL)

        chain_tuples = self.mapper(self.do_insert, arg_tuples)
        X_L_list, X_D_list = zip(*chain_tuples)

        if not was_multistate:
            X_L_list, X_D_list = X_L_list[0], X_D_list[0]

        T.extend(new_rows)
        ret_tuple = X_L_list, X_D_list, T
        return ret_tuple
990896
def add_row(self):
        
        tbl = self._tbl
        tr = tbl.add_tr()
        for gridCol in tbl.tblGrid.gridCol_lst:
            tc = tr.add_tc()
            tc.width = gridCol.w
        return _Row(tr, self)
815405
public void add( int row , int col , double value ) {
        if( col < 0 || col >= numCols || row < 0 || row >= numRows ) {
            throw new IllegalArgumentException("Specified element is out of bounds");
        }

        data[ row * numCols + col ] += value;
    }
1245114
public DataRow createRow() {
		DataRow row = new DataRow(columns);
		rows.add(row);
		return row;
	}
264599
void put(int row, int column, @NonNull TObj item) {
        SparseArrayCompat<TObj> array = mData.get(row);
        if (array == null) {
            array = new SparseArrayCompat<>();
            array.put(column, item);
            mData.put(row, array);
        } else {
            array.put(column, item);
        }
    }
543914
void insertRow(Session session, PersistentStore store, Object[] data) {

        setIdentityColumn(session, data);

        if (triggerLists[Trigger.INSERT_BEFORE].length != 0) {
            fireBeforeTriggers(session, Trigger.INSERT_BEFORE, null, data,
                               null);
        }

        if (isView) {
            return;
        }

        checkRowDataInsert(session, data);
        insertNoCheck(session, store, data);
    }
709712
void insertIntoTable(Session session, Result result) {

        PersistentStore store = session.sessionData.getRowStore(this);
        RowSetNavigator nav   = result.initialiseNavigator();

        while (nav.hasNext()) {
            Object[] data = nav.getNext();
            Object[] newData =
                (Object[]) ArrayUtil.resizeArrayIfDifferent(data,
                    getColumnCount());

            insertData(store, newData);
        }
    }
486532
def add_row(self, row_data, resize_x=True):
        """"""
        if not resize_x:
            self._check_row_size(row_data)
        self.body(Tr()(Td()(cell) for cell in row_data))
        return self
1052205
public void addRow(final String[] data) {
		if (anyStringContainsNewLine(data)) {
			final String[][] theMatrix = Util.createMatrix(data);
			for (int i = 0; i < theMatrix.length; i++) {
				addRow(theMatrix[i]);
			}
		} else {
			final Row myRow = new Row(this, data);
			rows.add(myRow);
		}

	}
1037083
def insert(self, row):
        
        self._check_dropped()
        res = self.engine.execute(self.table.insert(row))
        if len(res.inserted_primary_key) > 0:
            return res.inserted_primary_key[0]
718667
function insertRow($row, $row_id = 0) {
        array_splice($this->_data, $row_id, 0, array($row));

        $this->_updateRowsCols($row);
    }
1167512
public function insertRow($row): void {
        if ($this->connection === null) {
            throw new \RuntimeException('Copying already ended. Create a new object');
        }
        if (is_array($row)) {
            $row = $this->escape($row);
        }
        $wynik = @pg_put_line($this->connection, $row);
        if ($wynik === false) {
            throw new \RuntimeException('Failed to insert the row');
        }
    }
809984
def insert(self, rows):
        
        if len(rows) == 0:
            return

        sql, sql_args = self.get_insert_sql(rows)

        # get the cursor to execute the query
        cursor = self.get_cursor()

        # execute the query
        cursor.execute(sql, sql_args)
875363
private void addRow() {
    BloomFilter[] tmp = new BloomFilter[matrix.length + 1];

    for (int i = 0; i < matrix.length; i++) {
      tmp[i] = matrix[i];
    }

    tmp[tmp.length-1] = new BloomFilter(vectorSize, nbHash, hashType);

    matrix = tmp;
  }
646317
public RowIndexEntry tryAppend(AbstractCompactedRow row)
    {
        writer.mark();
        try
        {
            return append(row);
        }
        catch (Throwable t)
        {
            writer.resetAndTruncate();
            throw t;
        }
    }
584733
public final void add(VoltTableRow row) {
        assert(verifyTableInvariants());
        if (m_readOnly) {
            throw new IllegalStateException("Table is read-only. Make a copy before changing.");
        }
        if (m_colCount == 0) {
            throw new IllegalStateException("Table has no columns defined");
        }
        if (row.getColumnCount() != m_colCount) {
            throw new IllegalArgumentException(row.getColumnCount() + " arguments but table has " + m_colCount + " columns");
        }

        // memoize the start of this row in case we roll back
        final int pos = m_buffer.position();

        try {
            // Allow the buffer to grow to max capacity
            m_buffer.limit(m_buffer.capacity());

            byte[] inboundSchemaString = row.getSchemaString();
            byte[] mySchemaString = getSchemaString();

            // The way this works is that when two schema strings are found to have
            // the same value, the target table's reference is pointed at the source
            // table's reference. This allows the copying of multiple rows from one
            // table to another to only do a deep comparison once, and to do reference
            // equivalence checks for subsequent rows.
            boolean canDoRawCopy = (inboundSchemaString == mySchemaString) ||
                    Arrays.equals(inboundSchemaString, mySchemaString);

            if (canDoRawCopy) {
                // make them the same object if equal for faster comparison next time
                m_schemaString = inboundSchemaString;

                // raw blit the row (assume the row is valid with proper length)
                ByteBuffer rawRow = row.getRawRow();
                m_buffer.put(rawRow);
            }
            else {
                // advance the row size value
                m_buffer.position(pos + 4);

                for (int i = 0; i < m_colCount; i++) {
                    VoltType inboundType = row.getColumnType(i);
                    VoltType outboundType = getColumnType(i);

                    if (inboundType == outboundType) {
                        byte[] raw = row.getRaw(i);
                        m_buffer.put(raw);
                    }
                    else {
                        Object inboundValue = row.get(i, inboundType);
                        addColumnValue(inboundValue, outboundType, i);
                    }
                }

                final int rowsize = m_buffer.position() - pos - 4;
                assert(rowsize >= 0);

                // check for too big rows
                if (rowsize > VoltTableRow.MAX_TUPLE_LENGTH) {
                    throw new VoltOverflowException(
                            "Table row total length larger than allowed max " + VoltTableRow.MAX_TUPLE_LENGTH_STR);
                }

                // buffer overflow is caught and handled below.
                m_buffer.putInt(pos, rowsize);
            }

            // constrain buffer limit back to the new position
            m_buffer.limit(m_buffer.position());

            // increment the rowcount in the member var and in the buffer
            m_rowCount++;
            m_buffer.putInt(m_rowStart, m_rowCount);
        }
        catch (VoltTypeException vte) {
            // revert the row size advance and any other
            // buffer additions
            m_buffer.position(pos);
            throw vte;
        }
        catch (BufferOverflowException e) {
            m_buffer.position(pos);
            expandBuffer();
            add(row);
        }
        // row was too big, reset and rethrow
        catch (VoltOverflowException e) {
            m_buffer.position(pos);
            throw e;
        }
        catch (IllegalArgumentException e) {
            // if this was thrown because of a lack of space
            // then grow the buffer
            // the number 32 was picked out of a hat ( maybe a bug if str > 32 )
            if (m_buffer.limit() - m_buffer.position() < 32) {
                m_buffer.position(pos);
                expandBuffer();
                add(row);
            } else {
                throw e;
            }
        }
        assert(verifyTableInvariants());
    }