Use with care. Removes all content of all tables. Should only
be used for JUnit tests.
512843
public void clear() {
		List<AbstractTable<?>> tableList = new ArrayList<AbstractTable<?>>(tables.values());
		for (AbstractTable<?> table : tableList) {
			table.clear();
		}
	}
1369307
private synchronized void removeResultTable(){
		OWLResultSetTableModel tm = getTableModel();
		if (tm != null){
			tm.close();
		}
		resultTablePanel.setTableModel(new DefaultTableModel());
	}
547029
public void free()
    {
        if (m_PDatabase != null)
            m_PDatabase.removePTable(this);
        m_PDatabase = null;

        if (m_VKeyList != null)
        {
            for (int i = m_VKeyList.size() - 1 ; i >= 0 ;i--) {
                PKeyArea vKeyArea = (PKeyArea)m_VKeyList.elementAt(i);
                vKeyArea.free();
            } 
            m_VKeyList.removeAllElements();
        }
        m_VKeyList = null;
        
        if (m_setPTableOwners != null)
        {
            for (ThinPhysicalTableOwner owner : m_setPTableOwners)
            {
                this.removePTableOwner(owner, false);
            }
        }
    }
728791
@Override
	public void tearDownOperation() throws SQLException {
		Statement statement = null;

		try {
		    Connection connection = getConnection();
		    
			statement = connection.createStatement();
			

			disableReferentialIntegrity(statement);
			List<String> tableNames = getTableNames(getConnection());

			deleteContent(tableNames, statement);

		} catch (SQLException e) {
			LOG.error(e.getMessage(), e);
			try {
				rollback();
			} catch (SQLException e1) {
				LOG.error(e1.getMessage(), e1);
			}
		} finally {
			try {
				enableReferentialIntegrity(statement);

				if (statement != null) {
					statement.close();
				}
				commit();

				closeConnection();
			} catch (Exception e) {
			    rollback();
				LOG.error(e.getMessage(), e);
			}
		}

	}
316227
public void clear() {
		names.clear();
		values = null;
		valueType.clear();
		args.clear();
		whereArgs.clear();
		compiledStatement = null;
		compiledStatementBindIndex = 1;

	}
876816
def tear_down(self):
        
        # drop/delete the tables
        logger.info('resetting database...')
        BASE.metadata.drop_all(self.engine)
        return self
91358
public void cleanUp() {
    m_Owner     = null;
    m_Train     = null;
    m_Test      = null;
    m_Generator = null;
    m_Values    = null;
  }
1288495
public function deleteAllDocumentTables()
    {
        foreach ($this->metadataFactory->getAllMetadata() as $class) {
            if ($class->isMappedSuperclass || $class->isEmbeddedDocument || (count($class->parentClassNames) && $class->inheritanceType == ClassMetadata::INHERITANCE_TYPE_SINGLE_TABLE)) {
                continue;
            }

            $this->deleteDocumentTableFor($class->name);
        }
    }
842168
private void cleanup() {
        Entry<K, V>[] tab = this.table;

        for (int i = tab.length ; i-- > 0 ;) {
            for (Entry<K, V> e = tab[i], prev = null; e != null; e = e.next) {
                if (e.get() == null) {
                    // Clean up after a cleared Reference.
                    this.modCount++;
                    if (prev != null) {
                        prev.next = e.next;
                    } else {
                        tab[i] = e.next;
                    }
                    this.count--;
                } else {
                    prev = e;
                }
            }
        }
    }
868641
def teardown(self):
        """"""
        for table_spec in reversed(self._table_specs):
            with self._conn:
                table_spec.teardown(self._conn)
43241
def drop_all_tables(self):
        """"""
        for table_name in self.table_names():
            self.execute_sql("DROP TABLE %s" % table_name)
        self.connection.commit()
803644
private void cleanUpContentsTables(CmsSetupDb dbCon) throws SQLException {

        System.out.println(new Exception().getStackTrace()[0].toString());
        String query = readQuery(QUERY_DROP_TABLE);
        HashMap<String, String> replacers = new HashMap<String, String>();
        // Drop the CMS_ONLINE_CONTENTS table
        replacers.put(REPLACEMENT_TABLENAME, TABLE_CMS_ONLINE_CONTENTS);
        dbCon.updateSqlStatement(query, replacers, null);

        replacers.clear();
        // Drop the CMS_BACKUP_CONTENTS table
        replacers.put(REPLACEMENT_TABLENAME, TABLE_CMS_BACKUP_CONTENTS);
        dbCon.updateSqlStatement(query, replacers, null);
    }
1188808
public function deleteAll() {

        $tablenames = $this->getAllTableNames();
        foreach ($tablenames as $tablename) {
            $this->databaseConnection->query("DROP TABLE " . $tablename);
        }

    }
19069
public function deleteAllGeneratorTables()
    {
        $tables = [];

        /**
         * @var ClassMetadata $class
         */
        foreach ($this->metadataFactory->getAllMetadata() as $class) {
            $tables = array_merge(
                $tables,
                $this->getGeneratorTablesFor($class)
            );
        }

        foreach ($tables as $tableName => $definition) {
            $this->doDeleteTable($tableName, $definition);
        }
    }
657669
public void clear() {
      NonSyncHashtableEntry tab[] = table;
      for (int index = tab.length; --index >= 0;) {
         tab[index] = null;
      }
      count = 0;
   }
84069
public function removeAll() {
    $storage = $this->entityTypeManager->getStorage('openy_pef_gxp_mapping');

    $query = $storage->getQuery('openy_pef_gxp_mapping');
    $ids = $query->execute();
    if (!$ids) {
      return;
    }

    $this->removeByChunk($ids);
  }
1131303
public void clear() {
	new ByteArrayList(this.state).fillFromToWith(0, this.state.length-1, FREE);
   	new ObjectArrayList(values).fillFromToWith(0, state.length-1, null); // delta

	this.distinct = 0;
	this.freeEntries = table.length; // delta
	trimToSize();
}