Free the remote table.
491940
public void freeRemoteSession() throws RemoteException
    {
        if (m_tableRemote != null)
            m_tableRemote.freeRemoteSession();
        m_tableRemote = null;
        m_mapCache = null;
        m_htCache = null;
    }
965154
public void free()
    {
        if (m_databaseFake != null)
            m_databaseFake.free();
        m_databaseFake = null;
        if (m_taskFake != null)
            m_taskFake.free();
        m_taskFake = null;
        m_sharedTable = null;
        super.free();
    }
1031878
public function free()
    {

        switch ($this->mode) {

            case "mysql":
                $this->result->free();
                break;

            case "postgres":
            case "redshift":
                pg_free_result($this->result);
                break;

            case "odbc":
                odbc_free_result($this->result);
                break;

            case "sqlite":
                $this->result->finalize();
                break;

            case "mssql":
                mssql_free_result($this->result);
                break;

            case "mssqlsrv":
                sqlsrv_free_stmt($this->result);
                break;
        }
    }
1294396
def close(self):
        
        if self.lock_on_connect or self.locked:
            self.unlock()  # this refers to the config DB
        self._unlock_xml_agent()  # this refers to the XML agent
        if hasattr(self.device, 'remote_conn'):
            self.device.remote_conn.close()
115869
def clear(self):
        """"""
        with self._connection as con:
            con.execute("DELETE FROM {};".format(self.table))
1223670
def drop(self):
        
        if self._is_dropped is False:
            self.table.drop(self.engine)
        self._is_dropped = True
56296
public function cleanup()
    {
        $this->db->beginTransaction();

        // drop tables
        $rslt = $this->db->query( "SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename NOT LIKE 'pg_%'" );
        $rslt->setFetchMode( PDO::FETCH_NUM );
        $rows = $rslt->fetchAll();
        unset( $rslt );
        foreach ( $rows as $row )
        {
            $table = $row[0];
            $this->db->exec( "DROP TABLE $table" );
        }

        // drop sequences
        $rslt = $this->db->query( "SELECT relname FROM pg_catalog.pg_class WHERE relkind='S'" );
        $rslt->setFetchMode( PDO::FETCH_NUM );
        $rows = $rslt->fetchAll();
        foreach ( $rows as $row )
        {
            $seq = $row[0];
            $this->db->exec( "DROP SEQUENCE $seq" );
        }

        // FIXME: drop triggers?

        $this->db->commit();
    }
1050867
public void free()
    {
        super.free();
        try
        {
            if (this.getHandle(DBConstants.DATA_SOURCE_HANDLE) != null)
                ((BaseBuffer)this.getHandle(DBConstants.DATA_SOURCE_HANDLE)).free();
        } catch (DBException ex)    {
            // Never
        }
        if (m_pTable != null)
            m_pTable.removePTableOwner(this, true);      // Free or decrement the use count of the physical table
        m_pTable = null;
    }
1087081
public void free()
    {
        super.free();
        if (m_gridTable != null)
        {
            m_gridTable.close();
            m_gridTable.free();     // If this file doesn't have a sceen, close it
            m_gridTable = null;
        }
    }
1347210
def hide(self):
        """"""
        self.tk.withdraw()
        self._visible = False
        if self._modal:
            self.tk.grab_release()
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);
            }
        }
    }
42735
def teardown(self):
        ''''''

        for device in self.devices:
            self._remove_trustee(device)
            self._populate_domain()
        self.domain = {}
275089
async def reset_all(self):
        
        async with self.connection() as conn:
            await r.table(self._table).delete().run(conn)
955538
public void free()
    {
        this.setPDatabaseParent(null); // Remove from database
        
        Object[] keys = m_htTableList.keySet().toArray();
        for (int i = 0; i < keys.length; i++)
        { 
            Object key = keys[i];
            PTable pTable = m_htTableList.get(key);
            if (pTable != null)
                pTable.free();      // This can be dangerous if the PhysicalTables still have references to the PTables
        } 
        m_htTableList.clear();
        m_htTableList = null;
        this.close();
    }
1047538
def removeRemote(self, remote: Remote, clear=True):
        
        name = remote.name
        pkey = remote.publicKey
        vkey = remote.verKey
        if name in self.remotes:
            self.remotes.pop(name)
            self.remotesByKeys.pop(pkey, None)
            self.verifiers.pop(vkey, None)
        else:
            logger.info('No remote named {} present')
115362
def drop(self, ex):
    ""
    # todo: factor out inheritance logic (for readability)
    if ex.name not in self:
      if ex.ifexists: return
      raise KeyError(ex.name)
    table_ = self[ex.name]
    parent = table_.parent_table
    if table_.child_tables:
      if not ex.cascade:
        raise table.IntegrityError('delete_parent_without_cascade',ex.name)
      self.cascade_delete(ex.name)
    else: del self[ex.name]
    if parent: parent.child_tables.remove(table_)
1247756
async def stop(self):
        """"""
        await self._command_task.future_command(['_set_mode', 0, 0])  # Disable advertising
        await self._cleanup_old_connections()

        self._command_task.stop()
        self._stream.stop()
        self._serial_port.close()

        await super(BLED112Server, self).stop()