Parameters:
     - login
     - tableName
     - startRow
     - endRow
     - iterators
     - flush
     - wait
14495
def compactTable(self, login, tableName, startRow, endRow, iterators, flush, wait):
    
    self.send_compactTable(login, tableName, startRow, endRow, iterators, flush, wait)
    self.recv_compactTable()
955751
private void waitOnLock() throws PSQLException {
    while (lockedFor != null) {
      try {
        this.wait();
      } catch (InterruptedException ie) {
        Thread.currentThread().interrupt();
        throw new PSQLException(
            GT.tr("Interrupted while waiting to obtain lock on database connection"),
            PSQLState.OBJECT_NOT_IN_STATE, ie);
      }
    }
  }
496483
def flush(bank, key=None):
    '''
    
    '''
    _init_client()
    query = "DELETE FROM {0} WHERE bank='{1}'".format(_table_name, bank)
    if key is not None:
        query += " AND etcd_key='{0}'".format(key)

    cur, _ = run_query(client, query)
    cur.close()
184649
def sql_flush(self, style, tables, sequences, allow_cascade=False):
        

        for table in tables:
            qs = "TRUNCATE {}".format(table)
            self.connection.connection.execute(qs)

        return []
644947
public synchronized void waitForData() {
        while (this.flushers.isEmpty() && this.isNotStopped()) {
            try {
                this.wait();
            } catch (final InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
        }
    }
721812
public void flushRows(final XMLUtil util, final ZipUTF8Writer writer,
                          final SettingsElement settingsElement) throws IOException {
        this.ensureContentBegin(util, writer);
        final int lastTableIndex = this.tables.size() - 1;
        if (lastTableIndex == -1) return;

        int tableIndex = this.flushPosition.getTableIndex();
        Table table = this.tables.get(tableIndex);
        if (tableIndex < lastTableIndex) {
            table.flushRemainingRowsFrom(util, writer, this.flushPosition.getLastRowIndex() + 1);
            settingsElement.addTableConfig(table.getConfigEntry());
            tableIndex++;
            while (tableIndex < lastTableIndex) {
                table = this.tables.get(tableIndex);
                table.appendXMLToContentEntry(util, writer);
                settingsElement.addTableConfig(table.getConfigEntry());
                tableIndex++;
            }
            table = this.tables.get(lastTableIndex);
            table.flushAllAvailableRows(util, writer);
        } else {
            table.flushSomeAvailableRowsFrom(util, writer, this.flushPosition.getLastRowIndex() + 1);
        }
        this.flushPosition.set(lastTableIndex, this.tables.get(lastTableIndex).getLastRowNumber());
    }
526649
def start_output (self):
        
        super(SQLLogger, self).start_output()
        if self.has_part("intro"):
            self.write_intro()
            self.writeln()
            self.flush()
928296
function endFetchRows(options, statement, context)
{
  options.end(Errors.externalize(context.resultError), statement);
}
14886
function start(callback) {
  let handle = {close(){server.close()}}
  check(function _check(err, inUse) {
    if (err) throw err
    if (inUse) {
      server = {close(){}}
      init(callback)
    }
    else {
      server = dynalite({
        createTableMs: 0
      }).listen(5000, function _server(err) {
        if (err) {
          // if we err then the db has been started elsewhere..
          // just try to continue
          console.log(err)
        }
        init(callback)
      })
    }
  })
  return handle
}
1065253
def getIteratorSetting(self, login, tableName, iteratorName, scope):
    
    self.send_getIteratorSetting(login, tableName, iteratorName, scope)
    return self.recv_getIteratorSetting()
388713
public synchronized void waitForStart()
	throws ServerException,
	       ClientException,
	       IOException {
	    try {
	        while(!isStarted() && !hasError()) {
		        wait();
	        }
	    } catch(InterruptedException e) {
            // break
	    }
	    checkError();
    }
68310
def wait_until_exit(self):
        
        [t.join() for t in self.threads]

        self.threads = list()
166267
def _buffer_iter_rows(self, start):
        
        self._row_buffer = self[start:start+self._iter_row_buffer]

        # start back at the front of the buffer
        self._row_buffer_index = 0
600706
function(transaction, results) {
    if (ydn.db.core.req.CachedWebsqlCursor.DEBUG) {
      goog.global.console.log([sql, results]);
    }
    me.has_pending_request = false;
    me.cursor_ = results;
    me.current_cursor_index_ = 0;
    if (!!me.index_name && goog.isDefAndNotNull(ini_key)) {
      // skip them
      var cmp = ydn.db.cmp(me.getPrimaryKey(), ini_key);
      while (cmp == -1 || (cmp == 0 && exclusive)) {
        me.current_cursor_index_++;
        cmp = ydn.db.cmp(me.getPrimaryKey(), ini_key);
      }
    }
    me.onSuccess(me.getPrimaryKey(), me.getIndexKey(), me.getValue());
  }
550996
function checkTable(count) {
      // Make sure we don't go into an infinite loop
      if (++count > 1000) return cb(new Error('Wait limit exceeded'))

      self.describeTable(function(err, data) {
        if (err) return cb(err)
        if (data.TableStatus !== 'ACTIVE' || (data.GlobalSecondaryIndexes &&
            !data.GlobalSecondaryIndexes.every(function (idx) {return idx.IndexStatus === 'ACTIVE'}))) {
          return setTimeout(checkTable, 1000, count)
        }

        // If the table is ACTIVE then return
        cb(null, data)
      })
    }
1308486
async def fetchrow(self, *, timeout=None):
        
        """
        self._check_ready()
        if self._exhausted:
            return None
        recs = await self._exec(1, timeout)
        if len(recs) < 1:
            self._exhausted = True
            return None
        return recs[0]
801930
def wait_to_end(self, pids=[]):
        '''
        

        '''
        actual_pids = self._get_pids(pids)
        return self.wait_for(pids=actual_pids, status_list=process_result_statuses)