Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -19,6 +19,12 @@ public enum MSSQLDefinitionText {
["NATIONAL", "TEXT"], ["BINARY", "VARYING"],
]
private static let longestMultiWordType = 3
// ALTER COLUMN takes COLLATE on these and their ISO synonyms only, never on text, ntext or an alias type.
private static let characterTypes: Set<[String]> = [
["char"], ["varchar"], ["nchar"], ["nvarchar"], ["character"], ["char", "varying"], ["character", "varying"],
["national", "char"], ["national", "character"], ["national", "char", "varying"],
["national", "character", "varying"],
]

public static func isParenthesizedExpression(_ text: String) -> Bool {
SQLExpressionFragment.isSingleExpression(text, databaseTypeId: databaseTypeId)
Expand Down Expand Up @@ -54,6 +60,11 @@ public enum MSSQLDefinitionText {
return SQLExpressionFragment.isSingleType(source.substring(from: index), databaseTypeId: databaseTypeId)
}

public static func isCharacterType(_ text: String) -> Bool {
let name = text.prefix { $0 != "(" }.lowercased().filter { $0 != "[" && $0 != "]" }
return characterTypes.contains(name.split(whereSeparator: \.isWhitespace).map(String.init))
}

public static func isCollationName(_ text: String) -> Bool {
!text.isEmpty && text.unicodeScalars.allSatisfy { scalar in
("A"..."Z").contains(scalar) || ("a"..."z").contains(scalar) || ("0"..."9").contains(scalar) || scalar == "_"
Expand Down Expand Up @@ -205,6 +216,14 @@ public struct MSSQLDefinitionRefusal: Error, LocalizedError, Sendable, Equatable
))
}

public static func foreignKeyAction(_ constraint: String, _ action: String) -> MSSQLDefinitionRefusal {
MSSQLDefinitionRefusal(reason: String(
format: String(localized: "The referential action of foreign key %@ is not one SQL Server has: %@"),
constraint,
action
))
}

public static func indexFilter(_ index: String) -> MSSQLDefinitionRefusal {
MSSQLDefinitionRefusal(reason: String(
format: String(localized: "The filter of index %@ is not one SQL expression, so it cannot be written."),
Expand Down

Large diffs are not rendered by default.

Original file line number Diff line number Diff line change
Expand Up @@ -41,7 +41,8 @@ enum RecordDecoder {
case TeradataType.decimal:
return try reader.take(decimalByteWidth(precision: column.dataLength >> 8))
default:
throw TeradataWireError.unsupported("record field type \(column.baseCode)")
// NUMBER's length byte is not documented well enough to read, and LOBs need the multipart request.
throw TeradataWireError.unreadableColumn(name: column.name, typeCode: column.typeCode)
}
}

Expand Down Expand Up @@ -115,7 +116,7 @@ enum RecordDecoder {
let day = Int(packed % 100)
return .text(String(format: "%04d-%02d-%02d", year, month, day))
default:
throw TeradataWireError.unsupported("record field type \(column.baseCode)")
throw TeradataWireError.unreadableColumn(name: column.name, typeCode: column.typeCode)
}
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -58,14 +58,19 @@ public enum TeradataColumnType {
}

public static func wireTypeName(_ code: UInt16) -> String {
knownWireTypeName(code) ?? "VARCHAR"
}

// Codes from the CLIv2 data type table; JSON's from the embedded SQL SQLDA table, which CLIv2 does not list.
public static func knownWireTypeName(_ code: UInt16) -> String? {
switch code & 0xFFFE {
case TeradataType.byteint: return "BYTEINT"
case TeradataType.smallint: return "SMALLINT"
case TeradataType.integer: return "INTEGER"
case TeradataType.bigint: return "BIGINT"
case TeradataType.float: return "FLOAT"
case TeradataType.decimal: return "DECIMAL"
case 604: return "NUMBER"
case TeradataType.number: return "NUMBER"
case TeradataType.char: return "CHAR"
case TeradataType.varchar: return "VARCHAR"
case TeradataType.longVarchar: return "LONG VARCHAR"
Expand All @@ -76,10 +81,19 @@ public enum TeradataColumnType {
case 764: return "TIMESTAMP"
case 768: return "TIME WITH TIME ZONE"
case 772: return "TIMESTAMP WITH TIME ZONE"
case 400: return "BLOB"
case 416: return "CLOB"
case 880: return "JSON"
default: return "VARCHAR"
case 776, 780, 784, 788, 792, 796, 800, 804, 808, 812, 816, 820, 824: return "INTERVAL"
case 832: return "PERIOD(DATE)"
case 836: return "PERIOD(TIME)"
case 840: return "PERIOD(TIME WITH TIME ZONE)"
case 844: return "PERIOD(TIMESTAMP)"
case 848: return "PERIOD(TIMESTAMP WITH TIME ZONE)"
case 400, 404, 408, 412: return "BLOB"
case 416, 420, 424: return "CLOB"
case 432, 436, 440: return "UDT"
case 504, 508: return "ARRAY"
case 852, 856, 860: return "XML"
case 880, 884, 888: return "JSON"
default: return nil
}
}

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -29,6 +29,10 @@
private var _operationActive = false
// The request a stop is waiting on the server for, so the stop's deadline closes nothing that came after it.
private var _stoppingRequest: UInt32?
// Under socketLock: the semantics the session runs with, and what its requests have left open.
private var _sessionMode: TeradataTransactionMode
private var _sessionModeSource: TeradataSessionModeSource
private var _transaction: TeradataTransactionTracker

// 3110: "The transaction was aborted by the user."
public static let userAbortCode = 3_110
Expand Down Expand Up @@ -63,6 +67,10 @@
public init(config: TeradataConnectionConfig) {
self.config = config
stopGrace = Self.defaultStopGrace
let configured = Self.configuredMode(config.transactionMode)
_sessionMode = configured.mode
_sessionModeSource = configured.source
_transaction = TeradataTransactionTracker(mode: configured.mode)
}

init(
Expand All @@ -74,10 +82,27 @@
self._socket = transport
self.stopGrace = stopGrace
confidentialityBypassed = true
let configured = Self.configuredMode(config.transactionMode)
_sessionMode = configured.mode
_sessionModeSource = configured.source
_transaction = TeradataTransactionTracker(mode: configured.mode)
}

private static func configuredMode(
_ mode: TeradataTransactionMode
) -> (mode: TeradataTransactionMode, source: TeradataSessionModeSource) {
mode == .default ? (.default, .unresolved) : (mode, .configured)
}

public var isConnected: Bool { socket != nil }

// `.default` when the session could not say which semantics it runs with; it then gets Teradata's.
public var sessionTransactionMode: TeradataTransactionMode { socketLock.withLock { _sessionMode } }

public var sessionModeSource: TeradataSessionModeSource { socketLock.withLock { _sessionModeSource } }

public var transactionState: TeradataTransactionState { socketLock.withLock { _transaction.state } }

// Set when a request failed partway, so the session it ran on was given up rather than ended.
public var hasLostConnection: Bool { socketLock.withLock { _hasLostConnection } }

Expand Down Expand Up @@ -114,10 +139,7 @@
let params = try Td2Token.parseServerParams(serverToken)
try runKeyExchange(params)
try runConnect()

if let database = config.database, !database.isEmpty {
_ = try execute(TeradataSchemaQueries.setDatabase(database))
}
try prepareSession()
_ = try deadline.remainingMilliseconds()
established = true
}
Expand All @@ -132,6 +154,84 @@
self.connectDeadline = nil
}

// DEFAULT is the site's default, so the session is asked which one it got. An ANSI session opens a transaction
// with its first request and counts DATABASE as DDL, after which only COMMIT is legal, so the setup is committed.
func prepareSession() throws {
let (mode, source) = try resolveSessionMode()
var ranRequest = config.transactionMode == .default
if let database = config.database, !database.isEmpty {
_ = try execute(TeradataSchemaQueries.setDatabase(database))
ranRequest = true
}
if mode == .ansi, ranRequest {
_ = try execute(TeradataTransactionSQL.commit(.ansi))
}
socketLock.withLock {
_sessionMode = mode
_sessionModeSource = source
_transaction = TeradataTransactionTracker(mode: mode)
}
}

private func resolveSessionMode() throws -> (TeradataTransactionMode, TeradataSessionModeSource) {
guard config.transactionMode == .default else { return (config.transactionMode, .configured) }
if let mode = try probeSessionMode(
TeradataSessionModeProbe.helpSession, read: TeradataSessionModeProbe.mode(fromHelpSession:)
) {
return (mode, .helpSession)
}
if let mode = try probeSessionMode(
TeradataSessionModeProbe.sessionInfo, read: TeradataSessionModeProbe.mode(fromSessionInfo:)
) {
return (mode, .sessionInfoView)
}
return (.default, .unresolved)
}

// A refusal, or a reply this decoder cannot read, leaves the session usable for the next way of asking.
private func probeSessionMode(
_ sql: String,
read: (TeradataResultSet) -> TeradataTransactionMode?
) throws -> TeradataTransactionMode? {
do {
return read(try execute(sql))
} catch TeradataWireError.cancelled {
throw TeradataWireError.cancelled
} catch {
guard isConnected else { throw error }
return nil
}
}

public func beginTransaction() throws {
guard let statement = TeradataTransactionSQL.begin(sessionTransactionMode) else { return }
_ = try execute(statement)
}

public func commitTransaction() throws {
_ = try execute(TeradataTransactionSQL.commit(sessionTransactionMode))
}

public func rollbackTransaction() throws {
do {
_ = try execute(TeradataTransactionSQL.rollback(sessionTransactionMode))
} catch TeradataWireError.server(let code, _) where TeradataTransactionSQL.rollbackAnswerCodes.contains(code) {
// The failure parcel a rollback answers with is its success.
}
socketLock.withLock { _transaction.rolledBack() }
}

// After DATABASE inside a transaction only the closing statement is legal (ANSI counts it as DDL; Teradata mode
// is not documented either way), so a switch never joins an open one, and in ANSI it is committed at once.
public func switchDatabase(to database: String) throws {
let (mode, state) = socketLock.withLock { (_sessionMode, _transaction.state) }
guard state != .open else { throw TeradataWireError.openTransactionBlocksDatabaseSwitch }
_ = try execute(TeradataSchemaQueries.setDatabase(database))
if mode == .ansi {
_ = try execute(TeradataTransactionSQL.commit(.ansi))
}
}

public func execute(_ sql: String) throws -> TeradataResultSet {
var columns: [TeradataColumn] = []
var rows: [[TeradataValue]] = []
Expand Down Expand Up @@ -179,6 +279,7 @@
onRows: ([[TeradataValue]]) throws -> Bool
) throws -> Int {
guard socket != nil else { throw TeradataWireError.connectionFailed("not connected") }
let kinds = TeradataStatementKind.kinds(in: sql)
let requestNumber = nextRequest()
let body = TeradataMessages.optionsParcel(returnStatementInfo: false).encoded()
+ TeradataMessages.requestParcel(sql: sql).encoded()
Expand All @@ -200,14 +301,25 @@
case .notSent:
throw TeradataWireError.cancelled
case .refused(let error):
if stopped, case .server(let code, _)? = error as? TeradataWireError, code == Self.userAbortCode {
// In Teradata mode a request outside BT is its own transaction, so the abort undid that request alone.
throw config.transactionMode == .ansi ? TeradataWireError.rolledBackByStop : TeradataWireError.cancelled
guard case .server(let code, _)? = error as? TeradataWireError else {
// Refused by its reader rather than the server, so the request ran.
socketLock.withLock { _transaction.ran(kinds) }
throw error
}
let abortRolledBack = socketLock.withLock { () -> Bool in
let heldTransaction = _transaction.abortRollsBackTransaction
_transaction.failed(kinds, code: code)
return heldTransaction
}
if stopped, code == Self.userAbortCode {
throw abortRolledBack ? TeradataWireError.rolledBackByStop : TeradataWireError.cancelled
}
throw error
case .outputEnded where stopped:
socketLock.withLock { _transaction.ran(kinds) }
throw TeradataWireError.cancelled
case .answered, .outputEnded:
socketLock.withLock { _transaction.ran(kinds) }
try reader.finish(onColumns: onColumns)
return reader.activityCount
}
Expand Down Expand Up @@ -578,7 +690,7 @@
let sockaddrIn = addr.withMemoryRebound(to: sockaddr_in.self, capacity: 1) { $0.pointee }
var inAddr = sockaddrIn.sin_addr
guard inet_ntop(AF_INET, &inAddr, &buffer, socklen_t(INET_ADDRSTRLEN)) != nil else { return nil }
return String(cString: buffer)

Check warning on line 693 in apple/Packages/TableProCore/Sources/TableProTeradataCore/TeradataConnection.swift

View workflow job for this annotation

GitHub Actions / macos / macOS Tests

'init(cString:)' is deprecated: Use String(decoding: array, as: UTF8.self) instead, after truncating the null termination. [#DeprecatedDeclaration]
}
}

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,8 @@ public enum TeradataWireError: Error, CustomStringConvertible, LocalizedError {
case cancelled
// Stop aborted the request, and the server rolled back the transaction it ran in.
case rolledBackByStop
case unreadableColumn(name: String, typeCode: UInt16)
case openTransactionBlocksDatabaseSwitch

public var description: String {
switch self {
Expand All @@ -20,9 +22,20 @@ public enum TeradataWireError: Error, CustomStringConvertible, LocalizedError {
case .unsupported(let what): return "unsupported: \(what)"
case .cancelled: return "cancelled"
case .rolledBackByStop: return "stopped, and the server rolled back the transaction (\(TeradataConnection.userAbortCode))"
case .unreadableColumn(let name, let typeCode): return Self.unreadableColumnMessage(name: name, typeCode: typeCode)
case .openTransactionBlocksDatabaseSwitch:
return String(localized: "Commit or roll back the open transaction before switching database.")
}
}

private static func unreadableColumnMessage(name: String, typeCode: UInt16) -> String {
let typeName = TeradataColumnType.knownWireTypeName(typeCode) ?? String(typeCode)
let format = typeCode & 0xFFFE == TeradataType.number
? String(localized: "Column \"%1$@\" has Teradata type %2$@, which TablePro cannot read yet. CAST it to DECIMAL or VARCHAR in the query.")
: String(localized: "Column \"%1$@\" has Teradata type %2$@, which TablePro cannot read yet. CAST it to VARCHAR in the query.")
return String(format: format, name, typeName)
}

public var errorDescription: String? { description }
}

Expand Down
Loading
Loading