object JdbcUtils extends Logging with SQLConfHelper
Util functions for JDBC tables.
- Alphabetic
- By Inheritance
- JdbcUtils
- SQLConfHelper
- Logging
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def alterSchemaComment(conn: Connection, options: JDBCOptions, schema: String, comment: String): Unit
- def alterTable(conn: Connection, tableName: String, changes: Seq[TableChange], options: JDBCOptions): Unit
Update a table from the JDBC database.
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def checkIfIndexExists(conn: Connection, sql: String, options: JDBCOptions): Boolean
Check if index exists in a table
- def classifyException[T](message: String, dialect: JdbcDialect)(f: => T): T
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def conf: SQLConf
- Definition Classes
- SQLConfHelper
- def containsIndexTypeIgnoreCase(supportedIndexTypeList: Array[String], value: String): Boolean
- def createIndex(conn: Connection, indexName: String, tableName: String, columns: Array[NamedReference], columnsProperties: Map[NamedReference, Map[String, String]], properties: Map[String, String], options: JDBCOptions): Unit
Create an index.
- def createSchema(conn: Connection, options: JDBCOptions, schema: String, comment: String): Unit
Creates a schema.
- def createTable(conn: Connection, tableName: String, schema: StructType, caseSensitive: Boolean, options: JdbcOptionsInWrite): Unit
Creates a table with a given schema.
- def dropIndex(conn: Connection, indexName: String, tableName: String, options: JDBCOptions): Unit
Drop an index.
- def dropSchema(conn: Connection, options: JDBCOptions, schema: String, cascade: Boolean): Unit
Drops a schema from the JDBC database.
- def dropTable(conn: Connection, table: String, options: JDBCOptions): Unit
Drops a table from the JDBC database.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def executeQuery(conn: Connection, options: JDBCOptions, sql: String)(f: (ResultSet) => Unit): Unit
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def getCommonJDBCType(dt: DataType): Option[JdbcType]
Retrieve standard jdbc types.
Retrieve standard jdbc types.
- dt
The datatype (e.g. org.apache.spark.sql.types.StringType)
- returns
The default JdbcType for this DataType
- def getCustomSchema(tableSchema: StructType, customSchema: String, nameEquality: Resolver): StructType
Parses the user specified customSchema option value to DataFrame schema, and returns a schema that is replaced by the custom schema's dataType if column name is matched.
- def getInsertStatement(table: String, rddSchema: StructType, tableSchema: Option[StructType], isCaseSensitive: Boolean, dialect: JdbcDialect): String
Returns an Insert SQL statement for inserting a row into the target table via JDBC conn.
- def getJdbcType(dt: DataType, dialect: JdbcDialect): JdbcType
- def getSchema(resultSet: ResultSet, dialect: JdbcDialect, alwaysNullable: Boolean = false): StructType
Takes a ResultSet and returns its Catalyst schema.
Takes a ResultSet and returns its Catalyst schema.
- alwaysNullable
If true, all the columns are nullable.
- returns
A StructType giving the Catalyst schema.
- Exceptions thrown
SQLExceptionif the schema contains an unsupported type.
- def getSchemaOption(conn: Connection, options: JDBCOptions): Option[StructType]
Returns the schema if the table already exists in the JDBC database.
- def getSupportedIndexTypeList(catalogName: String): Array[String]
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def indexExists(conn: Connection, indexName: String, tableName: String, options: JDBCOptions): Boolean
Check if an index exists
- def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean
- Attributes
- protected
- Definition Classes
- Logging
- def initializeLogIfNecessary(isInterpreter: Boolean): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def isCascadingTruncateTable(url: String): Option[Boolean]
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isTraceEnabled(): Boolean
- Attributes
- protected
- Definition Classes
- Logging
- def listIndexes(conn: Connection, tableName: String, options: JDBCOptions): Array[TableIndex]
List all the indexes in a table.
- def listSchemas(conn: Connection, options: JDBCOptions): Array[Array[String]]
- def log: Logger
- Attributes
- protected
- Definition Classes
- Logging
- def logDebug(msg: => String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logDebug(msg: => String): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logError(msg: => String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logError(msg: => String): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logInfo(msg: => String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logInfo(msg: => String): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logName: String
- Attributes
- protected
- Definition Classes
- Logging
- def logTrace(msg: => String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logTrace(msg: => String): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logWarning(msg: => String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logWarning(msg: => String): Unit
- Attributes
- protected
- Definition Classes
- Logging
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def processIndexProperties(properties: Map[String, String], catalogName: String): (String, Array[String])
Process index properties and return tuple of indexType and list of the other index properties.
- def removeSchemaComment(conn: Connection, options: JDBCOptions, schema: String): Unit
- def renameTable(conn: Connection, oldTable: String, newTable: String, options: JDBCOptions): Unit
Rename a table from the JDBC database.
- def resultSetToRows(resultSet: ResultSet, schema: StructType): Iterator[Row]
Convert a ResultSet into an iterator of Catalyst Rows.
- def savePartition(table: String, iterator: Iterator[Row], rddSchema: StructType, insertStmt: String, batchSize: Int, dialect: JdbcDialect, isolationLevel: Int, options: JDBCOptions): Unit
Saves a partition of a DataFrame to the JDBC database.
Saves a partition of a DataFrame to the JDBC database. This is done in a single database transaction (unless isolation level is "NONE") in order to avoid repeatedly inserting data as much as possible.
It is still theoretically possible for rows in a DataFrame to be inserted into the database more than once if a stage somehow fails after the commit occurs but before the stage can return successfully.
This is not a closure inside saveTable() because apparently cosmetic implementation changes elsewhere might easily render such a closure non-Serializable. Instead, we explicitly close over all variables that are used.
Note that this method records task output metrics. It assumes the method is running in a task. For now, we only records the number of rows being written because there's no good way to measure the total bytes being written. Only effective outputs are taken into account: for example, metric will not be updated if it supports transaction and transaction is rolled back, but metric will be updated even with error if it doesn't support transaction, as there're dirty outputs.
- def saveTable(df: DataFrame, tableSchema: Option[StructType], isCaseSensitive: Boolean, options: JdbcOptionsInWrite): Unit
Saves the RDD to the database in a single transaction.
- def schemaExists(conn: Connection, options: JDBCOptions, schema: String): Boolean
- def schemaString(schema: StructType, caseSensitive: Boolean, url: String, createTableColumnTypes: Option[String] = None): String
Compute the schema string for this RDD.
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tableExists(conn: Connection, options: JdbcOptionsInWrite): Boolean
Returns true if the table already exists in the JDBC database.
- def toString(): String
- Definition Classes
- AnyRef → Any
- def truncateTable(conn: Connection, options: JdbcOptionsInWrite): Unit
Truncates a table from the JDBC database without side effects.
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def withConnection[T](options: JDBCOptions)(f: (Connection) => T): T