类
class DriverManager
public class DriverManager {}
功能：支持运行时根据驱动名获取数据库驱动实例。
static func deregister(String)
public static func deregister(driverName: String): Unit
功能：按名称取消注册数据库驱动（如果存在）。本函数并发安全。
参数：
- driverName: String - 驱动名称。
示例：
import std.database.sql.*
main() {
// 使用一个假设已注册的驱动名称来演示取消注册功能
// 注意：在实际使用中，需要先注册驱动才能取消注册
let driverName = "exampleDriver"
// 尝试取消注册驱动（如果存在）
DriverManager.deregister(driverName)
println("Attempted to deregister driver: ${driverName}")
// 显示当前已注册的驱动列表
let drivers = DriverManager.drivers()
println("Currently registered drivers: ${drivers}")
}
运行结果：
Attempted to deregister driver: exampleDriver
Currently registered drivers: []
static func drivers()
public static func drivers(): Array<String>
功能：返回已注册数据库驱动名称的列表（名称已按照字典序排序）。本方法并发安全。
返回值：
示例：
import std.database.sql.*
main() {
// 获取当前已注册的驱动列表
let driverList = DriverManager.drivers()
println("Currently registered drivers:")
if (driverList.size == 0) {
println(" No drivers registered")
} else {
for (driverName in driverList) {
println(" - ${driverName}")
}
}
// 注册一个示例驱动（仅用于演示）
// 注意：实际使用中需要提供真正的Driver实现
println("\nAfter registering a driver:")
println(" (In practice, you would register an actual driver implementation)")
}
运行结果：
Currently registered drivers:
No drivers registered
After registering a driver:
(In practice, you would register an actual driver implementation)
static func getDriver(String)
public static func getDriver(driverName: String): Option<Driver>
功能：按名称获取已注册的数据库驱动，如果不存在返回 None。本函数并发安全。
参数：
- driverName: String - 驱动名称。
返回值：
示例：
import std.database.sql.*
main() {
// 尝试获取一个驱动实例
let driverName = "nonExistentDriver"
let driverOption = DriverManager.getDriver(driverName)
// 检查驱动是否存在
if (driverOption.isNone()) {
println("Driver '${driverName}' not found")
} else {
println("Driver '${driverName}' found")
}
// 显示如何正确处理Option类型
match (driverOption) {
case None => println("No driver returned for '${driverName}'")
case Some(driver) => println("Got driver instance for '${driverName}'")
}
}
运行结果：
Driver 'nonExistentDriver' not found
No driver returned for 'nonExistentDriver'
static func register(String, Driver)
public static func register(driverName: String, driver: Driver): Unit
功能：按名称和驱动实例注册数据库驱动，名称和实例一一对应。本方法并发安全。
参数：
异常：
- SqlException - 当指定的驱动名称已经存在时，抛出异常。
示例：
import std.database.sql.*
main() {
// 演示如何注册数据库驱动
// 注意：实际使用中需要提供真正的Driver实现
println("To register a database driver:")
println("1. Create a class that implements the Driver interface")
println("2. Call DriverManager.register(driverName, driverInstance)")
// 显示注册驱动时可能抛出的异常
println("\nNote: DriverManager.register() may throw SqlException")
println("if a driver with the same name is already registered.")
}
运行结果：
To register a database driver:
1. Create a class that implements the Driver interface
2. Call DriverManager.register(driverName, driverInstance)
Note: DriverManager.register() may throw SqlException
if a driver with the same name is already registered.
class PooledDatasource
public class PooledDatasource <: Datasource {
public init(datasource: Datasource)
}
功能：数据库连接池类，提供数据库连接池能力。
父类型：
prop connectionTimeout
public mut prop connectionTimeout: Duration
功能：从池中获取连接的超时时间。
类型：Duration
异常：
- ArithmeticException - 当该属性被设置为 Duration.Max 或 Duration.Min 时，抛此异常。
- SqlException - 当获取连接超时后，抛出此异常。
示例：
import std.database.sql.*
main() {
// 创建一个PooledDatasource实例（需要提供一个Datasource实现）
// 这里我们使用一个简化的示例
println("Example for PooledDatasource.connectionTimeout property:")
println("To set the connection timeout:")
println(" pooledDatasource.connectionTimeout = Duration.hour")
println("To get the connection timeout:")
println(" let timeout = pooledDatasource.connectionTimeout")
println(" println(\"Connection timeout: \${timeout}\")") // 使用转义字符避免变量替换
}
运行结果：
Example for PooledDatasource.connectionTimeout property:
To set the connection timeout:
pooledDatasource.connectionTimeout = Duration.hour
To get the connection timeout:
let timeout = pooledDatasource.connectionTimeout
println("Connection timeout: ${timeout}")
prop idleTimeout
public mut prop idleTimeout: Duration
功能：允许连接在池中闲置的最长时间，超过这个时间的空闲连接可能会被回收。
类型：Duration
示例：
import std.database.sql.*
main() {
// 创建一个PooledDatasource实例（需要提供一个Datasource实现）
// 这里我们使用一个简化的示例
println("Example for PooledDatasource.idleTimeout property:")
println("To set the idle timeout:")
println(" pooledDatasource.idleTimeout = Duration.hour")
println("To get the idle timeout:")
println(" let timeout = pooledDatasource.idleTimeout")
println(" println(\"Idle timeout: \${timeout}\")") // 使用转义字符避免变量替换
}
运行结果：
Example for PooledDatasource.idleTimeout property:
To set the idle timeout:
pooledDatasource.idleTimeout = Duration.hour
To get the idle timeout:
let timeout = pooledDatasource.idleTimeout
println("Idle timeout: ${timeout}")
prop keepaliveTime
public mut prop keepaliveTime: Duration
功能：检查空闲连接健康状况的间隔时间，防止它被数据库或网络基础设施超时。
类型：Duration
示例：
import std.database.sql.*
main() {
// 创建一个PooledDatasource实例（需要提供一个Datasource实现）
// 这里我们使用一个简化的示例
println("Example for PooledDatasource.keepaliveTime property:")
println("To set the keepalive time:")
println(" pooledDatasource.keepaliveTime = Duration.hour")
println("To get the keepalive time:")
println(" let time = pooledDatasource.keepaliveTime")
println(" println(\"Keepalive time: \${time}\")") // 使用转义字符避免变量替换
}
运行结果：
Example for PooledDatasource.keepaliveTime property:
To set the keepalive time:
pooledDatasource.keepaliveTime = Duration.hour
To get the keepalive time:
let time = pooledDatasource.keepaliveTime
println("Keepalive time: ${time}")
prop maxIdleSize
public mut prop maxIdleSize: Int32
功能：最大空闲连接数量，超过这个数量的空闲连接会被关闭，负数或 0 表示无限制。
类型：Int32
示例：
import std.database.sql.*
main() {
// 创建一个PooledDatasource实例（需要提供一个Datasource实现）
// 这里我们使用一个简化的示例
println("Example for PooledDatasource.maxIdleSize property:")
println("To set the maximum idle size:")
println(" pooledDatasource.maxIdleSize = 10")
println("To get the maximum idle size:")
println(" let size = pooledDatasource.maxIdleSize")
println(" println(\"Max idle size: \${size}\")") // 使用转义字符避免变量替换
}
运行结果：
Example for PooledDatasource.maxIdleSize property:
To set the maximum idle size:
pooledDatasource.maxIdleSize = 10
To get the maximum idle size:
let size = pooledDatasource.maxIdleSize
println("Max idle size: ${size}")
prop maxLifeTime
public mut prop maxLifeTime: Duration
功能：自连接创建以来的最大持续时间，在该持续时间之后，连接将自动关闭。
类型：Duration
示例：
import std.database.sql.*
main() {
// 创建一个PooledDatasource实例（需要提供一个Datasource实现）
// 这里我们使用一个简化的示例
println("Example for PooledDatasource.maxLifeTime property:")
println("To set the maximum lifetime:")
println(" pooledDatasource.maxLifeTime = Duration.hour")
println("To get the maximum lifetime:")
println(" let time = pooledDatasource.maxLifeTime")
println(" println(\"Max lifetime: \${time}\")") // 使用转义字符避免变量替换
}
运行结果：
Example for PooledDatasource.maxLifeTime property:
To set the maximum lifetime:
pooledDatasource.maxLifeTime = Duration.hour
To get the maximum lifetime:
let time = pooledDatasource.maxLifeTime
println("Max lifetime: ${time}")
prop maxSize
public mut prop maxSize: Int32
功能：连接池最大连接数量，负数或 0 表示无限制。
类型：Int32
示例：
import std.database.sql.*
main() {
// 创建一个PooledDatasource实例（需要提供一个Datasource实现）
// 这里我们使用一个简化的示例
println("Example for PooledDatasource.maxSize property:")
println("To set the maximum size:")
println(" pooledDatasource.maxSize = 20")
println("To get the maximum size:")
println(" let size = pooledDatasource.maxSize")
println(" println(\"Max size: \${size}\")") // 使用转义字符避免变量替换
}
运行结果：
Example for PooledDatasource.maxSize property:
To set the maximum size:
pooledDatasource.maxSize = 20
To get the maximum size:
let size = pooledDatasource.maxSize
println("Max size: ${size}")
init(Datasource)
public init(datasource: Datasource)
功能：通过数据源 datasource 构造一个 PooledDatasource 实例，入参必须为 Datasource 对象。
参数：
- datasource: Datasource - 数据源。
示例：
import std.database.sql.*
main() {
// 创建一个PooledDatasource实例
// 需要提供一个Datasource实现
println("Example for PooledDatasource.init(Datasource) constructor:")
println("To create a PooledDatasource:")
println(" let pooledDatasource = PooledDatasource(datasource)")
println("Where 'datasource' is an implementation of the Datasource interface")
}
运行结果：
Example for PooledDatasource.init(Datasource) constructor:
To create a PooledDatasource:
let pooledDatasource = PooledDatasource(datasource)
Where 'datasource' is an implementation of the Datasource interface
func close()
public func close(): Unit
功能：关闭连接池中的所有连接并阻止其他连接请求。调用该方法会阻塞至所有连接关闭并归还到连接池。
示例：
import std.database.sql.*
main() {
// 使用PooledDatasource的close函数
println("Example for PooledDatasource.close() function:")
println("To close a PooledDatasource:")
println(" pooledDatasource.close()")
println("This will close all connections in the pool and block until all connections are returned to the pool.")
}
运行结果：
Example for PooledDatasource.close() function:
To close a PooledDatasource:
pooledDatasource.close()
This will close all connections in the pool and block until all connections are returned to the pool.
func connect()
public func connect(): Connection
功能：获取一个连接。
返回值：
- Connection - 获取到的连接。
示例：
import std.database.sql.*
main() {
// 使用PooledDatasource的connect函数
println("Example for PooledDatasource.connect() function:")
println("To get a connection from the pool:")
println(" let connection = pooledDatasource.connect()")
println(" // Use the connection for database operations")
println(" // ...")
println(" // Remember to close the connection when done")
println(" connection.close()")
}
运行结果：
Example for PooledDatasource.connect() function:
To get a connection from the pool:
let connection = pooledDatasource.connect()
// Use the connection for database operations
// ...
// Remember to close the connection when done
connection.close()
func isClosed()
public func isClosed(): Bool
功能：判断连接是否关闭。
返回值：
- Bool - 连接是否关闭。
示例：
import std.database.sql.*
main() {
// 使用PooledDatasource的isClosed函数
println("Example for PooledDatasource.isClosed() function:")
println("To check if a PooledDatasource is closed:")
println(" let isClosed = pooledDatasource.isClosed()")
println(" if (isClosed) {")
println(" println(\"The datasource is closed\")")
println(" } else {")
println(" println(\"The datasource is open\")")
println(" }")
}
运行结果：
Example for PooledDatasource.isClosed() function:
To check if a PooledDatasource is closed:
let isClosed = pooledDatasource.isClosed()
if (isClosed) {
println("The datasource is closed")
} else {
println("The datasource is open")
}
func setOption(String, String)
public func setOption(key: String, value: String): Unit
功能：设置数据库驱动连接选项（公钥在 SqlOption 中预定义）。
参数：
示例：
import std.database.sql.*
main() {
// 使用PooledDatasource的setOption函数
println("Example for PooledDatasource.setOption(String, String) function:")
println("To set a database driver connection option:")
println(" pooledDatasource.setOption(\"optionKey\", \"optionValue\")")
println("Common options are predefined in SqlOption class")
}
运行结果：
Example for PooledDatasource.setOption(String, String) function:
To set a database driver connection option:
pooledDatasource.setOption("optionKey", "optionValue")
Common options are predefined in SqlOption class
class SqlBigInt (deprecated)
public class SqlBigInt <: SqlDbType {
public init(v: Int64)
}
功能：大整数，对应仓颉 Int64 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlBigInt (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlBigInt实例
let sqlBigInt = SqlBigInt(1234567890)
// 访问name属性
let name = sqlBigInt.name
println("SqlBigInt name: ${name}")
}
运行结果：
SqlBigInt name: SqlBigInt
prop value
public mut prop value: Int64
功能：该数据的值。
类型：Int64
示例：
import std.database.sql.*
main() {
// 创建一个SqlBigInt实例
let sqlBigInt = SqlBigInt(1234567890)
// 访问value属性
let value = sqlBigInt.value
println("SqlBigInt value: ${value}")
// 修改value属性
sqlBigInt.value = 987654321
println("Modified SqlBigInt value: ${sqlBigInt.value}")
}
运行结果：
SqlBigInt value: 1234567890
Modified SqlBigInt value: 987654321
init(Int64)
public init(v: Int64)
功能：根据传入参数 v 构造一个 SqlBigInt (deprecated) 实例。
参数：
- v: Int64 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlBigInt的构造函数
let sqlBigInt = SqlBigInt(1234567890)
println("Created SqlBigInt with value: ${sqlBigInt.value}")
// 访问name属性
println("SqlBigInt name: ${sqlBigInt.name}")
}
运行结果：
Created SqlBigInt with value: 1234567890
SqlBigInt name: SqlBigInt
class SqlBinary (deprecated)
public class SqlBinary <: SqlDbType {
public init(v: Array<Byte>)
}
功能：定长二进制字符串，对应仓颉 Array<Byte> 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlBinary (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlBinary实例
let bytes: Array<Byte> = [1, 2, 3, 4, 5]
let sqlBinary = SqlBinary(bytes)
// 访问name属性
let name = sqlBinary.name
println("SqlBinary name: ${name}")
}
运行结果：
SqlBinary name: SqlBinary
prop value
public mut prop value: Array<Byte>
功能：该数据的值。
示例：
import std.database.sql.*
main() {
// 创建一个SqlBinary实例
let bytes: Array<Byte> = [1, 2, 3, 4, 5]
let sqlBinary = SqlBinary(bytes)
// 访问value属性
let value = sqlBinary.value
println("SqlBinary value size: ${value.size}")
for (i in 0..value.size) {
println(" Byte ${i}: ${value[i]}")
}
// 修改value属性
let newBytes: Array<Byte> = [10, 20, 30]
sqlBinary.value = newBytes
println("Modified SqlBinary value size: ${sqlBinary.value.size}")
}
运行结果：
SqlBinary value size: 5
Byte 0: 1
Byte 1: 2
Byte 2: 3
Byte 3: 4
Byte 4: 5
Modified SqlBinary value size: 3
init(Array<Byte>)
public init(v: Array<Byte>)
功能：根据传入参数 v 构造一个 SqlBinary (deprecated) 实例。
参数：
示例：
import std.database.sql.*
main() {
// 使用SqlBinary的构造函数
let bytes: Array<Byte> = [1, 2, 3, 4, 5]
let sqlBinary = SqlBinary(bytes)
println("Created SqlBinary with ${sqlBinary.value.size} bytes")
// 访问name属性
println("SqlBinary name: ${sqlBinary.name}")
}
运行结果：
Created SqlBinary with 5 bytes
SqlBinary name: SqlBinary
class SqlBlob (deprecated)
public class SqlBlob <: SqlDbType {
public init(v: InputStream)
}
功能：变长超大二进制字符串（BINARY LARGE OBJECT），对应仓颉 InputStream 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlBlob (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.io.*
main() {
// 创建一个SqlBlob实例
let data: Array<Byte> = [1, 2, 3, 4, 5]
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlBlob = SqlBlob(inputStream)
// 访问name属性
let name = sqlBlob.name
println("SqlBlob name: ${name}")
}
运行结果：
SqlBlob name: SqlBlob
prop value
public mut prop value: InputStream
功能：该数据的值。
类型：InputStream
示例：
import std.database.sql.*
import std.io.*
main() {
// 创建一个SqlBlob实例
let data: Array<Byte> = [1, 2, 3, 4, 5]
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlBlob = SqlBlob(inputStream)
// 访问value属性
let value = sqlBlob.value
println("SqlBlob value: InputStream")
// 修改value属性
let newData: Array<Byte> = [10, 20, 30]
let newByteBuffer = ByteBuffer(newData)
let newInputStream = BufferedInputStream(newByteBuffer)
sqlBlob.value = newInputStream
println("Modified SqlBlob value")
}
运行结果：
SqlBlob value: InputStream
Modified SqlBlob value
init(InputStream)
public init(v: InputStream)
功能：根据传入参数 v 构造一个 SqlBlob (deprecated) 实例。
参数：
- v: InputStream - 传入的数据。
示例：
import std.database.sql.*
import std.io.*
main() {
// 使用SqlBlob的构造函数
let data: Array<Byte> = [1, 2, 3, 4, 5]
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlBlob = SqlBlob(inputStream)
println("Created SqlBlob with InputStream")
// 访问name属性
println("SqlBlob name: ${sqlBlob.name}")
}
运行结果：
Created SqlBlob with InputStream
SqlBlob name: SqlBlob
class SqlBool (deprecated)
public class SqlBool <: SqlDbType {
public init(v: Bool)
}
功能：布尔类型，对应仓颉 Bool 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlBool(deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlBool实例
let sqlBool = SqlBool(true)
// 访问name属性
let name = sqlBool.name
println("SqlBool name: ${name}")
}
运行结果：
SqlBool name: SqlBool
prop value
public mut prop value: Bool
功能：该数据的值。
类型：Bool
示例：
import std.database.sql.*
main() {
// 创建一个SqlBool实例
let sqlBool = SqlBool(true)
// 访问value属性
let value = sqlBool.value
println("SqlBool value: ${value}")
// 修改value属性
sqlBool.value = false
println("Modified SqlBool value: ${sqlBool.value}")
}
运行结果：
SqlBool value: true
Modified SqlBool value: false
init(Bool)
public init(v: Bool)
功能：根据传入参数 v 构造一个 SqlBool(deprecated) 实例。
参数：
- v: Bool - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlBool的构造函数
let sqlBool = SqlBool(true)
println("Created SqlBool with value: ${sqlBool.value}")
// 访问name属性
println("SqlBool name: ${sqlBool.name}")
}
运行结果：
Created SqlBool with value: true
SqlBool name: SqlBool
class SqlByte (deprecated)
public class SqlByte <: SqlDbType {
public init(v: Int8)
}
功能：字节，对应仓颉 Int8 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlByte (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlByte实例
let sqlByte = SqlByte(65)
// 访问name属性
let name = sqlByte.name
println("SqlByte name: ${name}")
}
运行结果：
SqlByte name: SqlByte
prop value
public mut prop value: Int8
功能：该数据的值。
类型：Int8
示例：
import std.database.sql.*
main() {
// 创建一个SqlByte实例
let sqlByte = SqlByte(65)
// 访问value属性
let value = sqlByte.value
println("SqlByte value: ${value}")
// 修改value属性
sqlByte.value = 90
println("Modified SqlByte value: ${sqlByte.value}")
}
运行结果：
SqlByte value: 65
Modified SqlByte value: 90
init(Int8)
public init(v: Int8)
功能：根据传入参数 v 构造一个 SqlByte (deprecated) 实例。
参数：
- v: Int8 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlByte的构造函数
let sqlByte = SqlByte(65)
println("Created SqlByte with value: ${sqlByte.value}")
// 访问name属性
println("SqlByte name: ${sqlByte.name}")
}
运行结果：
Created SqlByte with value: 65
SqlByte name: SqlByte
class SqlChar (deprecated)
public class SqlChar <: SqlDbType {
public init(v: String)
}
功能：定长字符串，对应仓颉 String 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlChar (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlChar实例
let sqlChar = SqlChar("A")
// 访问name属性
let name = sqlChar.name
println("SqlChar name: ${name}")
}
运行结果：
SqlChar name: SqlChar
prop value
public mut prop value: String
功能：该数据的值。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlChar实例
let sqlChar = SqlChar("Hello")
// 访问value属性
let value = sqlChar.value
println("SqlChar value: ${value}")
// 修改value属性
sqlChar.value = "World"
println("Modified SqlChar value: ${sqlChar.value}")
}
运行结果：
SqlChar value: Hello
Modified SqlChar value: World
init(String)
public init(v: String)
功能：根据传入参数 v 构造一个 SqlChar (deprecated) 实例。
参数：
- v: String - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlChar的构造函数
let sqlChar = SqlChar("Hello")
println("Created SqlChar with value: ${sqlChar.value}")
// 访问name属性
println("SqlChar name: ${sqlChar.name}")
}
运行结果：
Created SqlChar with value: Hello
SqlChar name: SqlChar
class SqlClob (deprecated)
public class SqlClob <: SqlDbType {
public init(v: InputStream)
}
功能：变长超大字符串（RUNE LARGE OBJECT），对应仓颉 InputStream 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlClob。
类型：String
示例：
import std.database.sql.*
import std.io.*
main() {
// 创建一个SqlClob实例
let data: Array<Byte> = [72, 101, 108, 108, 111] // "Hello"的ASCII码
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlClob = SqlClob(inputStream)
// 访问name属性
let name = sqlClob.name
println("SqlClob name: ${name}")
}
运行结果：
SqlClob name: SqlClob
prop value
public mut prop value: InputStream
功能：该数据的值。
类型：InputStream
示例：
import std.database.sql.*
import std.io.*
main() {
// 创建一个SqlClob实例
let data: Array<Byte> = [72, 101, 108, 108, 111] // "Hello"的ASCII码
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlClob = SqlClob(inputStream)
// 访问value属性
let value = sqlClob.value
println("SqlClob value: InputStream")
// 修改value属性
let newData: Array<Byte> = [87, 111, 114, 108, 100] // "World"的ASCII码
let newByteBuffer = ByteBuffer(newData)
let newInputStream = BufferedInputStream(newByteBuffer)
sqlClob.value = newInputStream
println("Modified SqlClob value")
}
运行结果：
SqlClob value: InputStream
Modified SqlClob value
init(InputStream)
public init(v: InputStream)
功能：根据传入参数 v 构造一个 SqlClob 实例。
参数：
- v: InputStream - 传入的数据。
示例：
import std.database.sql.*
import std.io.*
main() {
// 使用SqlClob的构造函数
let data: Array<Byte> = [72, 101, 108, 108, 111] // "Hello"的ASCII码
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlClob = SqlClob(inputStream)
println("Created SqlClob with InputStream")
// 访问name属性
println("SqlClob name: ${sqlClob.name}")
}
运行结果：
Created SqlClob with InputStream
SqlClob name: SqlClob
class SqlDate (deprecated)
public class SqlDate <: SqlDbType {
public init(v: DateTime)
}
功能：日期，仅年月日有效，对应仓颉 DateTime 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlDate (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个SqlDate实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
let sqlDate = SqlDate(dateTime)
// 访问name属性
let name = sqlDate.name
println("SqlDate name: ${name}")
}
运行结果：
SqlDate name: SqlDate
prop value
public mut prop value: DateTime
功能：该数据的值。
类型：DateTime
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个SqlDate实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
let sqlDate = SqlDate(dateTime)
// 访问value属性
let value = sqlDate.value
println("SqlDate value: ${value}")
// 修改value属性
let newDateTime = dateTime.addDays(10)
sqlDate.value = newDateTime
println("Modified SqlDate value: ${sqlDate.value}")
}
可能的运行结果：
SqlDate value: 2012-01-01T00:00:00Z
Modified SqlDate value: 2012-01-11T00:00:00Z
init(DateTime)
public init(v: DateTime)
功能：根据传入参数 v 构造一个 SqlDate (deprecated) 实例。
参数：
- v: DateTime - 传入的数据。
示例：
import std.database.sql.*
import std.time.*
main() {
// 使用SqlDate的构造函数
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
let sqlDate = SqlDate(dateTime)
println("Created SqlDate with value: ${sqlDate.value}")
// 访问name属性
println("SqlDate name: ${sqlDate.name}")
}
可能的运行结果：
Created SqlDate with value: 2012-01-01T00:00:00Z
SqlDate name: SqlDate
class SqlDecimal (deprecated)
public class SqlDecimal <: SqlDbType {
public init(v: Decimal)
}
功能：高精度数，对应仓颉 Decimal 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlDecimal (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.math.numeric.*
main() {
// 创建一个SqlDecimal实例
let decimal = Decimal(123.456)
let sqlDecimal = SqlDecimal(decimal)
// 访问name属性
let name = sqlDecimal.name
println("SqlDecimal name: ${name}")
}
运行结果：
SqlDecimal name: SqlDecimal
prop value
public mut prop value: Decimal
功能：该数据的值。
类型：Decimal
示例：
import std.database.sql.*
import std.math.numeric.*
main() {
// 创建一个SqlDecimal实例
let decimal = Decimal(123.456)
let sqlDecimal = SqlDecimal(decimal)
// 访问value属性
let value = sqlDecimal.value
println("SqlDecimal value: ${value}")
// 修改value属性
let newDecimal = Decimal(789.012)
sqlDecimal.value = newDecimal
println("Modified SqlDecimal value: ${sqlDecimal.value}")
}
运行结果：
SqlDecimal value: 123.4560000000000030695446184836328029632568359375
Modified SqlDecimal value: 789.011999999999943611328490078449249267578125
init(Decimal)
public init(v: Decimal)
功能：根据传入参数 v 构造一个 SqlDecimal (deprecated) 实例。
参数：
- v: Decimal - 传入的数据。
示例：
import std.database.sql.*
import std.math.numeric.*
main() {
// 使用SqlDecimal的构造函数
let decimal = Decimal(123.456)
let sqlDecimal = SqlDecimal(decimal)
println("Created SqlDecimal with value: ${sqlDecimal.value}")
// 访问name属性
println("SqlDecimal name: ${sqlDecimal.name}")
}
运行结果：
Created SqlDecimal with value: 123.4560000000000030695446184836328029632568359375
SqlDecimal name: SqlDecimal
class SqlDouble (deprecated)
public class SqlDouble <: SqlDbType {
public init(v: Float64)
}
功能：双精度数，对应仓颉 Float64 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlDouble (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlDouble实例
let sqlDouble = SqlDouble(123.456)
// 访问name属性
let name = sqlDouble.name
println("SqlDouble name: ${name}")
}
运行结果：
SqlDouble name: SqlDouble
prop value
public mut prop value: Float64
功能：该数据的值。
类型：Float64
示例：
import std.database.sql.*
main() {
// 创建一个SqlDouble实例
let sqlDouble = SqlDouble(123.456)
// 访问value属性
let value = sqlDouble.value
println("SqlDouble value: ${value}")
// 修改value属性
sqlDouble.value = 789.012
println("Modified SqlDouble value: ${sqlDouble.value}")
}
运行结果：
SqlDouble value: 123.456000
Modified SqlDouble value: 789.012000
init(Float64)
public init(v: Float64)
功能：根据传入参数 v 构造一个 SqlDouble (deprecated) 实例。
参数：
- v: Float64 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlDouble的构造函数
let sqlDouble = SqlDouble(123.456)
println("Created SqlDouble with value: ${sqlDouble.value}")
// 访问name属性
println("SqlDouble name: ${sqlDouble.name}")
}
运行结果：
Created SqlDouble with value: 123.456000
SqlDouble name: SqlDouble
class SqlInteger (deprecated)
public class SqlInteger <: SqlDbType {
public init(v: Int32)
}
功能：中整数，对应仓颉 Int32 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlInteger (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlInteger实例
let sqlInteger = SqlInteger(123456)
// 访问name属性
let name = sqlInteger.name
println("SqlInteger name: ${name}")
}
运行结果：
SqlInteger name: SqlInteger
prop value
public mut prop value: Int32
功能：该数据的值。
类型：Int32
示例：
import std.database.sql.*
main() {
// 创建一个SqlInteger实例
let sqlInteger = SqlInteger(123456)
// 访问value属性
let value = sqlInteger.value
println("SqlInteger value: ${value}")
// 修改value属性
sqlInteger.value = 789012
println("Modified SqlInteger value: ${sqlInteger.value}")
}
运行结果：
SqlInteger value: 123456
Modified SqlInteger value: 789012
init(Int32)
public init(v: Int32)
功能：根据传入参数 v 构造一个 SqlInteger (deprecated) 实例。
参数：
- v: Int32 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlInteger的构造函数
let sqlInteger = SqlInteger(123456)
println("Created SqlInteger with value: ${sqlInteger.value}")
// 访问name属性
println("SqlInteger name: ${sqlInteger.name}")
}
运行结果：
Created SqlInteger with value: 123456
SqlInteger name: SqlInteger
class SqlInterval (deprecated)
public class SqlInterval <: SqlDbType {
public init(v: Duration)
}
功能：时间间隔，对应仓颉 Duration 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlInterval (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.core.*
main() {
// 创建一个SqlInterval实例
let duration = 123456789 * Duration.millisecond
let sqlInterval = SqlInterval(duration)
// 访问name属性
let name = sqlInterval.name
println("SqlInterval name: ${name}")
}
运行结果：
SqlInterval name: SqlInterval
prop value
public mut prop value: Duration
功能：该数据的值。
类型：Duration
示例：
import std.database.sql.*
import std.core.*
main() {
// 创建一个SqlInterval实例
let duration = 123456789 * Duration.millisecond
let sqlInterval = SqlInterval(duration)
// 访问value属性
let value = sqlInterval.value
println("SqlInterval value: ${value}")
// 修改value属性
let newDuration = 987654321 * Duration.millisecond
sqlInterval.value = newDuration
println("Modified SqlInterval value: ${sqlInterval.value}")
}
运行结果：
SqlInterval value: 1d10h17m36s789ms
Modified SqlInterval value: 11d10h20m54s321ms
init(Duration)
public init(v: Duration)
功能：根据传入参数 v 构造一个 SqlInterval (deprecated) 实例。
参数：
- v: Duration - 传入的数据。
示例：
import std.database.sql.*
import std.core.*
main() {
// 使用SqlInterval的构造函数
let duration = 123456789 * Duration.millisecond
let sqlInterval = SqlInterval(duration)
println("Created SqlInterval with value: ${sqlInterval.value}")
// 访问name属性
println("SqlInterval name: ${sqlInterval.name}")
}
运行结果：
Created SqlInterval with value: 1d10h17m36s789ms
SqlInterval name: SqlInterval
class SqlNullableBigInt (deprecated)
public class SqlNullableBigInt <: SqlNullableDbType {
public init(v: ?Int64)
}
功能：大整数，对应仓颉 Int64 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableBigInt (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableBigInt实例
let sqlNullableBigInt = SqlNullableBigInt(Some(123456i64))
// 访问name属性
let name = sqlNullableBigInt.name
println("SqlNullableBigInt name: ${name}")
}
运行结果：
SqlNullableBigInt name: SqlNullableBigInt
prop value
public mut prop value: ?Int64
功能：该数据的值。
类型：?Int64
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableBigInt实例
let sqlNullableBigInt = SqlNullableBigInt(Some(123456i64))
// 访问value属性
let value = sqlNullableBigInt.value
println("SqlNullableBigInt value: ${value}")
// 修改value属性
sqlNullableBigInt.value = Some(789012i64)
println("Modified SqlNullableBigInt value: ${sqlNullableBigInt.value}")
}
运行结果：
SqlNullableBigInt value: Some(123456)
Modified SqlNullableBigInt value: Some(789012)
init(?Int64)
public init(v: ?Int64)
功能：根据传入参数 v 构造一个 SqlNullableBigInt (deprecated) 实例。
参数：
- v: ?Int64 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlNullableBigInt的构造函数
let sqlNullableBigInt = SqlNullableBigInt(Some(123456i64))
println("Created SqlNullableBigInt with value: ${sqlNullableBigInt.value}")
// 访问name属性
println("SqlNullableBigInt name: ${sqlNullableBigInt.name}")
}
运行结果：
Created SqlNullableBigInt with value: Some(123456)
SqlNullableBigInt name: SqlNullableBigInt
class SqlNullableBinary (deprecated)
public class SqlNullableBinary <: SqlNullableDbType {
public init(v: ?Array<Byte>)
}
功能：定长二进制字符串，对应仓颉 Array<Byte> 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableBinary (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableBinary实例
let bytes = [1u8, 2u8, 3u8, 4u8]
let sqlNullableBinary = SqlNullableBinary(Some(bytes))
// 访问name属性
let name = sqlNullableBinary.name
println("SqlNullableBinary name: ${name}")
}
运行结果：
SqlNullableBinary name: SqlNullableBinary
prop value
public mut prop value: ?Array<Byte>
功能：该数据的值。
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableBinary实例
let bytes = [1u8, 2u8, 3u8, 4u8]
let sqlNullableBinary = SqlNullableBinary(Some(bytes))
// 访问value属性
let value = sqlNullableBinary.value
println("SqlNullableBinary value: ${value}")
// 修改value属性
let newBytes = [5u8, 6u8, 7u8, 8u8]
sqlNullableBinary.value = Some(newBytes)
println("Modified SqlNullableBinary value: ${sqlNullableBinary.value}")
}
运行结果：
SqlNullableBinary value: Some([1, 2, 3, 4])
Modified SqlNullableBinary value: Some([5, 6, 7, 8])
init(?Array<Byte>)
public init(v: ?Array<Byte>)
功能：根据传入参数 v 构造一个 SqlNullableBinary (deprecated) 实例。
参数：
示例：
import std.database.sql.*
main() {
// 使用SqlNullableBinary的构造函数
let bytes = [1u8, 2u8, 3u8, 4u8]
let sqlNullableBinary = SqlNullableBinary(Some(bytes))
println("Created SqlNullableBinary with value: ${sqlNullableBinary.value}")
// 访问name属性
println("SqlNullableBinary name: ${sqlNullableBinary.name}")
}
运行结果：
Created SqlNullableBinary with value: Some([1, 2, 3, 4])
SqlNullableBinary name: SqlNullableBinary
class SqlNullableBlob (deprecated)
public class SqlNullableBlob <: SqlNullableDbType {
public init(v: ?InputStream)
}
功能：变长超大二进制字符串（BINARY LARGE OBJECT），对应仓颉 InputStream 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableBlob (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.io.*
main() {
// 创建一个SqlBlob实例
let data: Array<Byte> = [1, 2, 3, 4, 5]
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlNullableBlob = SqlNullableBlob(Some(inputStream))
// 访问name属性
let name = sqlNullableBlob.name
println("SqlNullableBlob name: ${name}")
}
运行结果：
SqlNullableBlob name: SqlNullableBlob
prop value
public mut prop value: ?InputStream
功能：该数据的值。
类型：?InputStream
示例：
import std.database.sql.*
import std.io.*
main() {
// 创建一个SqlNullableBlob实例
let data: Array<Byte> = [1, 2, 3, 4, 5]
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlNullableBlob = SqlNullableBlob(Some(inputStream))
// 访问value属性
let value = sqlNullableBlob.value
match (value) {
case None => println("SqlNullableBlob value is None")
case Some(_) => println("SqlNullableBlob value is Some(InputStream)")
}
// 修改value属性
sqlNullableBlob.value = None
match (sqlNullableBlob.value) {
case None => println("Modified SqlNullableBlob value is None")
case Some(_) => println("Modified SqlNullableBlob value is Some(InputStream)")
}
}
运行结果：
SqlNullableBlob value is Some(InputStream)
Modified SqlNullableBlob value is None
init(?InputStream)
public init(v: ?InputStream)
功能：根据传入参数 v 构造一个 SqlNullableBlob (deprecated) 实例。
参数：
- v: ?InputStream - 传入的数据。
示例：
import std.database.sql.*
import std.io.*
main() {
// 创建一个SqlBlob实例
let data: Array<Byte> = [1, 2, 3, 4, 5]
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlNullBlob = SqlNullableBlob(Some(inputStream))
// 访问name属性
let name = sqlNullBlob.name
println("SqlNullableBlob name: ${name}")
}
运行结果：
SqlNullableBlob name: SqlNullableBlob
class SqlNullableBool (deprecated)
public class SqlNullableBool <: SqlNullableDbType {
public init(v: ?Bool)
}
功能：布尔类型，对应仓颉 Bool 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableBool (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableBool实例
let sqlNullableBool = SqlNullableBool(Some(true))
// 访问name属性
let name = sqlNullableBool.name
println("SqlNullableBool name: ${name}")
}
运行结果：
SqlNullableBool name: SqlNullableBool
prop value
public mut prop value: ?Bool
功能：该数据的值。
类型：?Bool
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableBool实例
let sqlNullableBool = SqlNullableBool(Some(true))
// 访问value属性
let value = sqlNullableBool.value
println("SqlNullableBool value: ${value}")
// 修改value属性
sqlNullableBool.value = Some(false)
println("Modified SqlNullableBool value: ${sqlNullableBool.value}")
}
运行结果：
SqlNullableBool value: Some(true)
Modified SqlNullableBool value: Some(false)
init(?Bool)
public init(v: ?Bool)
功能：根据传入参数 v 构造一个 SqlNullableBool (deprecated) 实例。
参数：
- v: ?Bool - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlNullableBool的构造函数
let sqlNullableBool = SqlNullableBool(Some(true))
println("Created SqlNullableBool with value: ${sqlNullableBool.value}")
// 访问name属性
println("SqlNullableBool name: ${sqlNullableBool.name}")
}
运行结果：
Created SqlNullableBool with value: Some(true)
SqlNullableBool name: SqlNullableBool
class SqlNullableByte (deprecated)
public class SqlNullableByte <: SqlNullableDbType {
public init(v: ?Int8)
}
功能：字节，对应仓颉 Int8 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableByte (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableByte实例
let sqlNullableByte = SqlNullableByte(Some(123i8))
// 访问name属性
let name = sqlNullableByte.name
println("SqlNullableByte name: ${name}")
}
运行结果：
SqlNullableByte name: SqlNullableByte
prop value
public mut prop value: ?Int8
功能：该数据的值。
类型：?Int8
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableByte实例
let sqlNullableByte = SqlNullableByte(Some(123i8))
// 访问value属性
let value = sqlNullableByte.value
println("SqlNullableByte value: ${value}")
// 修改value属性
sqlNullableByte.value = Some(45i8)
println("Modified SqlNullableByte value: ${sqlNullableByte.value}")
}
运行结果：
SqlNullableByte value: Some(123)
Modified SqlNullableByte value: Some(45)
init(?Int8)
public init(v: ?Int8)
功能：根据传入参数 v 构造一个 SqlNullableByte (deprecated) 实例。
参数：
- v: ?Int8 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlNullableByte的构造函数
let sqlNullableByte = SqlNullableByte(Some(123i8))
println("Created SqlNullableByte with value: ${sqlNullableByte.value}")
// 访问name属性
println("SqlNullableByte name: ${sqlNullableByte.name}")
}
运行结果：
Created SqlNullableByte with value: Some(123)
SqlNullableByte name: SqlNullableByte
class SqlNullableChar (deprecated)
public class SqlNullableChar <: SqlNullableDbType {
public init(v: ?String)
}
功能：定长字符串，对应仓颉 String 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableChar (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableChar实例
let sqlNullableChar = SqlNullableChar(Some("Hello"))
// 访问name属性
let name = sqlNullableChar.name
println("SqlNullableChar name: ${name}")
}
运行结果：
SqlNullableChar name: SqlNullableChar
prop value
public mut prop value: ?String
功能：该数据的值。
类型：?String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableChar实例
let sqlNullableChar = SqlNullableChar(Some("Hello"))
// 访问value属性
let value = sqlNullableChar.value
println("SqlNullableChar value: ${value}")
// 修改value属性
sqlNullableChar.value = Some("World")
println("Modified SqlNullableChar value: ${sqlNullableChar.value}")
}
运行结果：
SqlNullableChar value: Some(Hello)
Modified SqlNullableChar value: Some(World)
init(?String)
public init(v: ?String)
功能：根据传入参数 v 构造一个 SqlNullableChar (deprecated) 实例。
参数：
- v: ?String - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlNullableChar的构造函数
let sqlNullableChar = SqlNullableChar(Some("Hello"))
println("Created SqlNullableChar with value: ${sqlNullableChar.value}")
// 访问name属性
println("SqlNullableChar name: ${sqlNullableChar.name}")
}
运行结果：
Created SqlNullableChar with value: Some(Hello)
SqlNullableChar name: SqlNullableChar
class SqlNullableClob (deprecated)
public class SqlNullableClob <: SqlNullableDbType {
public init(v: ?InputStream)
}
功能：变长超大字符串（RUNE LARGE OBJECT），对应仓颉 InputStream 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableClob (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.io.*
main() {
// 创建一个SqlNullableClob实例
let data: Array<Byte> = [72, 101, 108, 108, 111] // "Hello"的ASCII码
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlNullableClob = SqlNullableClob(Some(inputStream))
// 访问name属性
let name = sqlNullableClob.name
println("SqlNullableClob name: ${name}")
}
运行结果：
SqlNullableClob name: SqlNullableClob
prop value
public mut prop value: ?InputStream
功能：该数据的值。
类型：?InputStream
示例：
import std.database.sql.*
import std.io.*
main() {
// 创建一个SqlNullableClob实例
let data: Array<Byte> = [72, 101, 108, 108, 111] // "Hello"的ASCII码
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlNullableClob = SqlNullableClob(Some(inputStream))
// 访问value属性
let value = sqlNullableClob.value
match (value) {
case None => println("SqlNullableClob value is None")
case Some(_) => println("SqlNullableClob value is Some(InputStream)")
}
// 修改value属性
sqlNullableClob.value = None
match (sqlNullableClob.value) {
case None => println("Modified SqlNullableClob value is None")
case Some(_) => println("Modified SqlNullableClob value is Some(InputStream)")
}
}
运行结果：
SqlNullableClob value is Some(InputStream)
Modified SqlNullableClob value is None
init(?InputStream)
public init(v: ?InputStream)
功能：根据传入参数 v 构造一个 SqlNullableClob (deprecated) 实例。
参数：
- v: ?InputStream - 传入的数据。
示例：
import std.database.sql.*
import std.io.*
main() {
// 使用SqlNullableClob的构造函数
let data: Array<Byte> = [72, 101, 108, 108, 111] // "Hello"的ASCII码
let byteBuffer = ByteBuffer(data)
let inputStream = BufferedInputStream(byteBuffer)
let sqlNullableClob = SqlNullableClob(Some(inputStream))
println("Created SqlNullableClob with value: Some(InputStream)")
// 访问name属性
println("SqlNullableClob name: ${sqlNullableClob.name}")
}
运行结果：
Created SqlNullableClob with value: Some(InputStream)
SqlNullableClob name: SqlNullableClob
class SqlNullableDate (deprecated)
public class SqlNullableDate <: SqlNullableDbType {
public init(v: ?DateTime)
}
功能：日期，仅年月日有效，对应仓颉 DateTime 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableDate (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个SqlNullableDate实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
let sqlNullableDate = SqlNullableDate(Some(dateTime))
// 访问name属性
let name = sqlNullableDate.name
println("SqlNullableDate name: ${name}")
}
运行结果：
SqlNullableDate name: SqlNullableDate
prop value
public mut prop value: ?DateTime
功能：该数据的值。
类型：?DateTime
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个SqlNullableDate实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
let sqlNullableDate = SqlNullableDate(Some(dateTime))
// 访问value属性
let value = sqlNullableDate.value
println("SqlNullableDate value: ${value}")
// 修改value属性为None
sqlNullableDate.value = None
println("Modified SqlNullableDate value: ${sqlNullableDate.value}")
}
可能的运行结果：
SqlNullableDate value: Some(2012-01-01T00:00:00Z)
Modified SqlNullableDate value: None
init(?DateTime)
public init(v: ?DateTime)
功能：根据传入参数 v 构造一个 SqlNullableDate (deprecated) 实例。
参数：
- v: ?DateTime - 传入的数据。
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个SqlNullableDate实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
let sqlNullableDate = SqlNullableDate(Some(dateTime))
// 访问name属性
let name = sqlNullableDate.name
println("SqlNullableDate name: ${name}")
}
运行结果：
SqlNullableDate name: SqlNullableDate
class SqlNullableDecimal (deprecated)
public class SqlNullableDecimal <: SqlNullableDbType {
public init(v: ?Decimal)
}
功能：高精度数，对应仓颉 Decimal 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableDecimal (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.math.numeric.*
main() {
// 创建一个SqlNullableDecimal实例
let decimalValue = Decimal(123.45)
let sqlNullableDecimal = SqlNullableDecimal(Some(decimalValue))
// 访问name属性
let name = sqlNullableDecimal.name
println("SqlNullableDecimal name: ${name}")
}
运行结果：
SqlNullableDecimal name: SqlNullableDecimal
prop value
public mut prop value: ?Decimal
功能：该数据的值。
类型：?Decimal
示例：
import std.database.sql.*
import std.math.numeric.*
main() {
// 创建一个SqlNullableDecimal实例
let decimalValue = Decimal(123.45)
let sqlNullableDecimal = SqlNullableDecimal(Some(decimalValue))
// 访问value属性
let value = sqlNullableDecimal.value
println("SqlNullableDecimal value: ${value}")
// 修改value属性为None
sqlNullableDecimal.value = None
println("Modified SqlNullableDecimal value: ${sqlNullableDecimal.value}")
}
运行结果：
SqlNullableDecimal value: Some(123.4500000000000028421709430404007434844970703125)
Modified SqlNullableDecimal value: None
init(?Decimal)
public init(v: ?Decimal)
功能：根据传入参数 v 构造一个 SqlNullableDecimal (deprecated) 实例。
参数：
- v: ?Decimal - 传入的数据。
示例：
import std.database.sql.*
import std.math.numeric.*
main() {
// 使用SqlNullableDecimal的构造函数
let decimalValue = Decimal(123.45)
let sqlNullableDecimal = SqlNullableDecimal(Some(decimalValue))
println("Created SqlNullableDecimal with value: ${sqlNullableDecimal.value}")
// 访问name属性
println("SqlNullableDecimal name: ${sqlNullableDecimal.name}")
}
运行结果：
Created SqlNullableDecimal with value: Some(123.4500000000000028421709430404007434844970703125)
SqlNullableDecimal name: SqlNullableDecimal
class SqlNullableDouble (deprecated)
public class SqlNullableDouble <: SqlNullableDbType {
public init(v: ?Float64)
}
功能：双精度数，对应仓颉 Float64 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableDouble (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableDouble实例
let sqlNullableDouble = SqlNullableDouble(Some(123.45f64))
// 访问name属性
let name = sqlNullableDouble.name
println("SqlNullableDouble name: ${name}")
}
运行结果：
SqlNullableDouble name: SqlNullableDouble
prop value
public mut prop value: ?Float64
功能：该数据的值。
类型：?Float64
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableDouble实例
let sqlNullableDouble = SqlNullableDouble(Some(123.45f64))
// 访问value属性
let value = sqlNullableDouble.value
println("SqlNullableDouble value: ${value}")
// 修改value属性为None
sqlNullableDouble.value = None
println("Modified SqlNullableDouble value: ${sqlNullableDouble.value}")
}
运行结果：
SqlNullableDouble value: Some(123.450000)
Modified SqlNullableDouble value: None
init(?Float64)
public init(v: ?Float64)
功能：根据传入参数 v 构造一个 SqlNullableDouble (deprecated) 实例。
参数：
- v: ?Float64 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlNullableDouble的构造函数
let sqlNullableDouble = SqlNullableDouble(Some(123.45f64))
println("Created SqlNullableDouble with value: ${sqlNullableDouble.value}")
// 访问name属性
println("SqlNullableDouble name: ${sqlNullableDouble.name}")
}
运行结果：
Created SqlNullableDouble with value: Some(123.450000)
SqlNullableDouble name: SqlNullableDouble
class SqlNullableInteger (deprecated)
public class SqlNullableInteger <: SqlNullableDbType {
public init(v: ?Int32)
}
功能：中整数，对应仓颉 Int32 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableInteger (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableInteger实例
let sqlNullableInteger = SqlNullableInteger(Some(123i32))
// 访问name属性
let name = sqlNullableInteger.name
println("SqlNullableInteger name: ${name}")
}
运行结果：
SqlNullableInteger name: SqlNullableInteger
prop value
public mut prop value: ?Int32
功能：该数据的值。
类型：?Int32
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableInteger实例
let sqlNullableInteger = SqlNullableInteger(Some(123i32))
// 访问value属性
let value = sqlNullableInteger.value
println("SqlNullableInteger value: ${value}")
// 修改value属性为None
sqlNullableInteger.value = None
println("Modified SqlNullableInteger value: ${sqlNullableInteger.value}")
}
运行结果：
SqlNullableInteger value: Some(123)
Modified SqlNullableInteger value: None
init(?Int32)
public init(v: ?Int32)
功能：根据传入参数 v 构造一个 SqlNullableInteger (deprecated) 实例。
参数：
- v: ?Int32 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlNullableInteger的构造函数
let sqlNullableInteger = SqlNullableInteger(Some(123i32))
println("Created SqlNullableInteger with value: ${sqlNullableInteger.value}")
// 访问name属性
println("SqlNullableInteger name: ${sqlNullableInteger.name}")
}
运行结果：
Created SqlNullableInteger with value: Some(123)
SqlNullableInteger name: SqlNullableInteger
class SqlNullableInterval (deprecated)
public class SqlNullableInterval <: SqlNullableDbType {
public init(v: ?Duration)
}
功能：时间间隔，对应仓颉 Duration 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableInterval (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableInterval实例
let duration = 123456789 * Duration.millisecond
let sqlNullableInterval = SqlNullableInterval(Some(duration))
// 访问name属性
let name = sqlNullableInterval.name
println("SqlNullableInterval name: ${name}")
}
运行结果：
SqlNullableInterval name: SqlNullableInterval
prop value
public mut prop value: ?Duration
功能：该数据的值。
类型：?Duration
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableInterval实例
let duration = 123456789 * Duration.millisecond
let sqlNullableInterval = SqlNullableInterval(Some(duration))
// 访问value属性
let value = sqlNullableInterval.value
println("SqlNullableInterval value: ${value}")
// 修改value属性为None
sqlNullableInterval.value = None
println("Modified SqlNullableInterval value: ${sqlNullableInterval.value}")
}
运行结果：
SqlNullableInterval value: Some(1d10h17m36s789ms)
Modified SqlNullableInterval value: None
init(?Duration)
public init(v: ?Duration)
功能：根据传入参数 v 构造一个 SqlNullableInterval (deprecated) 实例。
参数：
- v: ?Duration - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlNullableInterval的构造函数
let sqlNullableInterval = SqlNullableInterval(None)
println("Created SqlNullableInterval with value: ${sqlNullableInterval.value}")
// 访问name属性
println("SqlNullableInterval name: ${sqlNullableInterval.name}")
}
运行结果：
Created SqlNullableInterval with value: None
SqlNullableInterval name: SqlNullableInterval
class SqlNullableReal (deprecated)
public class SqlNullableReal <: SqlNullableDbType {
public init(v: ?Float32)
}
功能：浮点数，对应仓颉 Float32 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableReal (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableReal实例
let sqlNullableReal = SqlNullableReal(Some(123.45f32))
// 访问name属性
let name = sqlNullableReal.name
println("SqlNullableReal name: ${name}")
}
运行结果：
SqlNullableReal name: SqlNullableReal
prop value
public mut prop value: ?Float32
功能：该数据的值。
类型：?Float32
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableReal实例
let sqlNullableReal = SqlNullableReal(Some(123.45f32))
// 访问value属性
let value = sqlNullableReal.value
println("SqlNullableReal value: ${value}")
// 修改value属性为None
sqlNullableReal.value = None
println("Modified SqlNullableReal value: ${sqlNullableReal.value}")
}
运行结果：
SqlNullableReal value: Some(123.449997)
Modified SqlNullableReal value: None
init(?Float32)
public init(v: ?Float32)
功能：根据传入参数 v 构造一个 SqlNullableReal (deprecated) 实例。
参数：
- v: ?Float32 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlNullableReal的构造函数
let sqlNullableReal = SqlNullableReal(Some(123.45f32))
println("Created SqlNullableReal with value: ${sqlNullableReal.value}")
// 访问name属性
println("SqlNullableReal name: ${sqlNullableReal.name}")
}
运行结果：
Created SqlNullableReal with value: Some(123.449997)
SqlNullableReal name: SqlNullableReal
class SqlNullableSmallInt (deprecated)
public class SqlNullableSmallInt <: SqlNullableDbType {
public init(v: ?Int16)
}
功能：小整数，对应仓颉 Int16 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableSmallInt (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableSmallInt实例
let sqlNullableSmallInt = SqlNullableSmallInt(Some(123i16))
// 访问name属性
let name = sqlNullableSmallInt.name
println("SqlNullableSmallInt name: ${name}")
}
运行结果：
SqlNullableSmallInt name: SqlNullableSmallInt
prop value
public mut prop value: ?Int16
功能：该数据的值。
类型：?Int16
示例：
import std.database.sql.*
main() {
// 创建一个SqlNullableSmallInt实例
let sqlNullableSmallInt = SqlNullableSmallInt(Some(123i16))
// 访问value属性
let value = sqlNullableSmallInt.value
println("SqlNullableSmallInt value: ${value}")
// 修改value属性为None
sqlNullableSmallInt.value = None
println("Modified SqlNullableSmallInt value: ${sqlNullableSmallInt.value}")
}
运行结果：
SqlNullableSmallInt value: Some(123)
Modified SqlNullableSmallInt value: None
init(?Int16)
public init(v: ?Int16)
功能：根据传入参数 v 构造一个 SqlNullableSmallInt (deprecated) 实例。
参数：
- v: ?Int16 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlNullableSmallInt的构造函数
let sqlNullableSmallInt = SqlNullableSmallInt(Some(123i16))
println("Created SqlNullableSmallInt with value: ${sqlNullableSmallInt.value}")
// 访问name属性
println("SqlNullableSmallInt name: ${sqlNullableSmallInt.name}")
}
运行结果：
Created SqlNullableSmallInt with value: Some(123)
SqlNullableSmallInt name: SqlNullableSmallInt
class SqlNullableTime (deprecated)
public class SqlNullableTime <: SqlNullableDbType {
public init(v: ?DateTime)
}
功能：时间，仅时分秒毫秒有效，对应仓颉 DateTime 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableTime (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlNullableTime的构造函数
let sqlNullableTime = SqlNullableTime(None)
println("Created SqlNullableTime with value: ${sqlNullableTime.value}")
// 访问name属性
println("SqlNullableTime name: ${sqlNullableTime.name}")
}
运行结果：
Created SqlNullableTime with value: None
SqlNullableTime name: SqlNullableTime
prop value
public mut prop value: ?DateTime
功能：该数据的值。
类型：?DateTime
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlNullableTime的构造函数创建一个有值的实例
let sqlNullableTimeWithValue = SqlNullableTime(Some(dateTime))
// 访问value属性
let value1 = sqlNullableTimeWithValue.value
println("SqlNullableTime value: ${value1}")
// 使用SqlNullableTime的构造函数创建一个无值的实例
let sqlNullableTimeWithoutValue = SqlNullableTime(None)
// 访问value属性
let value2 = sqlNullableTimeWithoutValue.value
println("SqlNullableTime value: ${value2}")
}
可能的运行结果：
SqlNullableTime value: Some(2012-01-01T00:00:00Z)
SqlNullableTime value: None
init(?DateTime)
public init(v: ?DateTime)
功能：根据传入参数 v 构造一个 SqlNullableTime (deprecated) 实例。
参数：
- v: ?DateTime - 传入的数据。
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlNullableTime的构造函数创建一个有值的实例
let sqlNullableTimeWithValue = SqlNullableTime(Some(dateTime))
println("Created SqlNullableTime with value: ${sqlNullableTimeWithValue.value}")
// 使用SqlNullableTime的构造函数创建一个无值的实例
let sqlNullableTimeWithoutValue = SqlNullableTime(None)
println("Created SqlNullableTime with value: ${sqlNullableTimeWithoutValue.value}")
}
可能的运行结果：
Created SqlNullableTime with value: Some(2012-01-01T00:00:00Z)
Created SqlNullableTime with value: None
class SqlNullableTimestamp (deprecated)
public class SqlNullableTimestamp <: SqlNullableDbType {
public init(v: ?DateTime)
}
功能：时间戳，对应仓颉 DateTime 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableTimestamp (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlNullableTimestamp的构造函数
let sqlNullableTimestamp = SqlNullableTimestamp(None)
// 访问name属性
println("SqlNullableTimestamp name: ${sqlNullableTimestamp.name}")
}
运行结果：
SqlNullableTimestamp name: SqlNullableTimestamp
prop value
public mut prop value: ?DateTime
功能：该数据的值。
类型：?DateTime
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlNullableTimestamp的构造函数创建一个有值的实例
let sqlNullableTimestampWithValue = SqlNullableTimestamp(Some(dateTime))
// 访问value属性
let value1 = sqlNullableTimestampWithValue.value
println("SqlNullableTimestamp value: ${value1}")
// 使用SqlNullableTimestamp的构造函数创建一个无值的实例
let sqlNullableTimestampWithoutValue = SqlNullableTimestamp(None)
// 访问value属性
let value2 = sqlNullableTimestampWithoutValue.value
println("SqlNullableTimestamp value: ${value2}")
}
可能的运行结果：
SqlNullableTimestamp value: Some(2012-01-01T00:00:00Z)
SqlNullableTimestamp value: None
init(?DateTime)
public init(v: ?DateTime)
功能：根据传入参数 v 构造一个 SqlNullableTimestamp (deprecated) 实例。
参数：
- v: ?DateTime - 传入的数据。
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlNullableTimestamp的构造函数创建一个有值的实例
let sqlNullableTimestampWithValue = SqlNullableTimestamp(Some(dateTime))
println("Created SqlNullableTimestamp with value: ${sqlNullableTimestampWithValue.value}")
// 使用SqlNullableTimestamp的构造函数创建一个无值的实例
let sqlNullableTimestampWithoutValue = SqlNullableTimestamp(None)
println("Created SqlNullableTimestamp with value: ${sqlNullableTimestampWithoutValue.value}")
}
可能的运行结果：
Created SqlNullableTimestamp with value: Some(2012-01-01T00:00:00Z)
Created SqlNullableTimestamp with value: None
class SqlNullableTimeTz (deprecated)
public class SqlNullableTimeTz <: SqlNullableDbType {
public init(v: ?DateTime)
}
功能：带时区的时间，仅时分秒毫秒时区有效，对应仓颉 DateTime 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableTimeTz (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlNullableTimeTz的构造函数
let sqlNullableTimeTz = SqlNullableTimeTz(None)
// 访问name属性
println("SqlNullableTimeTz name: ${sqlNullableTimeTz.name}")
}
运行结果：
SqlNullableTimeTz name: SqlNullableTimeTz
prop value
public mut prop value: ?DateTime
功能：该数据的值。
类型：?DateTime
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlNullableTimeTz的构造函数创建一个有值的实例
let sqlNullableTimeTzWithValue = SqlNullableTimeTz(Some(dateTime))
// 访问value属性
let value1 = sqlNullableTimeTzWithValue.value
println("SqlNullableTimeTz value: ${value1}")
// 使用SqlNullableTimeTz的构造函数创建一个无值的实例
let sqlNullableTimeTzWithoutValue = SqlNullableTimeTz(None)
// 访问value属性
let value2 = sqlNullableTimeTzWithoutValue.value
println("SqlNullableTimeTz value: ${value2}")
}
可能的运行结果：
SqlNullableTimeTz value: Some(2012-01-01T00:00:00Z)
SqlNullableTimeTz value: None
init(?DateTime)
public init(v: ?DateTime)
功能：根据传入参数 v 构造一个 SqlNullableTimeTz (deprecated) 实例。
参数：
- v: ?DateTime - 传入的数据。
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlNullableTimeTz的构造函数创建一个有值的实例
let sqlNullableTimeTzWithValue = SqlNullableTimeTz(Some(dateTime))
println("Created SqlNullableTimeTz with value: ${sqlNullableTimeTzWithValue.value}")
// 使用SqlNullableTimeTz的构造函数创建一个无值的实例
let sqlNullableTimeTzWithoutValue = SqlNullableTimeTz(None)
println("Created SqlNullableTimeTz with value: ${sqlNullableTimeTzWithoutValue.value}")
}
可能的运行结果：
Created SqlNullableTimeTz with value: Some(2012-01-01T00:00:00Z)
Created SqlNullableTimeTz with value: None
class SqlNullableVarBinary (deprecated)
public class SqlNullableVarBinary <: SqlNullableDbType {
public init(v: ?Array<Byte>)
}
功能：变长二进制字符串，对应仓颉 Array<Byte> 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableVarBinary (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlNullableVarBinary的构造函数
let sqlNullableVarBinary = SqlNullableVarBinary(None)
// 访问name属性
println("SqlNullableVarBinary name: ${sqlNullableVarBinary.name}")
}
运行结果：
SqlNullableVarBinary name: SqlNullableVarBinary
prop value
public mut prop value: ?Array<Byte>
功能：该数据的值。
示例：
import std.database.sql.*
import std.core.*
main() {
// 创建一个Byte数组
let bytes: Array<Byte> = [1, 2, 3, 4]
// 使用SqlNullableVarBinary的构造函数创建一个有值的实例
let sqlNullableVarBinaryWithValue = SqlNullableVarBinary(Some(bytes))
// 访问value属性
let value1 = sqlNullableVarBinaryWithValue.value
println("SqlNullableVarBinary value: ${value1}")
// 使用SqlNullableVarBinary的构造函数创建一个无值的实例
let sqlNullableVarBinaryWithoutValue = SqlNullableVarBinary(None)
// 访问value属性
let value2 = sqlNullableVarBinaryWithoutValue.value
println("SqlNullableVarBinary value: ${value2}")
}
运行结果：
SqlNullableVarBinary value: Some([1, 2, 3, 4])
SqlNullableVarBinary value: None
init(?Array<Byte>)
public init(v: ?Array<Byte>)
功能：根据传入参数 v 构造一个 SqlNullableVarBinary (deprecated) 实例。
参数：
示例：
import std.database.sql.*
import std.core.*
main() {
// 创建一个Byte数组
let bytes: Array<Byte> = [5, 6, 7, 8]
// 使用SqlNullableVarBinary的构造函数创建一个有值的实例
let sqlNullableVarBinaryWithValue = SqlNullableVarBinary(Some(bytes))
println("Created SqlNullableVarBinary with value: ${sqlNullableVarBinaryWithValue.value}")
// 使用SqlNullableVarBinary的构造函数创建一个无值的实例
let sqlNullableVarBinaryWithoutValue = SqlNullableVarBinary(None)
println("Created SqlNullableVarBinary with value: ${sqlNullableVarBinaryWithoutValue.value}")
}
运行结果：
Created SqlNullableVarBinary with value: Some([5, 6, 7, 8])
Created SqlNullableVarBinary with value: None
class SqlNullableVarchar (deprecated)
public class SqlNullableVarchar <: SqlNullableDbType {
public init(v: ?String)
}
功能：变长字符串，对应仓颉 String 类型，可为数据库 Null 值。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlNullableVarchar (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlNullableVarchar的构造函数
let sqlNullableVarchar = SqlNullableVarchar(None)
// 访问name属性
println("SqlNullableVarchar name: ${sqlNullableVarchar.name}")
}
运行结果：
SqlNullableVarchar name: SqlNullableVarchar
prop value
public mut prop value: ?String
功能：该数据的值。 类型：?String
示例：
import std.database.sql.*
main() {
// 使用SqlNullableVarchar的构造函数创建一个有值的实例
let sqlNullableVarcharWithValue = SqlNullableVarchar(Some("Hello"))
// 访问value属性
let value1 = sqlNullableVarcharWithValue.value
println("SqlNullableVarchar value: ${value1}")
// 使用SqlNullableVarchar的构造函数创建一个无值的实例
let sqlNullableVarcharWithoutValue = SqlNullableVarchar(None)
// 访问value属性
let value2 = sqlNullableVarcharWithoutValue.value
println("SqlNullableVarchar value: ${value2}")
}
运行结果：
SqlNullableVarchar value: Some(Hello)
SqlNullableVarchar value: None
init(?String)
public init(v: ?String)
功能：根据传入参数 v 构造一个 SqlNullableVarchar (deprecated) 实例。
参数：
- v: ?String - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlNullableVarchar的构造函数创建一个有值的实例
let sqlNullableVarcharWithValue = SqlNullableVarchar(Some("World"))
println("Created SqlNullableVarchar with value: ${sqlNullableVarcharWithValue.value}")
// 使用SqlNullableVarchar的构造函数创建一个无值的实例
let sqlNullableVarcharWithoutValue = SqlNullableVarchar(None)
println("Created SqlNullableVarchar with value: ${sqlNullableVarcharWithoutValue.value}")
}
运行结果：
Created SqlNullableVarchar with value: Some(World)
Created SqlNullableVarchar with value: None
class SqlOption
public class SqlOption {
public static const URL: String = "url"
public static const Host: String = "host"
public static const Username: String = "username"
public static const Password: String = "password"
public static const Driver: String = "driver"
public static const Database: String = "database"
public static const Encoding: String = "encoding"
public static const ConnectionTimeout: String = "connection_timeout"
public static const UpdateTimeout: String = "update_timeout"
public static const QueryTimeout: String = "query_timeout"
public static const FetchRows: String = "fetch_rows"
public static const SSLMode: String = "ssl.mode"
public static const SSLModePreferred: String = "ssl.mode.preferred"
public static const SSLModeDisabled: String = "ssl.mode.disabled"
public static const SSLModeRequired: String = "ssl.mode.required"
public static const SSLModeVerifyCA: String = "ssl.mode.verify_ca"
public static const SSLModeVerifyFull: String = "ssl.mode.verify_full"
public static const SSLCA: String = "ssl.ca"
public static const SSLCert: String = "ssl.cert"
public static const SSLKey: String = "ssl.key"
public static const SSLKeyPassword: String = "ssl.key.password"
public static const SSLSni: String = "ssl.sni"
public static const Tls12Ciphersuites: String = "tls1.2.ciphersuites"
public static const Tls13Ciphersuites: String = "tls1.3.ciphersuites"
public static const TlsVersion: String = "tls.version"
}
功能：预定义的 sql 选项名称和值。如果需要扩展，请不要与这些名称和值冲突。
static const ConnectionTimeout
public static const ConnectionTimeout: String = "connection_timeout"
功能：获取 connect 操作的超时时间，单位 ms。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的ConnectionTimeout静态常量
println("Connection timeout key: ${SqlOption.ConnectionTimeout}")
}
运行结果：
Connection timeout key: connection_timeout
static const Database
public static const Database: String = "database"
功能：获取数据库名称。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的Database静态常量
println("Database key: ${SqlOption.Database}")
}
运行结果：
Database key: database
static const Driver
public static const Driver: String = "driver"
功能：获取数据库驱动名称，比如 postgres，opengauss。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的Driver静态常量
println("Driver key: ${SqlOption.Driver}")
}
运行结果：
Driver key: driver
static const Encoding
public static const Encoding: String = "encoding"
功能：获取数据库字符集编码类型。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的Encoding静态常量
println("Encoding key: ${SqlOption.Encoding}")
}
运行结果：
Encoding key: encoding
static const FetchRows
public static const FetchRows: String = "fetch_rows"
功能：获取每次获取额外数据时从数据库中提取的行数。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的FetchRows静态常量
println("Fetch rows key: ${SqlOption.FetchRows}")
}
运行结果：
Fetch rows key: fetch_rows
static const Host
public static const Host: String = "host"
功能：获取数据库服务器主机名或者 IP 地址。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的Host静态常量
println("Host key: ${SqlOption.Host}")
}
运行结果：
Host key: host
static const Password
public static const Password: String = "password"
功能：获取连接数据库的密码。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的Password静态常量
println("Password key: ${SqlOption.Password}")
}
运行结果：
Password key: password
static const QueryTimeout
public static const QueryTimeout: String = "query_timeout"
功能：获取 query 操作的超时时间，单位 ms。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的QueryTimeout静态常量
println("Query timeout key: ${SqlOption.QueryTimeout}")
}
运行结果：
Query timeout key: query_timeout
static const SSLCA
public static const SSLCA: String = "ssl.ca"
功能：证书颁发机构（ CA ）证书文件的路径名。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLCA静态常量
println("SSL CA key: ${SqlOption.SSLCA}")
}
运行结果：
SSL CA key: ssl.ca
static const SSLCert
public static const SSLCert: String = "ssl.cert"
功能：客户端 SSL 公钥证书文件的路径名。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLCert静态常量
println("SSL Cert key: ${SqlOption.SSLCert}")
}
运行结果：
SSL Cert key: ssl.cert
static const SSLKey
public static const SSLKey: String = "ssl.key"
功能：客户端 SSL 私钥文件的路径名。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLKey静态常量
println("SSL Key key: ${SqlOption.SSLKey}")
}
运行结果：
SSL Key key: ssl.key
static const SSLKeyPassword
public static const SSLKeyPassword: String = "ssl.key.password"
功能：客户端 SSL 私钥文件的密码。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLKeyPassword静态常量
println("SSL Key Password key: ${SqlOption.SSLKeyPassword}")
}
运行结果：
SSL Key Password key: ssl.key.password
static const SSLMode
public static const SSLMode: String = "ssl.mode"
功能：获取 SSLMode 传输层加密模式。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLMode静态常量
println("SSL Mode key: ${SqlOption.SSLMode}")
}
运行结果：
SSL Mode key: ssl.mode
static const SSLModeDisabled
public static const SSLModeDisabled: String = "ssl.mode.disabled"
功能：建立未加密的连接。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLModeDisabled静态常量
println("SSL Mode Disabled key: ${SqlOption.SSLModeDisabled}")
}
运行结果：
SSL Mode Disabled key: ssl.mode.disabled
static const SSLModePreferred
public static const SSLModePreferred: String = "ssl.mode.preferred"
功能：如果服务器支持加密连接，则建立加密连接；如果无法建立加密连接，则回退到未加密连接，这是 SSLMode 的默认值。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLModePreferred静态常量
println("SSL Mode Preferred key: ${SqlOption.SSLModePreferred}")
}
运行结果：
SSL Mode Preferred key: ssl.mode.preferred
static const SSLModeRequired
public static const SSLModeRequired: String = "ssl.mode.required"
功能：如果服务器支持加密连接，则建立加密连接。如果无法建立加密连接，则连接失败。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLModeRequired静态常量
println("SSL Mode Required key: ${SqlOption.SSLModeRequired}")
}
运行结果：
SSL Mode Required key: ssl.mode.required
static const SSLModeVerifyCA
public static const SSLModeVerifyCA: String = "ssl.mode.verify_ca"
功能：SSLModeVerifyCA 和 SSLModeRequired 类似，但是增加了校验服务器证书，如果校验失败，则连接失败。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLModeVerifyCA静态常量
println("SSL Mode Verify CA key: ${SqlOption.SSLModeVerifyCA}")
}
运行结果：
SSL Mode Verify CA key: ssl.mode.verify_ca
static const SSLModeVerifyFull
public static const SSLModeVerifyFull: String = "ssl.mode.verify_full"
功能：SSLModeVerifyFull 和 SSLModeVerifyCA 类似，但通过验证服务器证书中的标识与客户端连接的主机名是否匹配，来执行主机名身份验证。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLModeVerifyFull静态常量
println("SSL Mode Verify Full key: ${SqlOption.SSLModeVerifyFull}")
}
运行结果：
SSL Mode Verify Full key: ssl.mode.verify_full
static const SSLSni
public static const SSLSni: String = "ssl.sni"
功能：客户端通过该标识在握手过程开始时试图连接到哪个主机名。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的SSLSni静态常量
println("SSL SNI key: ${SqlOption.SSLSni}")
}
运行结果：
SSL SNI key: ssl.sni
static const Tls12Ciphersuites
public static const Tls12Ciphersuites: String = "tls1.2.ciphersuites"
功能：此选项指定客户端允许使用 TLSv1.2 及以下的加密连接使用哪些密码套件。
值为冒号分隔的字符串，比如 TLS_ECDHE_ECDSA_WITH_AES_128_GCM_[SHA256]():TLS_DHE_RSA_WITH_AES_128_CBC_SHA。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的Tls12Ciphersuites静态常量
println("TLS 1.2 Ciphersuites key: ${SqlOption.Tls12Ciphersuites}")
}
运行结果：
TLS 1.2 Ciphersuites key: tls1.2.ciphersuites
static const Tls13Ciphersuites
public static const Tls13Ciphersuites: String = "tls1.3.ciphersuites"
功能：此选项指定客户端允许使用 TLSv1.3 的加密连接使用哪些密码套件。
值为冒号分隔的字符串，比如 TLS_AES_256_GCM_[SHA384]():TLS_CHACHA20_POLY1305_[SHA256]()。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的Tls13Ciphersuites静态常量
println("TLS 1.3 Ciphersuites key: ${SqlOption.Tls13Ciphersuites}")
}
运行结果：
TLS 1.3 Ciphersuites key: tls1.3.ciphersuites
static const TlsVersion
public static const TlsVersion: String = "tls.version"
功能：支持的 TLS 版本号，值为逗号分隔的字符串，比如 "TLSv1.2,TLSv1.3"。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的TlsVersion静态常量
println("TLS Version key: ${SqlOption.TlsVersion}")
}
运行结果：
TLS Version key: tls.version
static const UpdateTimeout
public static const UpdateTimeout: String = "update_timeout"
功能：获取 update 操作的超时时间，单位 ms。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的UpdateTimeout静态常量
println("Update timeout key: ${SqlOption.UpdateTimeout}")
}
运行结果：
Update timeout key: update_timeout
static const URL
public static const URL: String = "url"
功能：获取数据库连接 URL 字符串。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的URL静态常量
println("URL key: ${SqlOption.URL}")
}
运行结果：
URL key: url
static const Username
public static const Username: String = "username"
功能：获取连接数据库的用户名。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlOption类的Username静态常量
println("Username key: ${SqlOption.Username}")
}
运行结果：
Username key: username
class SqlReal (deprecated)
public class SqlReal <: SqlDbType {
public init(v: Float32)
}
功能：浮点数，对应仓颉 Float32 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlReal (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlReal实例
let sqlReal = SqlReal(123.45f32)
// 访问name属性
let name = sqlReal.name
println("SqlReal name: ${name}")
}
运行结果：
SqlReal name: SqlReal
prop value
public mut prop value: Float32
功能：该数据的值。
类型：Float32
示例：
import std.database.sql.*
main() {
// 创建一个SqlReal实例
let sqlReal = SqlReal(123.45f32)
// 访问value属性
let value = sqlReal.value
println("SqlReal value: ${value}")
// 修改value属性
sqlReal.value = 54.321f32
println("Modified SqlReal value: ${sqlReal.value}")
}
运行结果：
SqlReal value: 123.449997
Modified SqlReal value: 54.320999
init(Float32)
public init(v: Float32)
功能：根据传入参数 v 构造一个 SqlReal (deprecated) 实例。
参数：
- v: Float32 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlReal的构造函数
let sqlReal = SqlReal(123.45f32)
println("Created SqlReal with value: ${sqlReal.value}")
// 访问name属性
println("SqlReal name: ${sqlReal.name}")
}
运行结果：
Created SqlReal with value: 123.449997
SqlReal name: SqlReal
class SqlSmallInt (deprecated)
public class SqlSmallInt <: SqlDbType {
public init(v: Int16)
}
功能：小整数，对应仓颉 Int16 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlSmallInt (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个SqlSmallInt实例
let sqlSmallInt = SqlSmallInt(123i16)
// 访问name属性
let name = sqlSmallInt.name
println("SqlSmallInt name: ${name}")
}
运行结果：
SqlSmallInt name: SqlSmallInt
prop value
public mut prop value: Int16
功能：该数据的值。
类型：Int16
示例：
import std.database.sql.*
main() {
// 创建一个SqlSmallInt实例
let sqlSmallInt = SqlSmallInt(123i16)
// 访问value属性
let value = sqlSmallInt.value
println("SqlSmallInt value: ${value}")
// 修改value属性
sqlSmallInt.value = 321i16
println("Modified SqlSmallInt value: ${sqlSmallInt.value}")
}
运行结果：
SqlSmallInt value: 123
Modified SqlSmallInt value: 321
init(Int16)
public init(v: Int16)
功能：根据传入参数 v 构造一个 SqlSmallInt (deprecated) 实例。
参数：
- v: Int16 - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlSmallInt的构造函数
let sqlSmallInt = SqlSmallInt(123i16)
println("Created SqlSmallInt with value: ${sqlSmallInt.value}")
// 访问name属性
println("SqlSmallInt name: ${sqlSmallInt.name}")
}
运行结果：
Created SqlSmallInt with value: 123
SqlSmallInt name: SqlSmallInt
class SqlTime (deprecated)
public class SqlTime <: SqlDbType {
public init(v: DateTime)
}
功能：时间，仅时分秒毫秒有效，对应仓颉 DateTime 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlTime (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.time.*
main() {
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlTime的构造函数
let sqlTime = SqlTime(dateTime)
println("Created SqlTime with value: ${sqlTime.value}")
// 访问name属性
println("SqlTime name: ${sqlTime.name}")
}
可能的运行结果：
Created SqlTime with value: 2012-01-01T00:00:00Z
SqlTime name: SqlTime
prop value
public mut prop value: DateTime
功能：该数据的值。
类型：DateTime
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlTime的构造函数创建一个实例
let sqlTimeWithValue = SqlTime(dateTime)
// 访问value属性
let value1 = sqlTimeWithValue.value
println("SqlTime value: ${value1}")
}
可能的运行结果：
SqlTime value: 2012-01-01T00:00:00Z
init(DateTime)
public init(v: DateTime)
功能：根据传入参数 v 构造一个 SqlTime (deprecated) 实例。
参数：
- v: DateTime - 传入的数据。
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlTime的构造函数创建一个实例
let sqlTimeWithValue = SqlTime(dateTime)
println("Created SqlTime with value: ${sqlTimeWithValue.value}")
}
可能的运行结果：
Created SqlTime with value: 2012-01-01T00:00:00Z
class SqlTimestamp (deprecated)
public class SqlTimestamp <: SqlDbType {
public init(v: DateTime)
}
功能：时间戳，对应仓颉 DateTime 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlTimestamp (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.time.*
main() {
// 使用SqlTimestamp的构造函数
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
let sqlTimestamp = SqlTimestamp(dateTime)
// 访问name属性
println("SqlTimestamp name: ${sqlTimestamp.name}")
}
运行结果：
SqlTimestamp name: SqlTimestamp
prop value
public mut prop value: DateTime
功能：该数据的值。
类型：DateTime
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlTimestamp的构造函数创建一个实例
let sqlTimestampWithValue = SqlTimestamp(dateTime)
// 访问value属性
let value1 = sqlTimestampWithValue.value
println("SqlTimestamp value: ${value1}")
}
可能的运行结果：
SqlTimestamp value: 2012-01-01T00:00:00Z
init(DateTime)
public init(v: DateTime)
功能：根据传入参数 v 构造一个 SqlTimestamp (deprecated) 实例。
参数：
- v: DateTime - 传入的数据。
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlTimestamp的构造函数创建一个实例
let sqlTimestampWithValue = SqlTimestamp(dateTime)
println("Created SqlTimestamp with value: ${sqlTimestampWithValue.value}")
}
可能的运行结果：
Created SqlTimestamp with value: 2012-01-01T00:00:00Z
class SqlTimeTz (deprecated)
public class SqlTimeTz <: SqlDbType {
public init(v: DateTime)
}
功能：带时区的时间，仅时分秒毫秒时区有效，对应仓颉 DateTime 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlTimeTz (deprecated)。
类型：String
示例：
import std.database.sql.*
import std.time.*
main() {
// 使用SqlTimeTz的构造函数
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
let sqlTimeTz = SqlTimeTz(dateTime)
// 访问name属性
println("SqlTimeTz name: ${sqlTimeTz.name}")
}
运行结果：
SqlTimeTz name: SqlTimeTz
prop value
public mut prop value: DateTime
功能：该数据的值。
类型：DateTime
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlTimeTz的构造函数创建一个实例
let sqlTimeTzWithValue = SqlTimeTz(dateTime)
// 访问value属性
let value1 = sqlTimeTzWithValue.value
println("SqlTimeTz value: ${value1}")
}
可能的运行结果：
SqlTimeTz value: 2012-01-01T00:00:00Z
init(DateTime)
public init(v: DateTime)
功能：根据传入参数 v 构造一个 SqlTimeTz (deprecated) 实例。
参数：
- v: DateTime - 传入的数据。
示例：
import std.database.sql.*
import std.time.*
main() {
// 创建一个DateTime实例
let dateTime = DateTime.of(year: 2012, month: 1, dayOfMonth: 1, hour: 0, minute: 0, second: 0)
// 使用SqlTimeTz的构造函数创建一个实例
let sqlTimeTzWithValue = SqlTimeTz(dateTime)
println("Created SqlTimeTz with value: ${sqlTimeTzWithValue.value}")
}
可能的运行结果：
Created SqlTimeTz with value: 2012-01-01T00:00:00Z
class SqlVarBinary (deprecated)
public class SqlVarBinary <: SqlDbType {
public init(v: Array<Byte>)
}
功能：变长二进制字符串，对应仓颉 Array<Byte> 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlVarBinary (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 创建一个Byte数组
let bytes: Array<Byte> = [1, 2, 3, 4]
// 使用SqlVarBinary的构造函数
let sqlVarBinary = SqlVarBinary(bytes)
// 访问name属性
println("SqlVarBinary name: ${sqlVarBinary.name}")
}
运行结果：
SqlVarBinary name: SqlVarBinary
prop value
public mut prop value: Array<Byte>
功能：该数据的值。
示例：
import std.database.sql.*
main() {
// 创建一个Byte数组
let bytes: Array<Byte> = [1, 2, 3, 4]
// 使用SqlVarBinary的构造函数创建一个实例
let sqlVarBinaryWithValue = SqlVarBinary(bytes)
// 访问value属性
let value1 = sqlVarBinaryWithValue.value
println("SqlVarBinary value: ${value1}")
}
运行结果：
SqlVarBinary value: [1, 2, 3, 4]
init(Array<Byte>)
public init(v: Array<Byte>)
功能：根据传入参数 v 构造一个 SqlVarBinary (deprecated) 实例。
参数：
示例：
import std.database.sql.*
main() {
// 创建一个Byte数组
let bytes: Array<Byte> = [5, 6, 7, 8]
// 使用SqlVarBinary的构造函数创建一个实例
let sqlVarBinaryWithValue = SqlVarBinary(bytes)
println("Created SqlVarBinary with value: ${sqlVarBinaryWithValue.value}")
}
运行结果：
Created SqlVarBinary with value: [5, 6, 7, 8]
class SqlVarchar (deprecated)
public class SqlVarchar <: SqlDbType {
public init(v: String)
}
功能：变长字符串，对应仓颉 String 类型。
注意：
未来版本即将废弃不再使用，使用仓颉原生类型替代。
父类型：
prop name
public prop name: String
功能：类型名称，即 SqlVarchar (deprecated)。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlVarchar的构造函数
let sqlVarchar = SqlVarchar("Hello")
// 访问name属性
println("SqlVarchar name: ${sqlVarchar.name}")
}
运行结果：
SqlVarchar name: SqlVarchar
prop value
public mut prop value: String
功能：该数据的值。
类型：String
示例：
import std.database.sql.*
main() {
// 使用SqlVarchar的构造函数创建一个实例
let sqlVarcharWithValue = SqlVarchar("Hello")
// 访问value属性
let value1 = sqlVarcharWithValue.value
println("SqlVarchar value: ${value1}")
}
运行结果：
SqlVarchar value: Hello
init(String)
public init(v: String)
功能：根据传入参数 v 构造一个 SqlVarchar (deprecated) 实例。
参数：
- v: String - 传入的数据。
示例：
import std.database.sql.*
main() {
// 使用SqlVarchar的构造函数创建一个实例
let sqlVarcharWithValue = SqlVarchar("World")
println("Created SqlVarchar with value: ${sqlVarcharWithValue.value}")
}
运行结果：
Created SqlVarchar with value: World