除了支援：Append、Overwrite、ErrorIfExists、Ignore；還要在支援update操作
spark提供了一個枚舉類，用來支撐對接數據來源的操作模式
透過原始碼查看，很明顯，spark是不支援update操作的
#關鍵的知識點就是：
我們正常在sparkSQL寫資料到mysql的時候：
大概的api是：
dataframe.write
.format("sql.execution.customDatasource.jdbc")
.option("jdbc.driver", "com.mysql.jdbc.Driver")
.option("jdbc.url", "jdbc:mysql://localhost:3306/test?user=root&password=&useUnicode=true&characterEncoding=gbk&autoReconnect=true&failOverReadOnly=false")
.option("jdbc.db", "test")
.save()那麼在底層中，spark會透過JDBC方言JdbcDialect ， 將我們要插入的資料翻譯成：
insert into student (columns_1 , columns_2 , ...) values (? , ? , ....)
那麼透過方言解析出的sql語句就透過PrepareStatement的executeBatch()，將sql語句提交給mysql，然後資料插入；
那麼上面的sql語句很明顯，完全就是插入程式碼，並沒有我們期望的update操作，類似：
UPDATE table_name SET field1=new-value1, field2=new-value2
但是mysql獨家支援這樣的sql語句：
INSERT INTO student (columns_1,columns_2）VALUES ('第一个字段值','第二个字段值') ON DUPLICATE KEY UPDATE columns_1 = '呵呵哒',columns_2 = '哈哈哒';
大概的意思就是，如果資料不存在則插入，如果資料存在，則執行update操作；
所以，我們的重點在於使Spark SQL內部與JdbcDialect對接時能夠產生此類SQL語句
INSERT INTO 表名称 (columns_1,columns_2）VALUES ('第一个字段值','第二个字段值') ON DUPLICATE KEY UPDATE columns_1 = '呵呵哒',columns_2 = '哈哈哒';
首先是：
dataframe.write
呼叫write方法就是為了傳回一個類別：DataFrameWriter
主要是因為DataFrameWriter是sparksql對接外部資料來源寫入的入口攜帶類，下面這些內容是給DataFrameWriter註冊的攜帶訊息
然後在出發save()操作後，就開始將資料寫入；
接下來看save()原始碼：
在上方的來源碼裡面主要是註冊DataSource實例，然後使用DataSource的write方法進行資料寫入
實例化DataSource的時候：
def save(): Unit = {
assertNotBucketed("save")
val dataSource = DataSource(
df.sparkSession,
className = source,//自定义数据源的包路径
partitionColumns = partitioningColumns.getOrElse(Nil),//分区字段
bucketSpec = getBucketSpec,//分桶(用于hive)
options = extraOptions.toMap)//传入的注册信息
//mode：插入数据方式SaveMode ， df：要插入的数据
dataSource.write(mode, df)
}然後就是dataSource.write(mode, df)的細節，整段的邏輯就是：
根據providingClass.newInstance()去做模式匹配，然後匹配到哪裡，就執行哪裡的程式碼；
然後看下providingClass是什麼：
拿到套件路徑.DefaultSource之後，程式進入：
那麼如果是資料庫作為寫入目標的話，就會走：dataSource.createRelation，直接跟進原始碼：
很明顯是個特質，因此哪裡實現了特質，程式就會走到哪裡了；
實現這個特質的地方就是：套件路徑.DefaultSource ， 然後就在這裡面去實現資料的插入和update的支援操作；
根據程式碼的流程，最終sparkSQL 將資料寫入mysql的操作，會進入：包路徑.DefaultSource這個類別裡面；
換個說法，就是這個類別需要同時支援Spark的正常插入操作（SaveMode）和更新操作
如果讓sparksql支援update操作，最關鍵的就是做一個判斷，例如：
if(isUpdate){
sql语句：INSERT INTO student (columns_1,columns_2）VALUES ('第一个字段值','第二个字段值') ON DUPLICATE KEY UPDATE columns_1 = '呵呵哒',columns_2 = '哈哈哒';
}else{
insert into student (columns_1 , columns_2 , ...) values (? , ? , ....)
}但是，在spark生產sql語句的源碼中，是這樣寫的：
沒有任何的判斷邏輯，就是最後產生一個:
INSERT INTO TABLE (字段1 ， 字段2....) VALUES (? , ? ...)
所以首要的任務就是，怎麼能讓目前程式碼支援： ON DUPLICATE KEY UPDATE
可以做個大膽的設計，就是在insertStatement這個方法中做個如下的判斷
def insertStatement(conn: Connection, savemode:CustomSaveMode , table: String, rddSchema: StructType, dialect: JdbcDialect)
: PreparedStatement = {
val columns = rddSchema.fields.map(x => dialect.quoteIdentifier(x.name)).mkString(",")
val placeholders = rddSchema.fields.map(_ => "?").mkString(",")
if(savemode == CustomSaveMode.update){
//TODO 如果是update，就组装成ON DUPLICATE KEY UPDATE的模式处理
s"INSERT INTO $table ($columns) VALUES ($placeholders) ON DUPLICATE KEY UPDATE $duplicateSetting"
}esle{
val sql = s"INSERT INTO $table ($columns) VALUES ($placeholders)"
conn.prepareStatement(sql)
}
}這樣，在用戶傳遞進來的savemode模式，我們進行校驗，如果是update操作，就回傳對應的sql語句！
所以按照上面的邏輯，我們程式碼這樣寫：
#這樣我們就拿到了對應的sql語句；
#但是只有這個sql語句還是不行的，因為在spark中會執行jdbc的prepareStatement操作，這裡面會牽涉到遊標。
即jdbc在遍歷這個sql的時候，原始碼會這樣做：
看下makeSetter：
所谓有坑就是：
insert into table (字段1 , 字段2, 字段3) values (? , ? , ?)
那么当前在源码中返回的数组长度应该是3：
val setters: Array[JDBCValueSetter] = rddSchema.fields.map(_.dataType)
.map(makeSetter(conn, dialect, _)).toArray但是如果我们此时支持了update操作，既：
insert into table (字段1 , 字段2, 字段3) values (? , ? , ?) ON DUPLICATE KEY UPDATE 字段1 = ?,字段2 = ?,字段3=?;
那么很明显，上面的sql语句提供了6个？ ， 但在规定字段长度的时候只有3
这样的话，后面的update操作就无法执行，程序报错！
所以我们需要有一个 识别机制，既：
if(isupdate){
val numFields = rddSchema.fields.length * 2
}else{
val numFields = rddSchema.fields.length
}
row[1,2,3] setter(0,1) //index of setter , index of row setter(1,2) setter(2,3) setter(3,1) setter(4,2) setter(5,3)
所以在prepareStatment中的占位符应该是row的两倍，而且应该是类似这样的一个逻辑
因此，代码改造前样子：
改造后的样子：
try {
if (supportsTransactions) {
conn.setAutoCommit(false) // Everything in the same db transaction.
conn.setTransactionIsolation(finalIsolationLevel)
}
// val stmt = insertStatement(conn, table, rddSchema, dialect)
//此处采用最新自己的sql语句，封装成prepareStatement
val stmt = conn.prepareStatement(sqlStmt)
println(sqlStmt)
/**
* 在mysql中有这样的操作：
* INSERT INTO user_admin_t (_id,password) VALUES ('1','第一次插入的密码')
* INSERT INTO user_admin_t (_id,password）VALUES ('1','第一次插入的密码') ON DUPLICATE KEY UPDATE _id = 'UpId',password = 'upPassword';
* 如果是下面的ON DUPLICATE KEY操作，那么在prepareStatement中的游标会扩增一倍
* 并且如果没有update操作，那么他的游标是从0开始计数的
* 如果是update操作，要算上之前的insert操作
* */
//makeSetter也要适配update操作，即游标问题
val isUpdate = saveMode == CustomSaveMode.Update
val setters: Array[JDBCValueSetter] = isUpdate match {
case true =>
val setters: Array[JDBCValueSetter] = rddSchema.fields.map(_.dataType)
.map(makeSetter(conn, dialect, _)).toArray
Array.fill(2)(setters).flatten
case _ =>
rddSchema.fields.map(_.dataType)
val numFieldsLength = rddSchema.fields.length
val numFields = isUpdate match{
case true => numFieldsLength *2
case _ => numFieldsLength
val cursorBegin = numFields / 2
try {
var rowCount = 0
while (iterator.hasNext) {
val row = iterator.next()
var i = 0
while (i < numFields) {
if(isUpdate){
//需要判断当前游标是否走到了ON DUPLICATE KEY UPDATE
i < cursorBegin match{
//说明还没走到update阶段
case true =>
//row.isNullAt 判空,则设置空值
if (row.isNullAt(i)) {
stmt.setNull(i + 1, nullTypes(i))
} else {
setters(i).apply(stmt, row, i, 0)
}
//说明走到了update阶段
case false =>
if (row.isNullAt(i - cursorBegin)) {
//pos - offset
stmt.setNull(i + 1, nullTypes(i - cursorBegin))
setters(i).apply(stmt, row, i, cursorBegin)
}
}else{
if (row.isNullAt(i)) {
stmt.setNull(i + 1, nullTypes(i))
} else {
setters(i).apply(stmt, row, i ,0)
}
//滚动游标
i = i + 1
}
stmt.addBatch()
rowCount += 1
if (rowCount % batchSize == 0) {
stmt.executeBatch()
rowCount = 0
}
if (rowCount > 0) {
stmt.executeBatch()
} finally {
stmt.close()
conn.commit()
committed = true
Iterator.empty
} catch {
case e: SQLException =>
val cause = e.getNextException
if (cause != null && e.getCause != cause) {
if (e.getCause == null) {
e.initCause(cause)
} else {
e.addSuppressed(cause)
throw e
} finally {
if (!committed) {
// The stage must fail. We got here through an exception path, so
// let the exception through unless rollback() or close() want to
// tell the user about another problem.
if (supportsTransactions) {
conn.rollback()
conn.close()
} else {
// The stage must succeed. We cannot propagate any exception close() might throw.
try {
conn.close()
} catch {
case e: Exception => logWarning("Transaction succeeded, but closing failed", e)// A `JDBCValueSetter` is responsible for setting a value from `Row` into a field for
// `PreparedStatement`. The last argument `Int` means the index for the value to be set
// in the SQL statement and also used for the value in `Row`.
//PreparedStatement, Row, position , cursor
private type JDBCValueSetter = (PreparedStatement, Row, Int , Int) => Unit
private def makeSetter(
conn: Connection,
dialect: JdbcDialect,
dataType: DataType): JDBCValueSetter = dataType match {
case IntegerType =>
(stmt: PreparedStatement, row: Row, pos: Int,cursor:Int) =>
stmt.setInt(pos + 1, row.getInt(pos - cursor))
case LongType =>
stmt.setLong(pos + 1, row.getLong(pos - cursor))
case DoubleType =>
stmt.setDouble(pos + 1, row.getDouble(pos - cursor))
case FloatType =>
stmt.setFloat(pos + 1, row.getFloat(pos - cursor))
case ShortType =>
stmt.setInt(pos + 1, row.getShort(pos - cursor))
case ByteType =>
stmt.setInt(pos + 1, row.getByte(pos - cursor))
case BooleanType =>
stmt.setBoolean(pos + 1, row.getBoolean(pos - cursor))
case StringType =>
// println(row.getString(pos))
stmt.setString(pos + 1, row.getString(pos - cursor))
case BinaryType =>
stmt.setBytes(pos + 1, row.getAs[Array[Byte]](pos - cursor))
case TimestampType =>
stmt.setTimestamp(pos + 1, row.getAs[java.sql.Timestamp](pos - cursor))
case DateType =>
stmt.setDate(pos + 1, row.getAs[java.sql.Date](pos - cursor))
case t: DecimalType =>
stmt.setBigDecimal(pos + 1, row.getDecimal(pos - cursor))
case ArrayType(et, _) =>
// remove type length parameters from end of type name
val typeName = getJdbcType(et, dialect).databaseTypeDefinition
.toLowerCase.split("\\(")(0)
val array = conn.createArrayOf(
typeName,
row.getSeq[AnyRef](pos - cursor).toArray)
stmt.setArray(pos + 1, array)
case _ =>
(_: PreparedStatement, _: Row, pos: Int,cursor:Int) =>
throw new IllegalArgumentException(
s"Can't translate non-null value for field $pos")
}以上是怎麼讓spark sql寫mysql時支援update操作的詳細內容。更多資訊請關注PHP中文網其他相關文章！
