把sql和sql的执行计划及索引结构发出来看一下把

yarn提供了一套自己的调度机制，如果想被yarn调度起来需要自定义开发很多组件，spark也是自己开发了适应于yarn调度的接口，才能部署为spark on yarn，这个内容比较多，推荐一篇文章给你看下吧https://blog.csdn.net/u010039929/article/details/74934306

!/usr/bin/env python -- coding: utf-8 --

import MySQLdb as mdb

连接数据库

conn = mdb.connect('localhost', 'root', 'root')

也可以使用关键字参数

conn = mdb.connect(host='127.0.0.1', port=3306, user='root', passwd='root', db='test', charset='utf8')

也可以使用字典进行连接参数的管理

config = {
'host': '127.0.0.1',
'port': 3306,
'user': 'root',
'passwd': 'root',
'db': 'test',
'charset': 'utf8'
}
conn = mdb.connect(**config)
连接完数据库就可以执行sql了
然后把查询出来的结果拼装成html就可以了

大数据平台一般指的是具体的平台比如某个商业公司用的某个基于大数据开发的平台，大数据技术平台一般指的是一系列技术构建成的平台，也可以用别的技术，这些技术栈统称为大数据技术平台技术栈，这个虽然有点拗口，但是不要太在意这些概念。

MetaStore的引入很重要，主要解决了客户端访问hive元数据的管理问题，客户端连接metastore服务，metastore再去连接MySQL数据库来存取元数据。有了metastore服务，就可以有多个客户端同时连接，而且这些客户端不需要知道MySQL数据库的用户名和密码，只需要连接metastore 服务即可。这样既可以保证安全又可以保证高效。

spark的出现其实是一个生态系统的成长过程，Spark是基于内存计算的大数据并行计算框架，也就是说他的思想是要在内存中处理大规模数据，同时还要兼顾处理数据处理的实时性,同时保证了高容错性和高可伸缩性,当然这个前提是要在廉价的分布式集群上解决这个问题，这就是设计的初衷，也是设计的主要思想，至于rdd只是一个抽象而已。

但从环境上来说可以部署在一起，也可以分开，可以按功能分开部署，这样有利于维护，就像你非要把数据库和web应用部署在同一台机器上是一个道理

1、zk是命门
2、因为仓库一般是内网 没有啥攻击 就像你说所有数据都存在oracle 、oracle挂了不都完了吗一样

这个方法目前存在什么问题吗 还是满足不了业务的需求？

flink 写数据的时候写两份就行了 如果不用保证集群的数据实时一致，为了不影响flink的性能，你可以写另外的一个任务，把一个集群的数据直接拷贝给另一个集群

import ctypes
from ctypes import *
dll=cdll.LoadLibrary('C:\xxx.dll')
floatAdd=dll.floatAdd      #加载函数对象
floatAdd.argtypes=[c_float,c_float]
floatAdd.restype=c_float
print floatAdd(1.4,3.45)

这要看order by的位置 一般讲order by是最后执行的 如果它在sql语句的最后面 ，有先于select执行的例子可以发出来 一起探讨一下

setData和getData在api中有好多同名的方法 你指的是哪一个？

public class server implements Runnable {// 服务端
static List socketList=new ArrayList();
// 读取 In
static Socket socket = null;
static ServerSocket serverSocket = null;
public server() {// 构造方法
try {
serverSocket = new ServerSocket(9999);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("****服务端*****");
server t = new server();
int count = 0;
while (true) {
try {
// System.out.println("端口9999等待被连接......");
socket = serverSocket.accept();
count++;
System.out.println("第" + count + "个客户已连接");
socketList.add(socket);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Print p = new Print(socket);
Thread read = new Thread(t);
Thread print = new Thread(p);
read.start();
print.start();
}
}
@Override
public void run() {
// 重写run方法
try {
Thread.sleep(1000);
BufferedReader in = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
while (true) {
String jieshou = in.readLine();
System.out.println( jieshou);
for (int i = 0; i < socketList.size(); i++) {
Socket socket=socketList.get(i);
PrintWriter out = new PrintWriter(socket.getOutputStream());
if (socket!=this.socket) {
out.println(jieshou);
}else{
out.println("(你)"+jieshou);
}
out.flush();
}
}
} catch (Exception e) {

        e.printStackTrace();
    }
}

}
class Print implements Runnable {
static List socketList=new ArrayList();
Scanner input = new Scanner(System.in);
public Print(Socket s) {// 构造方法
try {
socketList.add(s);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void run() {
try {
Thread.sleep(1000);
while (true) {
String msg = input.next();
for (int i = 0; i < socketList.size(); i++) {
Socket socket=socketList.get(i);
PrintWriter out = new PrintWriter(socket.getOutputStream());
// System.out.println("对客户端说：");
out.println("服务端说："+msg);
out.flush();
}
}
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
}
//client.java
package Socket;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class client implements Runnable {// 客户端
static Socket socket = null;
Scanner input = new Scanner(System.in);
static String name=null;
public static void main(String[] args) {
int x=(int)(Math.random()*100);
client.name="client"+x;
System.out.println("****客户端"+x+"*****");
try {
socket = new Socket("127.0.0.1", 9999);
System.out.println("已经连上服务器了");
} catch (Exception e) {
e.printStackTrace();
}
client t = new client();
Read r = new Read(socket);
Thread print = new Thread(t);
Thread read = new Thread(r);
print.start();
read.start();
}
@Override
public void run() {
try {
Thread.sleep(1000);
PrintWriter out = new PrintWriter(socket.getOutputStream());
while (true) {
String msg = input.next();
out.println(name+"说:"+msg);
out.flush();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Read implements Runnable {
static Socket socket = null;
public Read(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
Thread.sleep(1000);
BufferedReader in = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
while (true) {
System.out.println( in.readLine());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
————————————————
原文链接：https://blog.csdn.net/qq_29606255/article/details/78679815

把整个命令贴一下