DatabaseAdapter

abstract def isTableDoesNotExistException(e: SQLException): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def aliasExport(parentOfTarget: QueryableExpressionNode, target: SelectElement): String

final def arrayCreationType(ptype: Class[_]): String

final def asInstanceOf[T0]: T0

def bigDecimalTypeDeclaration(precision: Int, scale: Int): String

def bigDecimalTypeDeclaration: String

def binaryTypeDeclaration: String

def booleanTypeDeclaration: String

def clone(): AnyRef

def convertFromBooleanForJdbc(b: Boolean): Boolean

unused at the moment, since all jdbc drivers adhere to the standard that : 1 == true, false otherwise.

def convertFromUuidForJdbc(u: UUID): AnyRef

def convertToBooleanForJdbc(rs: ResultSet, i: Int): Boolean

unused for the same reason as def convertFromBooleanForJdbc (see comment)

def convertToJdbcValue(r: AnyRef): AnyRef

Converts field instances so they can be fed, and understood by JDBC will not do conversion from None/Some, so @arg r should be a java primitive type or a CustomType

def convertToUuidForJdbc(rs: ResultSet, i: Int): UUID

def createSequenceName(fmd: FieldMetaData): String

def createStatement(conn: Connection): Statement

def currenSession: AbstractSession

def databaseTypeFor(fieldMapper: FieldMapper, c: Class[_]): String

def databaseTypeFor(fmd: FieldMetaData): String

def dateTypeDeclaration: String

def doubleArrayTypeDeclaration: String

def doubleTypeDeclaration: String

def dropForeignKeyStatement(foreignKeyTable: Table[_], fkName: String, session: AbstractSession): Unit

def dropTable(t: Table[_]): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exec[A](s: AbstractSession, sw: StatementWriter)(block: (Iterable[StatementParam]) ⇒ A): A

def execFailSafeExecute(sw: StatementWriter, silenceException: (SQLException) ⇒ Boolean): Unit

Some methods like 'dropTable' issue their statement, and will silence the exception.

def executeQuery(s: AbstractSession, sw: StatementWriter): (ResultSet, PreparedStatement)

def executeUpdate(s: AbstractSession, sw: StatementWriter): (Int, PreparedStatement)

def executeUpdateAndCloseStatement(s: AbstractSession, sw: StatementWriter): Int

def executeUpdateForInsert(s: AbstractSession, sw: StatementWriter, ps: PreparedStatement): Int

def failureOfStatementRequiresRollback: Boolean

def fieldAlias(n: QueryableExpressionNode, fse: FieldSelectElement): String

def fillParamsInto(params: Iterable[StatementParam], s: PreparedStatement): Unit

def finalize(): Unit

def floatTypeDeclaration: String

def foreignKeyConstraintName(foreignKeyTable: Table[_], idWithinSchema: Int): String

def generateAlmostUniqueSuffixWithHash(s: String): String

This will create an probabilistically unique string of length no longer than 11 chars, it can be used to create "almost unique" names where uniqueness is not an absolute requirement, is not ,

final def getClass(): Class[_]

def getInsertableFields(fmd: Iterable[FieldMetaData]): Iterable[FieldMetaData]

def hashCode(): Int

def intArrayTypeDeclaration: String

def intTypeDeclaration: String

def isFullOuterJoinSupported: Boolean

final def isInstanceOf[T0]: Boolean

def isNotNullConstraintViolation(e: SQLException): Boolean

Figures out from the SQLException (ex.: vendor specific error code) if it's cause is a NOT NULL constraint violation

def jdbcDoubleArrayCreationType: String

def jdbcIntArrayCreationType: String

def jdbcLongArrayCreationType: String

def jdbcStringArrayCreationType: String

def jdbcTypeConstantFor(c: Class[_]): Int

def longArrayTypeDeclaration: String

def longTypeDeclaration: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def nvlToken: String

def postCreateTable(t: Table[_], printSinkWhenWriteOnlyMode: Option[(String) ⇒ Unit]): Unit

When @arg printSinkWhenWriteOnlyMode is not None, the adapter will not execute any statement, but only silently give it to the String=>Unit closure

def postDropTable(t: Table[_]): Unit

def prepareStatement(conn: Connection, statement: String): PreparedStatement

def quoteIdentifier(s: String): String

def quoteName(s: String): String

def setParamInto(s: PreparedStatement, p: StatementParam, i: Int): Unit

implicit def string2StatementWriter(s: String): StatementWriter

def stringArrayTypeDeclaration: String

def stringTypeDeclaration(length: Int): String

def stringTypeDeclaration: String

def supportsAutoIncrementInColumnDeclaration: Boolean

def supportsCommonTableExpressions: Boolean

def supportsForeignKeyConstraints: Boolean

def supportsUnionQueryOptions: Boolean

final def synchronized[T0](arg0: ⇒ T0): T0

def timestampTypeDeclaration: String

def toString(): String

def uuidTypeDeclaration: String

def verifyDeleteByPK: Boolean

Should we verify that when we delete by primary key the JDBC driver reports that no more than one row was affected? MonetDB in particular seems to act badly here

def viewAlias(vn: ViewExpressionNode[_]): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def writeColumnDeclaration(fmd: FieldMetaData, isPrimaryKey: Boolean, schema: Schema): String

def writeCompositePrimaryKeyConstraint(t: Table[_], cols: Iterable[FieldMetaData]): String

def writeConcatFunctionCall(fn: FunctionNode, sw: StatementWriter): Unit

def writeConcatOperator(left: ExpressionNode, right: ExpressionNode, sw: StatementWriter): Unit

def writeCreateTable[T](t: Table[T], sw: StatementWriter, schema: Schema): Unit

def writeCteReference(sw: StatementWriter, q: QueryExpressionElements): Unit

def writeDelete[T](t: Table[T], whereClause: Option[ExpressionNode], sw: StatementWriter): Unit

def writeDropForeignKeyStatement(foreignKeyTable: Table[_], fkName: String): String

def writeDropTable(tableName: String): String

def writeEndOfFromHint(qen: QueryExpressionElements, sw: StatementWriter): Unit

def writeEndOfQueryHint(isForUpdate: () ⇒ Boolean, qen: QueryExpressionElements, sw: StatementWriter): Unit

def writeForeignKeyDeclaration(foreignKeyTable: Table[_], foreignKeyColumnName: String, primaryKeyTable: Table[_], primaryKeyColumnName: String, referentialAction1: Option[ReferentialAction], referentialAction2: Option[ReferentialAction], fkId: Int): String

def writeIndexDeclaration(columnDefs: Seq[FieldMetaData], name: Option[String], nameOfCompositeKey: Option[String], isUnique: Boolean): String

def writeInsert[T](o: T, t: Table[T], sw: StatementWriter): Unit

def writeJoin(queryableExpressionNode: QueryableExpressionNode, sw: StatementWriter): Unit

def writeNvlCall(left: ExpressionNode, right: ExpressionNode, sw: StatementWriter): Unit

def writePaginatedQueryDeclaration(page: () ⇒ Option[(Int, Int)], qen: QueryExpressionElements, sw: StatementWriter): Unit

def writeQuery(qen: QueryExpressionElements, sw: StatementWriter, inverseOrderBy: Boolean, topHint: Option[String]): Unit

def writeQuery(qen: QueryExpressionElements, sw: StatementWriter): Unit

def writeRegexExpression(left: ExpressionNode, pattern: String, sw: StatementWriter): Unit

def writeSelectElementAlias(se: SelectElement, sw: StatementWriter): Unit

def writeUnionQueryOptions(qen: QueryExpressionElements, sw: StatementWriter): Unit

def writeUniquenessConstraint(t: Table[_], cols: Iterable[FieldMetaData]): String

def writeUpdate(t: Table[_], us: UpdateStatement, sw: StatementWriter): Unit

def writeUpdate[T](o: T, t: Table[T], sw: StatementWriter, checkOCC: Boolean): Unit

def writeValue(o: AnyRef, fmd: FieldMetaData, sw: StatementWriter): String

implicit def zipIterable[T](i: Iterable[T]): ZipIterable[T]