MaxCompute功能与应用-Toy模板网

这篇具有很好参考价值的文章主要介绍了MaxCompute功能与应用。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

MaxCompute 是面向分析的企业级 SaaS 模式云数据仓库，以 Serverless 架构提供快速、全托管的在线数据仓库服务，消除了传统数据平台在资源扩展性和弹性方面的限制，最小化用户运维投入，使您可以经济并高效的分析处理海量数据。数以万计的企业正基于 MaxCompute 进行数据计算与分析，将数据高效转换为业务洞察。

功能

全托管的 Serverless 在线服务对外以API方式访问的在线服务，开箱即用；预铺设的大规模集群资源，按需使用和付费；无需平台运维，最小化运维投入。

弹性能力与扩展性存储和计算独立扩展，支持企业将全部数据资产在一个平台上进行联动分析，消除数据孤岛；实时根据业务峰谷变化来分配资源。

统一丰富的计算和存储能力多计算模型（MR，DAG，SQL，ML）和丰富的UDF，采用列压缩存储格式，通常情况下具备5倍压缩能力，大幅节省存储成本。

与 DataWorks 原生集成一站式数据开发与治理平台DataWorks，可实现全域数据汇聚、融合加工和治理，支持对MaxCompute项目进行管理以及web端查询编辑。

集成 AI 能力与机器学习平台PAI无缝集成，提供强大的机器学习处理能力；用户可使用熟悉的Spark-ML开展智能分析；使用Python机器学习三方库。

深度集成 Spark 引擎内建Apache Spark引擎，提供完整的Spark功能；与MaxCompute计算资源、数据和权限体系深度集成。

湖仓一体集成对数据湖（OSS或Hadoop HDFS）的访问分析，支持外表映射、Spark直接访问方式开展数据湖分析；在一套数仓服务和用户接口下，实现湖与仓的关联分析。

支持流式采集和近实时分析支持流式数据实时写入并在数据仓库中开展分析；与云上主要流式服务深度集成，轻松接入各种来源流式数据；高性能秒级弹性并发查询，满足近实时分析场景需求。

提供持续的SaaS化云上数据保护为云上企业提供从基础设施、数据中心、网络、供电到平台安全能力，再到用户权限管理、隐私保护等三级超20项安全功能，兼具开源大数据与托管数据库的安全能力。

数据存储

支持大规模计算存储，适用于TB以上规模的存储及计算需求，最大可达EB级别。同一个MaxCompute项目支持企业从创业团队发展到独角兽的数据规模需求；
数据分布式存储，多副本冗余，数据存储对外仅开放表的操作接口，不提供文件系统访问接口
自研数据存储结构，表数据列式存储，默认高度压缩，后续将提供兼容ORC的Ali-ORC存储格式
支持外表，将存储在OSS对象存储、OTS表格存储的数据映射为二维表
支持Partition、Bucket的分区、分桶存储
更底层不是HDFS，是阿里自研的盘古文件系统，但可借助HDFS理解对应的表之下文件的体系结构、任务并发机制
使用时，存储与计算解耦，不需要仅仅为了存储扩大不必要的计算资源

多种计算模型

需要说明的是，传统数据仓库场景下，实践中有大部分的数据分析需求可以通过SQL+UDF来完成。但随着企业对数据价值的重视以及更多不同的角色开始使用数据时，企业也会要求有更丰富的计算功能来满足不同场景、不同用户的需求。

MaxCompute不仅仅提供SQL数据分析语言，它在统一的数据存储和权限体系之上，支持了多种计算类型。

MaxCompute SQL:

TPC-DS 100% 支持，同时语法高度兼容Hive，有Hive背景开发者直接上手，特别在大数据规模下性能强大。

完全自主开发的compiler，语言功能开发更灵活，迭代快，语法语义检查更加灵活高效
基于代价的优化器，更智能，更强大，更适合复杂的查询
基于LLVM的代码生成，让执行过程更高效
支持复杂数据类型(array,map,struct)
支持Java、Python语言的UDF/UDAF/UDTF
语法：Values、CTE、SEMIJOIN、FROM倒装、Subquery Operations、Set Operations(UNION /INTERSECT /MINUS)、SELECT TRANSFORM 、User Defined Type、GROUPING SET(CUBE/rollup/GROUPING SET)、脚本运行模式、参数化视图
支持外表(外部数据源+StorageHandler 支持非结构化数据）

MapReduce：

支持MapReduce编程接口(提供优化增强的MaxCompute MapReduce,也提供高度兼容Hadoop的MapReduce版本)
不暴露文件系统，输入输出都是表
通过MaxCompute客户端工具、Dataworks提交作业

MaxCompute Graph图模型：

MaxCompute Graph是一套面向迭代的图计算处理框架。图计算作业使用图进行建模，图由点（Vertex）和边（Edge）组成，点和边包含权值（Value）。
通过迭代对图进行编辑、演化，最终求解出结果
典型应用有：PageRank，单源最短距离算法，K-均值聚类算法等
使用MaxCompute Graph提供的接口Java SDK编写图计算程序并通过MaxCompute客户端工具通过jar命令提交任务

PyODPS:

用熟悉的Python利用MaxCompute大规模计算能力处理MaxCompute数据。

PyODPS是MaxCompute 的 Python SDK，同时也提供 DataFrame 框架，提供类似 pandas 的语法，能利用 MaxCompute 强大的处理能力来处理超大规模数据。

PyODPS 提供了对 ODPS 对象比如表、资源、函数等的访问。
支持通过 run_sql/execute_sql 的方式来提交 SQL。
支持通过 open_writer 和 open_reader 或者原生 tunnel API 的方式来上传下载数据
PyODPS 提供了 DataFrame API，它提供了类似 pandas 的接口，能充分利用 MaxCompute 的计算能力进行DataFrame的计算。
PyODPS DataFrame 提供了很多 pandas-like 的接口，但扩展了它的语法，比如增加了 MapReduce API 来扩展以适应大数据环境。
利用map 、apply 、map_reduce 等方便在客户端写函数、调用函数的方法，用户可在这些函数里调用三方库，如pandas、scipy、scikit-learn、nltk

Spark:

MaxCompute提供了Spark on MaxCompute的解决方案，使MaxCompute提供的兼容开源的Spark计算服务，让它在统一的计算资源和数据集权限体系之上，提供Spark计算框架，支持用户以熟悉的开发使用方式提交运行Spark作业。

支持原生多版本Spark作业：Spark1.x/Spark2.x作业都可运行；
开源系统的使用体验：Spark-submit提交方式（暂不支持spark-shell/spark-sql的交互式），提供原生的Spark WebUI供用户查看；
通过访问OSS、OTS、database等外部数据源，实现更复杂的ETL处理，支持对OSS非结构化进行处理；
使用Spark面向MaxCompute内外部数据开展机器学习，扩展应用场景；

交互式分析(Lightning)

MaxCompute产品的交互式查询服务，特性如下：

兼容PostgreSQL：兼容PostgreSQL协议的JDBC/ODBC接口，所有支持PostgreSQL数据库的工具或应用使用默认驱动都可以轻松地连接到MaxCompute项目。支持主流BI及SQL客户端工具的连接访问，如Tableau、帆软BI、Navicat、SQL Workbench/J等。
显著提升的查询性能：提升了一定数据规模下的查询性能，查询结果秒级可见，支持BI分析、Ad-hoc、在线服务等场景；

机器学习：

MaxCompute内建支持的上百种机器学习算法，目前MaxCompute的机器学习能力由PAI产品进行统一提供服务，同时PAI提供了深度学习框架、Notebook开发环境、GPU计算资源、模型在线部署的弹性预测服务。PAI产品与MaxCompute在项目和数据方面无缝集成。

场景应用

maxcompute,odps,大数据,数据仓库

云数据仓储

maxcompute,odps,大数据,数据仓库

日志大数据分析

maxcompute,odps,大数据,数据仓库

推荐搜索

maxcompute,odps,大数据,数据仓库

海量营销数据分析

算法应用

N皇后问题

解法一： MaxCompute

N皇后问题是一个经典的回溯算法问题，很考验计算机的算力，可以使用MaxCompute进行求解。具体步骤如下：

使用SQL语句生成所有可能的N皇后布局。可以使用笛卡尔积等方式生成所有可能的位置组合。假设每个皇后的位置是一个整数，使用SQL语句生成所有可能的位置组合，并将结果保存到一个临时表中。

-- 生成N皇后的位置组合，并保存到temp_table中
CREATE TABLE temp_table AS
SELECT col1 AS queen1, col2 AS queen2, col3 AS queen3, ..., colN AS queenN
FROM (
  SELECT t1.col AS col1, t2.col AS col2, ..., tN.col AS colN
  FROM (SELECT 1 AS col UNION ALL SELECT 2 AS col UNION ALL ... SELECT N AS col) t1,
       (SELECT 1 AS col UNION ALL SELECT 2 AS col UNION ALL ... SELECT N AS col) t2,
       ...
       (SELECT 1 AS col UNION ALL SELECT 2 AS col UNION ALL ... SELECT N AS col) tN
)
WHERE queen1 <> queen2 AND queen1 <> queen3 AND ... AND queenN <> queenN;

使用用户自定义函数 (UDF) 来判断是否该布局满足N皇后的要求。通过定义一个自定义函数，传入N和皇后的位置数组，判断是否满足N皇后的要求。如果满足要求，返回1，否则返回0。将返回值为1的布局过滤出来。

-- 自定义函数定义
CREATE FUNCTION is_valid_queen(n INT, queens ARRAY<INT>)
RETURNS INT
BEGIN
  -- 逐一判断每个皇后的位置是否合法
  FOR i IN 1..n DO 
    FOR j IN i+1..n DO
      IF queens[i] = queens[j] THEN
        -- 同一列冲突
        RETURN 0;
      END IF;
      IF ABS(queens[i] - queens[j]) = ABS(i - j) THEN
        -- 对角线冲突
        RETURN 0;
      END IF;
    END FOR;
  END FOR;
  RETURN 1;
END;

-- 过滤符合条件的布局
CREATE TABLE valid_layouts AS
SELECT *
FROM temp_table
WHERE is_valid_queen(N, ARRAY[queen1, queen2, queen3, ..., queenN]) = 1;

统计符合条件的布局数量。可以使用SQL语句查询符合条件的布局数量。

-- 统计符合条件的布局数量
SELECT COUNT(*) AS total
FROM valid_layouts;

通过以上步骤，可以使用MaxCompute解决N皇后问题，并得到符合条件的布局数量。需要注意的是，这个方法会生成所有可能的布局，因此在N比较大的情况下，可能会占用较大的计算资源和存储空间。可以根据具体情况进行优化和扩展。

解法二： Java

/**
 * @author JerryCui
 * @ClassName:  NQueen   
 * @Description: N皇后问题最优解   
 * @date 2023年10月6日 下午5:13:37
 */
public class NQueen {

	public static void main(String[] args) {
		long start1 = System.currentTimeMillis();
		System.out.println(new NQueen().getNQueen1(16) + " " + (System.currentTimeMillis()-start1));
		long start2 = System.currentTimeMillis();
		System.out.println(new NQueen().getNQueen2(16) + " " + (System.currentTimeMillis()-start2));
	}

	// 位运算，比暴力递归优化了常数项，时间复杂度依然为N!
	public int getNQueen1(int n) {
		int res = 0;

		int limit = n == 32 ? -1 : ((1 << n) - 1), colLimit = 0, leftLimit = 0, rightLimit = 0;
		res = process1(n, limit, colLimit, leftLimit, rightLimit);
		return res;
	}

	private int process1(int n, int limit, int colLimit, int leftLimit, int rightLimit) {
		int res = 0;
		if (limit == colLimit) {
			return 1;
		}
		int testSite = limit & (~(colLimit | leftLimit | rightLimit));
		while (testSite != 0) {
			int mostRightOne = testSite & ((~testSite) + 1);
			testSite ^= mostRightOne;
			res += process1(n, limit, colLimit | mostRightOne, (leftLimit | mostRightOne) << 1,
					(rightLimit | mostRightOne) >> 1);
		}
		return res;
	}

	// 暴力递归
	public int getNQueen2(int n) {
		int res = 0;
		res = process2(n, 0, new int[n]);
		return res;
	}

	// 用i表示当前第几行，用j=arr[i]表示i行j列
	public int process2(int n, int i, int[] arr) {
		if (i == n) {
			return 1;
		}
		int res = 0;
		for (int j = 0; j < n; j++) {
			if (isValid(arr, j, i)) {
				arr[i] = j;
				res += process2(n, i + 1, arr);
			}
		}
		return res;
	}

	private boolean isValid(int[] arr, int j, int i) {
		for (int k = 0; k < i; k++) {
			if (arr[k] == j || Math.abs(arr[k] - j) == Math.abs(i - k)) {
				return false;
			}
		}
		return true;
	}

}

3Sum问题

问题描述：3Sum（三数之和）是LeetCode上的一道经典问题，在算法领域中被广泛讨论和研究。给定一个整数数组nums，要求在数组中找到所有唯一的三元组（a，b，c），使得a + b + c = 0。返回所有满足条件的三元组。

示例：假设输入的数组为nums = [-1, 0, 1, 2, -1, -4]，那么符合条件的三元组为：[ [-1, 0, 1], [-1, -1, 2] ]

解题思路：解决3Sum问题的常用方法是双指针法。首先对数组进行排序，然后固定一个数，再使用双指针从两侧向中间查找另外两个数，使其和为目标值。通过适当调整指针的位置，可以有效避免重复的解。

该问题的解法可以分为两步：

对原数组进行排序，这样可以方便后续的双指针遍历。
使用双指针法进行遍历，从左到右遍历数组的每一个数字作为第一个数，然后使用双指针在剩余的数字中左右夹逼，寻找满足条件的第二个数和第三个数。

通过这样的遍历和比较，可以找到所有满足条件的三元组。注意，为了避免重复的结果，需要在遍历过程中跳过相同的数字。

这个问题在实际编程中常用于处理数组中的数学问题，例如寻找数组中的三个数的组合，使得它们的和为0，或者寻找数组中两个数的组合，使得它们的和为目标值等。

解法一： MaxCompute

我们可以使用MaxCompute的SQL语言来解决这个问题，具体实现方法如下：

首先将原数组排序。
创建临时表tmp，存储nums数组中所有的三元组[i,j,k]。

CREATE TABLE tmp (i BIGINT, j BIGINT, k BIGINT);
对于每一个i，遍历i之后的元素，设其为j，在j之后的元素中找到k，使得nums[i]+nums[j]+nums[k]=0。利用MaxCompute提供的内置函数lead()和lag()可以轻松地完成该功能。

INSERT INTO tmp SELECT i, j, k FROM (SELECT t1.num AS i, t2.num AS j, t3.num AS k FROM (SELECT num FROM nums ORDER BY num) t1 JOIN (SELECT num FROM nums ORDER BY num) t2 ON t1.num < t2.num JOIN (SELECT num FROM nums ORDER BY num) t3 ON t2.num < t3.num WHERE t1.num + t2.num + t3.num = 0) sub;
利用 DISTINCT 去重，输出所有不同的三元组。

SELECT DISTINCT i, j, k FROM tmp;

最终的结果即为所有符合条件的三元组。

解法二： Java

我们也可以使用Java来解决该问题。由于题目要求对不同的三元组去重，因此可以考虑使用一个HashSet来存储结果。具体实现方法如下：

public List<List<Integer>> threeSum(int[] nums) {
    Arrays.sort(nums); // 将原数组排序
    List<List<Integer>> res = new ArrayList<>();
    HashSet<List<Integer>> set = new HashSet<>();
    int n = nums.length;

    // 遍历i
    for (int i = 0; i < n - 2; i++) {
        int j = i + 1; // 设置指针j
        int k = n - 1; // 设置指针k

        // 在[j, k]区间内查找与nums[i] 相加等于0的[j, k]组合
        while (j < k) {
            int sum = nums[i] + nums[j] + nums[k];
            if (sum == 0) {
                List<Integer> temp = new ArrayList<>(Arrays.asList(nums[i], nums[j], nums[k]));
                if (!set.contains(temp)) { // 不含重复三元组
                    res.add(temp);
                    set.add(temp);
                }
                j++; // 指针j向右移动
            } else if (sum < 0) {
                j++; // 指针j向右移动
            } else {
                k--; // 指针k向左移动
            }
        }
    }
    return res;
}

该算法的时间复杂度为O(n^2)，其中n为输入数组的长度。最终的结果即为符合条件的所有三元组列表。文章来源地址https://www.toymoban.com/news/detail-854567.html

到了这里，关于MaxCompute功能与应用的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！