Get the SQL to drop all the tables (DDL).
@return The SQL drop statements.
189811
protected List<String> getDropTablesSQL() {
        List<String> sqlStatements = new ArrayList<>();
        sqlStatements.add(DROP_SETTINGS_TABLE);
        sqlStatements.add(DROP_HEADERS_TABLE);
        sqlStatements.add(DROP_UNDOABLE_TABLE);
        sqlStatements.add(DROP_OPEN_OUTPUT_TABLE);
        return sqlStatements;
    }
415357
public List<SqlResultSetMapping<OrmDescriptor>> getAllSqlResultSetMapping()
   {
      List<SqlResultSetMapping<OrmDescriptor>> list = new ArrayList<SqlResultSetMapping<OrmDescriptor>>();
      List<Node> nodeList = model.get("sql-result-set-mapping");
      for(Node node: nodeList)
      {
         SqlResultSetMapping<OrmDescriptor>  type = new SqlResultSetMappingImpl<OrmDescriptor>(this, "sql-result-set-mapping", model, node);
         list.add(type);
      }
      return list;
   }
475141
public List<Statement> getAllStatements() {
        List<Statement> ret = new ArrayList<Statement>();

        // Statements within this group
        if (statements != null) {
            ret.addAll(statements);
        }

        // Statements within nested statement groups
        if (statementGroups != null) {
            for (final StatementGroup sg : statementGroups)
                ret.addAll(sg.getAllStatements());
        }

        return ret;
    }
1190731
public boolean dropTriggers(String tableName, String columnName) {
		boolean dropped = has(tableName, columnName);
		if (dropped) {
			dropAllTriggers(tableName, columnName);
		}
		return dropped;
	}
1332
public boolean dropTableIfExists(final String tableName) {
        Connection conn = getConnection();

        try {
            return JdbcUtil.dropTableIfExists(conn, tableName);
        } finally {
            closeQuietly(conn);
        }
    }
932967
public function drop()
        {
            $sql = $this->generateDropSql();
            try {
                $query = new RawQuery($sql);
                $statement = Statement::getPreparedStatement($query);
                return $statement->execute();
            } catch (\Exception $e) {
                throw new Exception('Error dropping table ' . $this->getB2DBName() . ': ' . $e->getMessage(), $sql);
            }
        }
573104
private static <T, ID> void addDropTableStatements(DatabaseType databaseType, TableInfo<T, ID> tableInfo,
			List<String> statements, boolean logDetails) {
		List<String> statementsBefore = new ArrayList<String>();
		List<String> statementsAfter = new ArrayList<String>();
		for (FieldType fieldType : tableInfo.getFieldTypes()) {
			databaseType.dropColumnArg(fieldType, statementsBefore, statementsAfter);
		}
		StringBuilder sb = new StringBuilder(64);
		if (logDetails) {
			logger.info("dropping table '{}'", tableInfo.getTableName());
		}
		sb.append("DROP TABLE ");
		databaseType.appendEscapedEntityName(sb, tableInfo.getTableName());
		sb.append(' ');
		statements.addAll(statementsBefore);
		statements.add(sb.toString());
		statements.addAll(statementsAfter);
	}
103087
public function dropColumn() {
        $columns = func_get_args();
        foreach ($columns as $column) {
            $this->set($column);
        }
        return $this->command()->execute($this->getDropColumnSql());
    }
1027970
public function dropDatabase()
    {
        $dropSchemaSql = $this->getDropDatabaseSQL();
        $conn          = $this->em->getConnection();

        foreach ($dropSchemaSql as $sql) {
            $conn->executeQuery($sql);
        }
    }
1104945
public function getTableList()
	{
		$this->connect();

		// Set the query to get the tables statement.
		$this->setQuery('SELECT name FROM ' . $this->getDatabase() . '.sys.Tables WHERE type = \'U\';');
		$tables = $this->loadColumn();

		return $tables;
	}
381124
protected function dropTables()
    {
        $tables = $this->db->query(
            'SHOW FULL TABLES WHERE TABLE_TYPE LIKE "BASE_TABLE"',
            DbAdapter::QUERY_MODE_EXECUTE
        );

        // Disable foreign key checks -- we are wiping the database on purpose
        $this->db->query(
            'SET FOREIGN_KEY_CHECKS = 0',
            DbAdapter::QUERY_MODE_EXECUTE
        );

        foreach ($tables as $table) {
            $this->db->query(
                'DROP TABLE '.reset($table),
                DbAdapter::QUERY_MODE_EXECUTE
            );
        }

        // Re-enable foreign key checks
        $this->db->query(
            'SET FOREIGN_KEY_CHECKS = 1',
            DbAdapter::QUERY_MODE_EXECUTE
        );
    }
78488
public Collection<String> listTables() throws SQLException {

	Collection<String> result = new ArrayList<String>();
	DatabaseMetaData dbm = connection.getMetaData();
	String types[] = { "TABLE" };
	ResultSet rs = dbm.getTables(null, null, "", types);
	while (rs.next()) {
	    String str = rs.getString("TABLE_NAME");
	    result.add(str);
	}
	return result;
    }
1243226
@Override
	public List<String> getSqlPathList() {
		List<String> list = Collections.list(this.sqlInfos.keys());
		Collections.sort(list);
		return list;
	}
1335791
public int deleteAll() throws SQLException {

		DeleteBuilder<Extensions, Void> db = deleteBuilder();
		int deleted = db.delete();

		return deleted;
	}
1163283
public function drop()
    {

        static::valTable();
        $sql = /** @lang text */
            "DROP TABLE " . self::$table;
        try {
            $this->exec($sql);
            static::$response["status"] = "success";
            static::$response["response"] = "success";
            return self::terminate(static::$response);

        } catch (Exception $e) {
            static::$response["status"] = "error";
            static::$response["response"] = $e->getMessage();
            static::$response["code"] = $e->getCode();
            return static::terminate(static::$response);
        }

    }
1371292
public java.util.List<DBInstanceAutomatedBackup> getDBInstanceAutomatedBackups() {
        if (dBInstanceAutomatedBackups == null) {
            dBInstanceAutomatedBackups = new com.amazonaws.internal.SdkInternalList<DBInstanceAutomatedBackup>();
        }
        return dBInstanceAutomatedBackups;
    }
435155
public Set<String> getInvokedTables() throws ParseException {

	// Read all SQL statements from input
	ZStatement st;
	Set<String> tables = new HashSet<String>();

	while ((st = parser.readStatement()) != null) {
	    this.sql = st.toString();
	    if (st instanceof ZQuery) { // An SQL query: query the DB
		getInvokedTables((ZQuery) st, tables);
	    }
	    break;
	}
	return tables;
    }