Index

Modules: env, v1/query_builder/enums, v1/query_builder/error, v1/query_builder/libs/mariadb/mariadb_impl, v1/query_builder/libs/mariadb/mariadb_lib, v1/query_builder/libs/mariadb/mariadb_rdb, v1/query_builder/libs/mysql/mysql_impl, v1/query_builder/libs/mysql/mysql_lib, v1/query_builder/libs/mysql/mysql_rdb, v1/query_builder/libs/postgres/postgres_impl, v1/query_builder/libs/postgres/postgres_lib, v1/query_builder/libs/postgres/postgres_rdb, v1/query_builder/libs/sqlite/sqlite_impl, v1/query_builder/libs/sqlite/sqlite_lib, v1/query_builder/libs/sqlite/sqlite_rdb, v1/query_builder/libs/surreal/surreal_impl, v1/query_builder/libs/surreal/surreal_lib, v1/query_builder/libs/surreal/surreal_rdb, v1/query_builder/log, v1/query_builder/models/database_types, v1/query_builder/models/mariadb/mariadb_connections, v1/query_builder/models/mariadb/mariadb_open, v1/query_builder/models/mariadb/mariadb_query, v1/query_builder/models/mariadb/mariadb_transaction, v1/query_builder/models/mariadb/mariadb_types, v1/query_builder/models/mariadb/query/mariadb_builder, v1/query_builder/models/mariadb/query/mariadb_generator, v1/query_builder/models/mysql/mysql_connections, v1/query_builder/models/mysql/mysql_open, v1/query_builder/models/mysql/mysql_query, v1/query_builder/models/mysql/mysql_transaction, v1/query_builder/models/mysql/mysql_types, v1/query_builder/models/mysql/query/mysql_builder, v1/query_builder/models/mysql/query/mysql_generator, v1/query_builder/models/postgres/poatgres_transaction, v1/query_builder/models/postgres/postgres_connections, v1/query_builder/models/postgres/postgres_open, v1/query_builder/models/postgres/postgres_query, v1/query_builder/models/postgres/postgres_types, v1/query_builder/models/postgres/query/postgres_builder, v1/query_builder/models/postgres/query/postgres_generator, v1/query_builder/models/sqlite/query/sqlite_builder, v1/query_builder/models/sqlite/query/sqlite_generator, v1/query_builder/models/sqlite/sqlite_connections, v1/query_builder/models/sqlite/sqlite_open, v1/query_builder/models/sqlite/sqlite_query, v1/query_builder/models/sqlite/sqlite_transaction, v1/query_builder/models/sqlite/sqlite_types, v1/query_builder/models/surreal/query/surreal_builder, v1/query_builder/models/surreal/query/surreal_generator, v1/query_builder/models/surreal/surreal_connections, v1/query_builder/models/surreal/surreal_open, v1/query_builder/models/surreal/surreal_query, v1/query_builder/models/surreal/surreal_types, v1/schema_builder/enums, v1/schema_builder/models/column, v1/schema_builder/models/table, v1/schema_builder/queries/mariadb/add_column, v1/schema_builder/queries/mariadb/change_column, v1/schema_builder/queries/mariadb/create_migration_table, v1/schema_builder/queries/mariadb/create_table, v1/schema_builder/queries/mariadb/drop_column, v1/schema_builder/queries/mariadb/drop_table, v1/schema_builder/queries/mariadb/mariadb_query_impl, v1/schema_builder/queries/mariadb/mariadb_query_type, v1/schema_builder/queries/mariadb/rename_column, v1/schema_builder/queries/mariadb/rename_table, v1/schema_builder/queries/mariadb/reset_table, v1/schema_builder/queries/mariadb/schema_utils, v1/schema_builder/queries/mariadb/sub/add_column_query, v1/schema_builder/queries/mariadb/sub/change_column_query, v1/schema_builder/queries/mariadb/sub/create_column_query, v1/schema_builder/queries/mysql/add_column, v1/schema_builder/queries/mysql/change_column, v1/schema_builder/queries/mysql/create_migration_table, v1/schema_builder/queries/mysql/create_table, v1/schema_builder/queries/mysql/drop_column, v1/schema_builder/queries/mysql/drop_table, v1/schema_builder/queries/mysql/mysql_query_impl, v1/schema_builder/queries/mysql/mysql_query_type, v1/schema_builder/queries/mysql/rename_column, v1/schema_builder/queries/mysql/rename_table, v1/schema_builder/queries/mysql/reset_table, v1/schema_builder/queries/mysql/schema_utils, v1/schema_builder/queries/mysql/sub/add_column_query, v1/schema_builder/queries/mysql/sub/change_column_query, v1/schema_builder/queries/mysql/sub/create_column_query, v1/schema_builder/queries/mysql/sub/is_exists, v1/schema_builder/queries/postgres/add_column, v1/schema_builder/queries/postgres/change_column, v1/schema_builder/queries/postgres/create_migration_table, v1/schema_builder/queries/postgres/create_table, v1/schema_builder/queries/postgres/drop_column, v1/schema_builder/queries/postgres/drop_table, v1/schema_builder/queries/postgres/postgres_query_impl, v1/schema_builder/queries/postgres/postgres_query_type, v1/schema_builder/queries/postgres/rename_column, v1/schema_builder/queries/postgres/rename_table, v1/schema_builder/queries/postgres/reset_table, v1/schema_builder/queries/postgres/schema_utils, v1/schema_builder/queries/postgres/sub/add_column_query, v1/schema_builder/queries/postgres/sub/change_column_query, v1/schema_builder/queries/postgres/sub/create_column_query, v1/schema_builder/queries/schema_interface, v1/schema_builder/queries/sqlite/add_column, v1/schema_builder/queries/sqlite/change_column, v1/schema_builder/queries/sqlite/create_migration_table, v1/schema_builder/queries/sqlite/create_table, v1/schema_builder/queries/sqlite/drop_column, v1/schema_builder/queries/sqlite/drop_table, v1/schema_builder/queries/sqlite/rename_column, v1/schema_builder/queries/sqlite/rename_table, v1/schema_builder/queries/sqlite/reset_table, v1/schema_builder/queries/sqlite/schema_utils, v1/schema_builder/queries/sqlite/sqlite_query_impl, v1/schema_builder/queries/sqlite/sqlite_query_type, v1/schema_builder/queries/sqlite/sub/add_column_query, v1/schema_builder/queries/sqlite/sub/create_column_query, v1/schema_builder/queries/surreal/add_column, v1/schema_builder/queries/surreal/change_column, v1/schema_builder/queries/surreal/create_migration_table, v1/schema_builder/queries/surreal/create_sequence_table, v1/schema_builder/queries/surreal/create_table, v1/schema_builder/queries/surreal/drop_column, v1/schema_builder/queries/surreal/drop_table, v1/schema_builder/queries/surreal/rename_column, v1/schema_builder/queries/surreal/rename_table, v1/schema_builder/queries/surreal/reset_table, v1/schema_builder/queries/surreal/schema_utils, v1/schema_builder/queries/surreal/sub/create_column_query, v1/schema_builder/queries/surreal/surreal_query_impl, v1/schema_builder/queries/surreal/surreal_query_type, v1/schema_builder/usecases/mariadb/alter, v1/schema_builder/usecases/mariadb/create, v1/schema_builder/usecases/mariadb/create_query_def, v1/schema_builder/usecases/mariadb/drop, v1/schema_builder/usecases/mysql/alter, v1/schema_builder/usecases/mysql/create, v1/schema_builder/usecases/mysql/create_query_def, v1/schema_builder/usecases/mysql/drop, v1/schema_builder/usecases/postgres/alter, v1/schema_builder/usecases/postgres/create, v1/schema_builder/usecases/postgres/create_query_def, v1/schema_builder/usecases/postgres/drop, v1/schema_builder/usecases/sqlite/alter, v1/schema_builder/usecases/sqlite/create, v1/schema_builder/usecases/sqlite/create_query_def, v1/schema_builder/usecases/sqlite/drop, v1/schema_builder/usecases/sub/migration_table_def, v1/schema_builder/usecases/surreal/alter, v1/schema_builder/usecases/surreal/create, v1/schema_builder/usecases/surreal/create_query_def, v1/schema_builder/usecases/surreal/drop.

API symbols

`$`:

• mariadb_connections: `$`(self: MariadbConnections | MariadbQuery): string
• mariadb_types: `$`(self: MariadbConnections): string
• mysql_connections: `$`(self: MysqlConnections | MysqlQuery): string
• mysql_types: `$`(self: MysqlConnections): string
• postgres_connections: `$`(self: PostgresConnections | PostgresQuery): string
• postgres_types: `$`(self: PostgresConnections): string
• sqlite_connections: `$`(self: SqliteConnections | SqliteQuery): string
• sqlite_types: `$`(self: SqliteConnections): string
• surreal_connections: `$`(self: SurrealConnections | SurrealQuery): string
• surreal_types: `$`(self: SurrealConnections): string
• surreal_types: `$`(self: SurrealId): string

`%`:

• surreal_types: `%`(self: SurrealId): JsonNode

`[]`:

• sqlite_lib: `[]`(row: InstantRow; col: int32): string

`distinct`:

• mariadb_query: `distinct`(self: MariadbQuery): MariadbQuery
• mysql_query: `distinct`(self: MysqlQuery): MysqlQuery
• postgres_query: `distinct`(self: PostgresQuery): PostgresQuery
• sqlite_query: `distinct`(self: SqliteQuery): SqliteQuery
• surreal_query: `distinct`(self: SurrealQuery): SurrealQuery

add:

• column: add(c: Column): Column

AddColumn:

• ColumnMigrationType.AddColumn

addColumn:

• add_column: addColumn(self: MariadbSchema; isReset: bool)
• add_column: addColumn(self: MysqlSchema; isReset: bool)
• add_column: addColumn(self: PostgresSchema; isReset: bool)
• add_column: addColumn(self: SqliteSchema; isReset: bool)
• add_column: addColumn(self: SurrealSchema; isReset: bool)

addColumnString:

• add_column_query: addColumnString(table: Table; column: Column): seq[string]
• add_column_query: addColumnString(table: Table; column: Column): seq[string]
• add_column_query: addColumnString(table: Table; column: Column): seq[string]
• add_column_query: addColumnString(rdb: SqliteConnections; table: Table; column: Column): seq[ string]

addIndexString:

• change_column_query: addIndexString(column: Column; table: Table): string
• change_column_query: addIndexString(column: Column; table: Table): string

add_slave:

• mariadb_rdb: add_slave(MySQL: PMySQL; host: cstring; port: cuint; user: cstring; passwd: cstring): cint
• mysql_rdb: add_slave(MySQL: PMySQL; host: cstring; port: cuint; user: cstring; passwd: cstring): cint

affected_rows:

• mariadb_rdb: affected_rows(MySQL: PMySQL): my_ulonglong
• mysql_rdb: affected_rows(MySQL: PMySQL): my_ulonglong

aggregate_context:

• sqlite_rdb: aggregate_context(para1: Pcontext; nBytes: int32): pointer

aggregate_count:

• sqlite_rdb: aggregate_count(para1: Pcontext): int32

ALLOC_MAX_BLOCK_TO_DROP:

• mariadb_rdb: ALLOC_MAX_BLOCK_TO_DROP
• mysql_rdb: ALLOC_MAX_BLOCK_TO_DROP

ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP:

• mariadb_rdb: ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP
• mysql_rdb: ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP

Alter:

• UsecaseType.Alter

alter:

• alter: alter(rdb: MariadbConnections; tables: varargs[Table])
• alter: alter(rdb: MysqlConnections; tables: varargs[Table])
• alter: alter(rdb: PostgresConnections; tables: varargs[Table])
• alter: alter(rdb: SqliteConnections; tables: varargs[Table])
• alter: alter(rdb: SurrealConnections; tables: varargs[Table])

alterAddForeignKey:

• create_column_query: alterAddForeignKey(column: Column; table: Table): string
• create_column_query: alterAddForeignKey(column: Column; table: Table): string

Asc:

• Order.Asc

autocommit:

• mariadb_rdb: autocommit(MySQL: PMySQL; auto_mode: my_bool): my_bool
• mysql_rdb: autocommit(MySQL: PMySQL; auto_mode: my_bool): my_bool

autoIncrement:

• column: autoIncrement(c: Column): Column

AUTO_INCREMENT_FLAG:

• mariadb_rdb: AUTO_INCREMENT_FLAG
• mysql_rdb: AUTO_INCREMENT_FLAG

avg:

• mariadb_query: avg(self: MariadbQuery; column: string): Future[Option[float]]
• mysql_query: avg(self: MysqlQuery; column: string): Future[Option[float]]
• postgres_query: avg(self: PostgresQuery; column: string): Future[Option[float]]
• sqlite_query: avg(self: SqliteQuery; column: string): Future[Option[float]]
• surreal_query: avg(self: SurrealQuery; column: string): Future[float]

avgBuilder:

• mariadb_builder: avgBuilder(self: MariadbQuery; column: string): string
• mysql_builder: avgBuilder(self: MysqlQuery; column: string): string
• postgres_builder: avgBuilder(self: PostgresQuery; column: string): string
• sqlite_builder: avgBuilder(self: SqliteQuery; column: string): string

backup_finish:

• sqlite_rdb: backup_finish(pBackup: PSqlite3_Backup): int32

backup_init:

• sqlite_rdb: backup_init(pDest: PSqlite3; zDestName: cstring; pSource: PSqlite3; zSourceName: cstring): PSqlite3_Backup

backup_pagecount:

• sqlite_rdb: backup_pagecount(pBackup: PSqlite3_Backup): int32

backup_remaining:

• sqlite_rdb: backup_remaining(pBackup: PSqlite3_Backup): int32

backup_step:

• sqlite_rdb: backup_step(pBackup: PSqlite3_Backup; nPage: int32): int32

begin:

• mariadb_query: begin(self: MariadbConnections): owned(Future[void])
• mysql_query: begin(self: MysqlConnections): owned(Future[void])
• postgres_query: begin(self: PostgresConnections): owned(Future[void])
• sqlite_query: begin(self: SqliteConnections): owned(Future[void])

bigInteger:

• column: bigInteger(_: type Column; name: string): Column

binary:

• column: binary(_: type Column; name: string): Column

BINARY_FLAG:

• mariadb_rdb: BINARY_FLAG
• mysql_rdb: BINARY_FLAG

BINCMP_FLAG:

• mariadb_rdb: BINCMP_FLAG
• mysql_rdb: BINCMP_FLAG

BIND:

• mariadb_rdb: BIND
• mysql_rdb: BIND

bind_blob:

• sqlite_rdb: bind_blob(para1: PStmt; para2: int32; para3: pointer; n: int32; para5: int32): int32
• sqlite_rdb: bind_blob(para1: PStmt; para2: int32; para3: pointer; n: int32; para5: Tbind_destructor_func): int32

bind_double:

• sqlite_rdb: bind_double(para1: PStmt; para2: int32; para3: float64): int32

bind_int:

• sqlite_rdb: bind_int(para1: PStmt; para2: int32; para3: int32): int32

bind_int64:

• sqlite_rdb: bind_int64(para1: PStmt; para2: int32; para3: int64): int32

bind_null:

• sqlite_rdb: bind_null(para1: PStmt; para2: int32): int32

bindParam:

• sqlite_lib: bindParam(ps: PStmt; paramIdx: int; val: string; copy = true)

bind_parameter_count:

• sqlite_rdb: bind_parameter_count(para1: PStmt): int32

bind_parameter_index:

• sqlite_rdb: bind_parameter_index(para1: PStmt; zName: cstring): int32

bind_parameter_name:

• sqlite_rdb: bind_parameter_name(para1: PStmt; para2: int32): cstring

bind_text:

• sqlite_rdb: bind_text(para1: PStmt; para2: int32; para3: cstring; n: int32; para5: int32): int32
• sqlite_rdb: bind_text(para1: PStmt; para2: int32; para3: cstring; n: int32; para5: Tbind_destructor_func): int32

bind_text16:

• sqlite_rdb: bind_text16(para1: PStmt; para2: int32; para3: pointer; para4: int32; para5: int32): int32
• sqlite_rdb: bind_text16(para1: PStmt; para2: int32; para3: pointer; para4: int32; para5: Tbind_destructor_func): int32

BLOB_FLAG:

• mariadb_rdb: BLOB_FLAG
• mysql_rdb: BLOB_FLAG

boolean:

• column: boolean(_: type Column; name: string): Column

busy_handler:

• sqlite_rdb: busy_handler(para1: PSqlite3; para2: proc (para1: pointer; para2: int32): int32 {.cdecl.}; para3: pointer): int32

busy_timeout:

• sqlite_rdb: busy_timeout(para1: PSqlite3; ms: int32): int32

Callback:

• sqlite_rdb: Callback

CASCADE:

• ForeignOnDelete.CASCADE

change:

• column: change(c: Column): Column

ChangeColumn:

• ColumnMigrationType.ChangeColumn

changeColumn:

• change_column: changeColumn(self: MariadbSchema; isReset: bool)
• change_column: changeColumn(self: MysqlSchema; isReset: bool)
• change_column: changeColumn(self: PostgresSchema; isReset: bool)
• change_column: changeColumn(self: SqliteSchema; isReset: bool)
• change_column: changeColumn(self: SurrealSchema; isReset: bool)

changeColumnString:

• change_column_query: changeColumnString(table: Table; column: Column): seq[string]
• change_column_query: changeColumnString(table: Table; column: Column): seq[string]
• change_column_query: changeColumnString(table: Table; column: Column): seq[string]

changeForeignKey:

• change_column_query: changeForeignKey(column: Column; table: Table): string
• change_column_query: changeForeignKey(column: Column; table: Table): string

changeIndexString:

• change_column_query: changeIndexString(table: Table; column: Column): string

changes:

• sqlite_rdb: changes(para1: PSqlite3): int32

ChangeTable:

• TableMigrationType.ChangeTable

change_user:

• mariadb_rdb: change_user(MySQL: PMySQL; user: cstring; passwd: cstring; db: cstring): my_bool
• mysql_rdb: change_user(MySQL: PMySQL; user: cstring; passwd: cstring; db: cstring): my_bool

char:

• column: char(_: type Column; name: string; maxLength: int): Column

Character_set:

• mariadb_rdb: Character_set
• mysql_rdb: Character_set

character_set_name:

• mariadb_rdb: character_set_name(MySQL: PMySQL): cstring
• mysql_rdb: character_set_name(MySQL: PMySQL): cstring

CHARSET_INFO:

• mariadb_rdb: CHARSET_INFO
• mysql_rdb: CHARSET_INFO

Charset_info_st:

• mariadb_rdb: Charset_info_st
• mysql_rdb: Charset_info_st

checkError:

• postgres_lib: checkError(db: PPGconn)

check_scramble:

• mariadb_rdb: check_scramble(reply: cstring; message: cstring; hash_stage2: pointer): my_bool
• mysql_rdb: check_scramble(reply: cstring; message: cstring; hash_stage2: pointer): my_bool

check_scramble_323:

• mariadb_rdb: check_scramble_323(para1: cstring; message: cstring; salt: int): my_bool
• mysql_rdb: check_scramble_323(para1: cstring; message: cstring; salt: int): my_bool

clear_bindings:

• sqlite_rdb: clear_bindings(para1: PStmt): int32

CLIENT_COMPRESS:

• mariadb_rdb: CLIENT_COMPRESS
• mysql_rdb: CLIENT_COMPRESS

CLIENT_CONNECT_WITH_DB:

• mariadb_rdb: CLIENT_CONNECT_WITH_DB
• mysql_rdb: CLIENT_CONNECT_WITH_DB

CLIENT_FOUND_ROWS:

• mariadb_rdb: CLIENT_FOUND_ROWS
• mysql_rdb: CLIENT_FOUND_ROWS

CLIENT_IGNORE_SIGPIPE:

• mariadb_rdb: CLIENT_IGNORE_SIGPIPE
• mysql_rdb: CLIENT_IGNORE_SIGPIPE

CLIENT_IGNORE_SPACE:

• mariadb_rdb: CLIENT_IGNORE_SPACE
• mysql_rdb: CLIENT_IGNORE_SPACE

CLIENT_INTERACTIVE:

• mariadb_rdb: CLIENT_INTERACTIVE
• mysql_rdb: CLIENT_INTERACTIVE

CLIENT_LOCAL_FILES:

• mariadb_rdb: CLIENT_LOCAL_FILES
• mysql_rdb: CLIENT_LOCAL_FILES

CLIENT_LONG_FLAG:

• mariadb_rdb: CLIENT_LONG_FLAG
• mysql_rdb: CLIENT_LONG_FLAG

CLIENT_LONG_PASSWORD:

• mariadb_rdb: CLIENT_LONG_PASSWORD
• mysql_rdb: CLIENT_LONG_PASSWORD

CLIENT_MULTI_QUERIES:

• mariadb_rdb: CLIENT_MULTI_QUERIES
• mysql_rdb: CLIENT_MULTI_QUERIES

CLIENT_MULTI_RESULTS:

• mariadb_rdb: CLIENT_MULTI_RESULTS
• mysql_rdb: CLIENT_MULTI_RESULTS

CLIENT_MULTI_STATEMENTS:

• mariadb_rdb: CLIENT_MULTI_STATEMENTS
• mysql_rdb: CLIENT_MULTI_STATEMENTS

CLIENT_NET_READ_TIMEOUT:

• mariadb_rdb: CLIENT_NET_READ_TIMEOUT
• mysql_rdb: CLIENT_NET_READ_TIMEOUT

CLIENT_NET_WRITE_TIMEOUT:

• mariadb_rdb: CLIENT_NET_WRITE_TIMEOUT
• mysql_rdb: CLIENT_NET_WRITE_TIMEOUT

CLIENT_NO_SCHEMA:

• mariadb_rdb: CLIENT_NO_SCHEMA
• mysql_rdb: CLIENT_NO_SCHEMA

CLIENT_ODBC:

• mariadb_rdb: CLIENT_ODBC
• mysql_rdb: CLIENT_ODBC

CLIENT_PROTOCOL_41:

• mariadb_rdb: CLIENT_PROTOCOL_41
• mysql_rdb: CLIENT_PROTOCOL_41

CLIENT_REMEMBER_OPTIONS:

• mariadb_rdb: CLIENT_REMEMBER_OPTIONS
• mysql_rdb: CLIENT_REMEMBER_OPTIONS

CLIENT_RESERVED:

• mariadb_rdb: CLIENT_RESERVED
• mysql_rdb: CLIENT_RESERVED

CLIENT_SECURE_CONNECTION:

• mariadb_rdb: CLIENT_SECURE_CONNECTION
• mysql_rdb: CLIENT_SECURE_CONNECTION

CLIENT_SSL:

• mariadb_rdb: CLIENT_SSL
• mysql_rdb: CLIENT_SSL

CLIENT_TRANSACTIONS:

• mariadb_rdb: CLIENT_TRANSACTIONS
• mysql_rdb: CLIENT_TRANSACTIONS

close:

• mariadb_rdb: close(sock: PMySQL)
• mysql_rdb: close(sock: PMySQL)
• sqlite_rdb: close(para1: PSqlite3): int32

CMDSTATUS_LEN:

• postgres_rdb: CMDSTATUS_LEN

Collate:

• Collation.Collate

Collation:

• enums: Collation

collation_needed:

• sqlite_rdb: collation_needed(para1: PSqlite3; para2: pointer; para3: Collation_needed_func): int32

collation_needed16:

• sqlite_rdb: collation_needed16(para1: PSqlite3; para2: pointer; para3: Collation_needed_func): int32

Collation_needed_func:

• sqlite_rdb: Collation_needed_func

Column:

• column: Column

column_blob:

• sqlite_rdb: column_blob(para1: PStmt; iCol: int32): pointer

columnBuilder:

• mariadb_builder: columnBuilder(self: MariadbQuery): string
• mysql_builder: columnBuilder(self: MysqlQuery): string
• postgres_builder: columnBuilder(self: PostgresQuery): string
• sqlite_builder: columnBuilder(self: SqliteQuery): string

column_bytes:

• sqlite_rdb: column_bytes(para1: PStmt; iCol: int32): int32

column_bytes16:

• sqlite_rdb: column_bytes16(para1: PStmt; iCol: int32): int32

column_count:

• sqlite_rdb: column_count(PStmt: PStmt): int32

column_decltype:

• sqlite_rdb: column_decltype(para1: PStmt; i: int32): cstring

column_decltype16:

• sqlite_rdb: column_decltype16(para1: PStmt; para2: int32): pointer

column_double:

• sqlite_rdb: column_double(para1: PStmt; iCol: int32): float64

column_int:

• sqlite_rdb: column_int(para1: PStmt; iCol: int32): int32

column_int64:

• sqlite_rdb: column_int64(para1: PStmt; iCol: int32): int64

ColumnMigrationType:

• enums: ColumnMigrationType

column_name:

• sqlite_rdb: column_name(para1: PStmt; para2: int32): cstring

column_name16:

• sqlite_rdb: column_name16(para1: PStmt; para2: int32): pointer

columns:

• mariadb_query: columns(self: MariadbQuery): Future[seq[string]]
• mysql_query: columns(self: MysqlQuery): Future[seq[string]]
• postgres_query: columns(self: PostgresQuery): Future[seq[string]]
• sqlite_query: columns(self: SqliteQuery): Future[seq[string]]
• surreal_query: columns(self: SurrealQuery): Future[seq[string]]

column_table_name:

• sqlite_rdb: column_table_name(para1: PStmt; para2: int32): cstring

column_text:

• sqlite_rdb: column_text(para1: PStmt; iCol: int32): cstring

column_text16:

• sqlite_rdb: column_text16(para1: PStmt; iCol: int32): pointer

column_type:

• sqlite_rdb: column_type(para1: PStmt; iCol: int32): int32

COM_BINLOG_DUMP:

• Enum_server_command.COM_BINLOG_DUMP
• Enum_server_command.COM_BINLOG_DUMP

COM_CHANGE_USER:

• Enum_server_command.COM_CHANGE_USER
• Enum_server_command.COM_CHANGE_USER

COM_CONNECT:

• Enum_server_command.COM_CONNECT
• Enum_server_command.COM_CONNECT

COM_CONNECT_OUT:

• Enum_server_command.COM_CONNECT_OUT
• Enum_server_command.COM_CONNECT_OUT

COM_CREATE_DB:

• Enum_server_command.COM_CREATE_DB
• Enum_server_command.COM_CREATE_DB

COM_DEBUG:

• Enum_server_command.COM_DEBUG
• Enum_server_command.COM_DEBUG

COM_DELAYED_INSERT:

• Enum_server_command.COM_DELAYED_INSERT
• Enum_server_command.COM_DELAYED_INSERT

COM_DROP_DB:

• Enum_server_command.COM_DROP_DB
• Enum_server_command.COM_DROP_DB

COM_END:

• Enum_server_command.COM_END
• Enum_server_command.COM_END

COM_FIELD_LIST:

• Enum_server_command.COM_FIELD_LIST
• Enum_server_command.COM_FIELD_LIST

COM_INIT_DB:

• Enum_server_command.COM_INIT_DB
• Enum_server_command.COM_INIT_DB

commit:

• mariadb_rdb: commit(MySQL: PMySQL): my_bool
• mysql_rdb: commit(MySQL: PMySQL): my_bool
• mariadb_query: commit(self: MariadbConnections): owned(Future[void])
• mysql_query: commit(self: MysqlConnections): owned(Future[void])
• postgres_query: commit(self: PostgresConnections): owned(Future[void])
• sqlite_query: commit(self: SqliteConnections): owned(Future[void])

commit_hook:

• sqlite_rdb: commit_hook(para1: PSqlite3; para2: proc (para1: pointer): int32 {.cdecl.}; para3: pointer): pointer

COMP_HEADER_SIZE:

• mariadb_rdb: COMP_HEADER_SIZE
• mysql_rdb: COMP_HEADER_SIZE

COM_PING:

• Enum_server_command.COM_PING
• Enum_server_command.COM_PING

complete:

• sqlite_rdb: complete(sql: cstring): int32

complete16:

• sqlite_rdb: complete16(sql: pointer): int32

COM_PROCESS_INFO:

• Enum_server_command.COM_PROCESS_INFO
• Enum_server_command.COM_PROCESS_INFO

COM_PROCESS_KILL:

• Enum_server_command.COM_PROCESS_KILL
• Enum_server_command.COM_PROCESS_KILL

COM_QUERY:

• Enum_server_command.COM_QUERY
• Enum_server_command.COM_QUERY

COM_QUIT:

• Enum_server_command.COM_QUIT
• Enum_server_command.COM_QUIT

COM_REFRESH:

• Enum_server_command.COM_REFRESH
• Enum_server_command.COM_REFRESH

COM_REGISTER_SLAVE:

• Enum_server_command.COM_REGISTER_SLAVE
• Enum_server_command.COM_REGISTER_SLAVE

COM_SET_OPTION:

• Enum_server_command.COM_SET_OPTION
• Enum_server_command.COM_SET_OPTION

COM_SHUTDOWN:

• Enum_server_command.COM_SHUTDOWN
• Enum_server_command.COM_SHUTDOWN

COM_SLEEP:

• Enum_server_command.COM_SLEEP
• Enum_server_command.COM_SLEEP

COM_STATISTICS:

• Enum_server_command.COM_STATISTICS
• Enum_server_command.COM_STATISTICS

COM_STMT_CLOSE:

• Enum_server_command.COM_STMT_CLOSE
• Enum_server_command.COM_STMT_CLOSE

COM_STMT_EXECUTE:

• Enum_server_command.COM_STMT_EXECUTE
• Enum_server_command.COM_STMT_EXECUTE

COM_STMT_FETCH:

• Enum_server_command.COM_STMT_FETCH
• Enum_server_command.COM_STMT_FETCH

COM_STMT_PREPARE:

• Enum_server_command.COM_STMT_PREPARE
• Enum_server_command.COM_STMT_PREPARE

COM_STMT_RESET:

• Enum_server_command.COM_STMT_RESET
• Enum_server_command.COM_STMT_RESET

COM_STMT_SEND_LONG_DATA:

• Enum_server_command.COM_STMT_SEND_LONG_DATA
• Enum_server_command.COM_STMT_SEND_LONG_DATA

COM_TABLE_DUMP:

• Enum_server_command.COM_TABLE_DUMP
• Enum_server_command.COM_TABLE_DUMP

COM_TIME:

• Enum_server_command.COM_TIME
• Enum_server_command.COM_TIME

CONNECTION_AUTH_OK:

• ConnStatusType.CONNECTION_AUTH_OK

CONNECTION_AWAITING_RESPONSE:

• ConnStatusType.CONNECTION_AWAITING_RESPONSE

CONNECTION_BAD:

• ConnStatusType.CONNECTION_BAD

CONNECTION_CHECK_TARGET:

• ConnStatusType.CONNECTION_CHECK_TARGET

CONNECTION_CHECK_WRITABLE:

• ConnStatusType.CONNECTION_CHECK_WRITABLE

CONNECTION_CONSUME:

• ConnStatusType.CONNECTION_CONSUME

CONNECTION_GSS_STARTUP:

• ConnStatusType.CONNECTION_GSS_STARTUP

CONNECTION_MADE:

• ConnStatusType.CONNECTION_MADE

CONNECTION_NEEDED:

• ConnStatusType.CONNECTION_NEEDED

CONNECTION_OK:

• ConnStatusType.CONNECTION_OK

CONNECTION_SETENV:

• ConnStatusType.CONNECTION_SETENV

CONNECTION_SSL_STARTUP:

• ConnStatusType.CONNECTION_SSL_STARTUP

CONNECTION_STARTED:

• ConnStatusType.CONNECTION_STARTED

ConnStatusType:

• postgres_rdb: ConnStatusType

count:

• mariadb_query: count(self: MariadbQuery): Future[int]
• mysql_query: count(self: MysqlQuery): Future[int]
• postgres_query: count(self: PostgresQuery): Future[int]
• sqlite_query: count(self: SqliteQuery): Future[int]
• surreal_query: count(self: SurrealQuery): Future[int]

countBuilder:

• mariadb_builder: countBuilder(self: MariadbQuery): string
• mysql_builder: countBuilder(self: MysqlQuery): string
• postgres_builder: countBuilder(self: PostgresQuery): string
• sqlite_builder: countBuilder(self: SqliteQuery): string
• surreal_builder: countBuilder(self: SurrealQuery): string

COUNT_ERROR:

• mariadb_rdb: COUNT_ERROR
• mysql_rdb: COUNT_ERROR

Create:

• UsecaseType.Create

create:

• create: create(rdb: MariadbConnections; tables: varargs[Table])
• create: create(rdb: MysqlConnections; tables: varargs[Table])
• create: create(rdb: PostgresConnections; tables: varargs[Table])
• create: create(rdb: SqliteConnections; tables: varargs[Table])
• create: create(rdb: SurrealConnections; tables: varargs[Table])

create_collation:

• sqlite_rdb: create_collation(para1: PSqlite3; zName: cstring; eTextRep: int32; para4: pointer; xCompare: Create_collation_func): int32

create_collation16:

• sqlite_rdb: create_collation16(para1: PSqlite3; zName: cstring; eTextRep: int32; para4: pointer; xCompare: Create_collation_func): int32

Create_collation_func:

• sqlite_rdb: Create_collation_func

createColumnString:

• create_column_query: createColumnString(table: Table; column: Column): string
• create_column_query: createColumnString(table: Table; column: Column): string
• create_column_query: createColumnString(table: Table; column: Column): string
• create_column_query: createColumnString(column: Column): string
• create_column_query: createColumnString(table: Table; column: Column): seq[string]

createForeignKey:

• create_column_query: createForeignKey(table: Table; column: Column): string
• create_column_query: createForeignKey(table: Table; column: Column): string

createForeignString:

• create_column_query: createForeignString(table: Table; column: Column): string
• create_column_query: createForeignString(column: Column): string

create_function:

• sqlite_rdb: create_function(para1: PSqlite3; zFunctionName: cstring; nArg: int32; eTextRep: int32; para5: pointer; xFunc: Create_function_func_func; xStep: Create_function_step_func; xFinal: Create_function_final_func): int32

create_function16:

• sqlite_rdb: create_function16(para1: PSqlite3; zFunctionName: pointer; nArg: int32; eTextRep: int32; para5: pointer; xFunc: Create_function_func_func; xStep: Create_function_step_func; xFinal: Create_function_final_func): int32

Create_function_final_func:

• sqlite_rdb: Create_function_final_func

Create_function_func_func:

• sqlite_rdb: Create_function_func_func

Create_function_step_func:

• sqlite_rdb: Create_function_step_func

createIndexString:

• create_column_query: createIndexString(table: Table; column: Column): string
• create_column_query: createIndexString(table: Table; column: Column): string
• create_column_query: createIndexString(table: Table; column: Column): string
• create_column_query: createIndexString(table: Table; column: Column): string

createMigrationTable:

• create_migration_table: createMigrationTable(self: MariadbSchema)
• create_migration_table: createMigrationTable(self: MysqlSchema)
• create_migration_table: createMigrationTable(self: PostgresSchema)
• create_migration_table: createMigrationTable(self: SqliteSchema)
• create_migration_table: createMigrationTable(self: SurrealSchema)

create_random_string:

• mariadb_rdb: create_random_string(fto: cstring; len: cuint; rand_st: Prand_struct)
• mysql_rdb: create_random_string(fto: cstring; len: cuint; rand_st: Prand_struct)

createSchema:

• create_query_def: createSchema(rdb: MariadbConnections; table: Table): ISchema
• create_query_def: createSchema(rdb: MariadbConnections; table: Table; column: Column): ISchema
• create_query_def: createSchema(rdb: MysqlConnections; table: Table): ISchema
• create_query_def: createSchema(rdb: MysqlConnections; table: Table; column: Column): ISchema
• create_query_def: createSchema(rdb: PostgresConnections; table: Table): ISchema
• create_query_def: createSchema(rdb: PostgresConnections; table: Table; column: Column): ISchema
• create_query_def: createSchema(rdb: SqliteConnections; table: Table): ISchema
• create_query_def: createSchema(rdb: SqliteConnections; table: Table; column: Column): ISchema
• create_query_def: createSchema(rdb: SurrealConnections; table: Table): ISchema
• create_query_def: createSchema(rdb: SurrealConnections; table: Table; column: Column): ISchema

createSequenceTable:

• create_sequence_table: createSequenceTable(rdb: SurrealConnections)

CreateTable:

• TableMigrationType.CreateTable

createTable:

• create_table: createTable(self: MariadbSchema; isReset: bool)
• create_table: createTable(self: MysqlSchema; isReset: bool)
• create_table: createTable(self: PostgresSchema; isReset: bool)
• create_table: createTable(self: SqliteSchema; isReset: bool)
• create_table: createTable(self: SurrealSchema; isReset: bool)

cuint:

• mariadb_rdb: cuint
• mysql_rdb: cuint

Current:

• DefaultDateTime.Current

CurrentOnUpdate:

• DefaultDateTime.CurrentOnUpdate

CURSOR_TYPE_FOR_UPDATE:

• Enum_cursor_type.CURSOR_TYPE_FOR_UPDATE
• Enum_cursor_type.CURSOR_TYPE_FOR_UPDATE

CURSOR_TYPE_NO_CURSOR:

• Enum_cursor_type.CURSOR_TYPE_NO_CURSOR
• Enum_cursor_type.CURSOR_TYPE_NO_CURSOR

CURSOR_TYPE_READ_ONLY:

• Enum_cursor_type.CURSOR_TYPE_READ_ONLY
• Enum_cursor_type.CURSOR_TYPE_READ_ONLY

CURSOR_TYPE_SCROLLABLE:

• Enum_cursor_type.CURSOR_TYPE_SCROLLABLE
• Enum_cursor_type.CURSOR_TYPE_SCROLLABLE

DATA:

• mariadb_rdb: DATA
• mysql_rdb: DATA

data_count:

• sqlite_rdb: data_count(PStmt: PStmt): int32

data_seek:

• mariadb_rdb: data_seek(result: PRES; offset: my_ulonglong)
• mysql_rdb: data_seek(result: PRES; offset: my_ulonglong)

DATA_TRUNCATED:

• mariadb_rdb: DATA_TRUNCATED
• mysql_rdb: DATA_TRUNCATED

date:

• column: date(_: type Column; name: string): Column

datetime:

• column: datetime(_: type Column; name: string): Column

dbArray:

• DbTypeKind.dbArray

dbBindParamError:

• sqlite_lib: dbBindParamError(paramIdx: int; val: varargs[untyped])

dbBit:

• DbTypeKind.dbBit

dbBlob:

• DbTypeKind.dbBlob

dbBool:

• DbTypeKind.dbBool

dbBox:

• DbTypeKind.dbBox

dbCircle:

• DbTypeKind.dbCircle

DbColumn:

• database_types: DbColumn

DbColumns:

• database_types: DbColumns

dbComposite:

• DbTypeKind.dbComposite

dbDate:

• DbTypeKind.dbDate

dbDatetime:

• DbTypeKind.dbDatetime

dbDecimal:

• DbTypeKind.dbDecimal

DbEffect:

• database_types: DbEffect

dbEnum:

• DbTypeKind.dbEnum

DbError:

• error: DbError

dbError:

• error: dbError(msg: string)
• mariadb_lib: dbError(db: PMySQL)
• mysql_lib: dbError(db: PMySQL)
• postgres_lib: dbError(db: PPGconn)
• sqlite_lib: dbError(db: PSqlite3)

dbFixedChar:

• DbTypeKind.dbFixedChar

dbFloat:

• DbTypeKind.dbFloat

dbFormat:

• mariadb_lib: dbFormat(conn: PMySQL; query: string; args: MariadbParams): string
• mariadb_lib: dbFormat(formatstr: string; args: seq[string]): string
• mysql_lib: dbFormat(conn: PMySQL; query: string; args: MysqlParams): string
• mysql_lib: dbFormat(formatstr: string; args: seq[string]): string
• postgres_lib: dbFormat(formatstr: string; args: varargs[string]): string
• sqlite_lib: dbFormat(formatstr: string; args: varargs[string]): string
• surreal_lib: dbFormat(queryString: string; args: JsonNode): string
• surreal_lib: dbFormat(formatstr: string; args: varargs[string]): string

dbGeometry:

• DbTypeKind.dbGeometry

dbInet:

• DbTypeKind.dbInet

dbInt:

• DbTypeKind.dbInt

dbJson:

• DbTypeKind.dbJson

dbLine:

• DbTypeKind.dbLine

dbLseg:

• DbTypeKind.dbLseg

dbMacAddress:

• DbTypeKind.dbMacAddress

dbNull:

• DbTypeKind.dbNull

dbOpen:

• mariadb_open: dbOpen(_: type MariaDB; database: string = ""; user: string = ""; password: string = ""; host: string = ""; port: int32 = 0; maxConnections: int = 1; timeout = 30; shouldDisplayLog = false; shouldOutputLogFile = false; logDir = ""): MariadbConnections
• mysql_open: dbOpen(_: type MySQL; database: string = ""; user: string = ""; password: string = ""; host: string = ""; port: int32 = 0; maxConnections: int = 1; timeout = 30; shouldDisplayLog = false; shouldOutputLogFile = false; logDir = ""): MysqlConnections
• postgres_open: dbOpen(_: type PostgreSQL; database: string = ""; user: string = ""; password: string = ""; host: string = ""; port: int32 = 0; maxConnections: int = 1; timeout = 30; shouldDisplayLog = false; shouldOutputLogFile = false; logDir = ""): PostgresConnections
• sqlite_open: dbOpen(_: type SQLite3; database: string = ""; user: string = ""; password: string = ""; host: string = ""; port: int32 = 0; maxConnections: int = 1; timeout = 30; shouldDisplayLog = false; shouldOutputLogFile = false; logDir = ""): SqliteConnections
• surreal_open: dbOpen(_: type SurrealDB; namespace: string = ""; database: string = ""; user: string = ""; password: string = ""; host: string = ""; port: int32 = 0; maxConnections: int = 1; timeout = 30; shouldDisplayLog = false; shouldOutputLogFile = false; logDir = ""): Future[ SurrealConnections]

dbPath:

• DbTypeKind.dbPath

dbPoint:

• DbTypeKind.dbPoint

dbPolygon:

• DbTypeKind.dbPolygon

DbRows:

• database_types: DbRows

dbSerial:

• DbTypeKind.dbSerial

dbSet:

• DbTypeKind.dbSet

dbTime:

• DbTypeKind.dbTime

dbTimeInterval:

• DbTypeKind.dbTimeInterval

dbTimestamp:

• DbTypeKind.dbTimestamp

DbType:

• database_types: DbType

DbTypeKind:

• database_types: DbTypeKind

dbUInt:

• DbTypeKind.dbUInt

dbUnknown:

• DbTypeKind.dbUnknown

dbUrl:

• DbTypeKind.dbUrl

dbUser1:

• DbTypeKind.dbUser1

dbUser2:

• DbTypeKind.dbUser2

dbUser3:

• DbTypeKind.dbUser3

dbUser4:

• DbTypeKind.dbUser4

dbUser5:

• DbTypeKind.dbUser5

dbUuid:

• DbTypeKind.dbUuid

dbVarchar:

• DbTypeKind.dbVarchar

dbXml:

• DbTypeKind.dbXml

debug:

• mariadb_rdb: debug(debug: cstring)
• mysql_rdb: debug(debug: cstring)

decimal:

• column: decimal(_: type Column; name: string; maximum: int; digit: int): Column

DECIMAL_RESULT:

• Item_result.DECIMAL_RESULT
• Item_result.DECIMAL_RESULT

default:

• column: default(c: Column): Column
• column: default(c: Column; value: bool): Column
• column: default(c: Column; value: DefaultDateTime): Column
• column: default(c: Column; value: float): Column
• column: default(c: Column; value: int): Column
• column: default(c: Column; value: JsonNode): Column
• column: default(c: Column; value: string): Column

DefaultDateTime:

• enums: DefaultDateTime

delete:

• mariadb_query: delete(self: MariadbQuery): owned(Future[void])
• mariadb_query: delete(self: MariadbQuery; id: int; key = "id"): owned(Future[void])
• mysql_query: delete(self: MysqlQuery): owned(Future[void])
• mysql_query: delete(self: MysqlQuery; id: int; key = "id"): owned(Future[void])
• postgres_query: delete(self: PostgresQuery): owned(Future[void])
• postgres_query: delete(self: PostgresQuery; id: int; key = "id"): owned(Future[void])
• sqlite_query: delete(self: SqliteQuery): owned(Future[void])
• sqlite_query: delete(self: SqliteQuery; id: int; key = "id"): owned(Future[void])
• surreal_query: delete(self: SurrealQuery): owned(Future[void])
• surreal_query: delete(self: SurrealQuery; id: SurrealId): owned(Future[void])

deleteBuilder:

• mariadb_builder: deleteBuilder(self: MariadbQuery): string
• mysql_builder: deleteBuilder(self: MysqlQuery): string
• postgres_builder: deleteBuilder(self: PostgresQuery): string
• sqlite_builder: deleteBuilder(self: SqliteQuery): string
• surreal_builder: deleteBuilder(self: SurrealQuery): string

deleteByIdBuilder:

• mariadb_builder: deleteByIdBuilder(self: MariadbQuery; id: int; key: string): string
• mysql_builder: deleteByIdBuilder(self: MysqlQuery; id: int; key: string): string
• postgres_builder: deleteByIdBuilder(self: PostgresQuery; id: int; key: string): string
• sqlite_builder: deleteByIdBuilder(self: SqliteQuery; id: int; key: string): string
• surreal_builder: deleteByIdBuilder(self: SurrealQuery; id: string): string

deleteByIdSql:

• mariadb_generator: deleteByIdSql(self: MariadbQuery; id: int; key: string): MariadbQuery
• mysql_generator: deleteByIdSql(self: MysqlQuery; id: int; key: string): MysqlQuery
• postgres_generator: deleteByIdSql(self: PostgresQuery; id: int; key: string): PostgresQuery
• sqlite_generator: deleteByIdSql(self: SqliteQuery; id: int; key: string): SqliteQuery
• surreal_generator: deleteByIdSql(self: SurrealQuery; id: string): SurrealQuery

deleteSql:

• mariadb_generator: deleteSql(self: MariadbQuery): MariadbQuery
• mysql_generator: deleteSql(self: MysqlQuery): MysqlQuery
• postgres_generator: deleteSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: deleteSql(self: SqliteQuery): SqliteQuery
• surreal_generator: deleteSql(self: SurrealQuery): SurrealQuery

Desc:

• Order.Desc

disable_reads_from_master:

• mariadb_rdb: disable_reads_from_master(MySQL: PMySQL)
• mysql_rdb: disable_reads_from_master(MySQL: PMySQL)

disable_rpl_parse:

• mariadb_rdb: disable_rpl_parse(MySQL: PMySQL)
• mysql_rdb: disable_rpl_parse(MySQL: PMySQL)

double:

• column: double(_: type Column; name: string; maximum: int; digit: int): Column

Drop:

• UsecaseType.Drop

drop:

• drop: drop(rdb: MariadbConnections; tables: varargs[Table])
• drop: drop(rdb: MysqlConnections; tables: varargs[Table])
• drop: drop(rdb: PostgresConnections; tables: varargs[Table])
• drop: drop(rdb: SqliteConnections; tables: varargs[Table])
• drop: drop(rdb: SurrealConnections; tables: varargs[Table])

DropColumn:

• ColumnMigrationType.DropColumn

dropColumn:

• column: dropColumn(_: type Column; name: string): Column
• drop_column: dropColumn(self: MariadbSchema; isReset: bool)
• drop_column: dropColumn(self: MysqlSchema; isReset: bool)
• drop_column: dropColumn(self: PostgresSchema; isReset: bool)
• drop_column: dropColumn(self: SqliteSchema; isReset: bool)
• drop_column: dropColumn(self: SurrealSchema; isReset: bool)

DropTable:

• TableMigrationType.DropTable

dropTable:

• drop_table: dropTable(self: MariadbSchema; isReset: bool)
• drop_table: dropTable(self: MysqlSchema; isReset: bool)
• drop_table: dropTable(self: PostgresSchema; isReset: bool)
• drop_table: dropTable(self: SqliteSchema; isReset: bool)
• drop_table: dropTable(self: SurrealSchema; isReset: bool)

dump_debug_info:

• mariadb_rdb: dump_debug_info(MySQL: PMySQL): cint
• mysql_rdb: dump_debug_info(MySQL: PMySQL): cint

DYNAMIC_ARRAY:

• mariadb_rdb: DYNAMIC_ARRAY
• mysql_rdb: DYNAMIC_ARRAY

echoErrorMsg:

• log: echoErrorMsg(self: LogSetting; msg: string; args: seq[string] = @[])

echoWarningMsg:

• log: echoWarningMsg(self: LogSetting; msg: string)

embedded:

• mariadb_rdb: embedded(): my_bool
• mysql_rdb: embedded(): my_bool

enable_reads_from_master:

• mariadb_rdb: enable_reads_from_master(MySQL: PMySQL)
• mysql_rdb: enable_reads_from_master(MySQL: PMySQL)

enable_rpl_parse:

• mariadb_rdb: enable_rpl_parse(MySQL: PMySQL)
• mysql_rdb: enable_rpl_parse(MySQL: PMySQL)

Enum_cursor_type:

• mariadb_rdb: Enum_cursor_type
• mysql_rdb: Enum_cursor_type

enumField:

• column: enumField(_: type Column; name: string; options: openArray[string]): Column

Enum_field_types:

• mariadb_rdb: Enum_field_types
• mysql_rdb: Enum_field_types

ENUM_FLAG:

• mariadb_rdb: ENUM_FLAG
• mysql_rdb: ENUM_FLAG

Enum_mysql_set_option:

• mariadb_rdb: Enum_mysql_set_option
• mysql_rdb: Enum_mysql_set_option

Enum_mysql_stmt_state:

• mariadb_rdb: Enum_mysql_stmt_state
• mysql_rdb: Enum_mysql_stmt_state

Enum_server_command:

• mariadb_rdb: Enum_server_command
• mysql_rdb: Enum_server_command

Enum_shutdown_level:

• mariadb_rdb: Enum_shutdown_level
• mysql_rdb: Enum_shutdown_level

Enum_stmt_attr_type:

• mariadb_rdb: Enum_stmt_attr_type
• mysql_rdb: Enum_stmt_attr_type

eof:

• mariadb_rdb: eof(res: PRES): my_bool
• mysql_rdb: eof(res: PRES): my_bool

errcode:

• sqlite_rdb: errcode(db: PSqlite3): int32

errmsg:

• sqlite_rdb: errmsg(para1: PSqlite3): cstring

errmsg16:

• sqlite_rdb: errmsg16(para1: PSqlite3): pointer

ERRMSG_SIZE:

• mariadb_rdb: ERRMSG_SIZE
• mysql_rdb: ERRMSG_SIZE

errno:

• mariadb_rdb: errno(MySQL: PMySQL): cuint
• mysql_rdb: errno(MySQL: PMySQL): cuint

errno_to_sqlstate:

• mariadb_rdb: errno_to_sqlstate(errno: cuint): cstring
• mysql_rdb: errno_to_sqlstate(errno: cuint): cstring

error:

• mariadb_rdb: error(MySQL: PMySQL): cstring
• mysql_rdb: error(MySQL: PMySQL): cstring

errorConnectionNum:

• database_types: errorConnectionNum

ERROR_MSG_LENGTH:

• postgres_rdb: ERROR_MSG_LENGTH

escape_string:

• mariadb_rdb: escape_string(fto: cstring; from: cstring; from_length: int): int
• mysql_rdb: escape_string(fto: cstring; from: cstring; from_length: int): int

exec:

• mariadb_impl: exec(db: PMySQL; query: string; args: JsonNode; timeout: int): owned( Future[void])
• mariadb_impl: exec(db: PMySQL; query: string; args: JsonNode; columns: seq[seq[string]]; timeout: int): owned(Future[void])
• mariadb_impl: exec(db: PMySQL; query: string; args: seq[string]; timeout: int): owned( Future[void])
• mysql_impl: exec(db: PMySQL; query: string; args: JsonNode; timeout: int): owned( Future[void])
• mysql_impl: exec(db: PMySQL; query: string; args: JsonNode; columns: seq[seq[string]]; timeout: int): owned(Future[void])
• mysql_impl: exec(db: PMySQL; query: string; args: seq[string]; timeout: int): owned( Future[void])
• postgres_impl: exec(db: PPGconn; query: string; args: JsonNode; columns: seq[Row]; timeout: int): owned( Future[void])
• postgres_impl: exec(db: PPGconn; query: string; args: seq[string]; timeout: int): owned( Future[void])
• sqlite_impl: exec(db: PSqlite3; query: string; args: JsonNode; timeout: int): owned( Future[void])
• sqlite_impl: exec(db: PSqlite3; query: string; args: JsonNode; columns: seq[(string, string)]; timeout: int): owned(Future[void])
• sqlite_impl: exec(db: PSqlite3; query: string; args: seq[string]; timeout: int): owned( Future[void])
• sqlite_rdb: exec(para1: PSqlite3; sql: cstring; para3: Callback; para4: pointer; errmsg: var cstring): int32
• surreal_impl: exec(db: SurrealConn; query: string; args: JsonNode; timeout: int): owned( Future[void])
• surreal_impl: exec(db: SurrealConn; query: string; args: seq[string]; timeout: int): owned( Future[void])
• mariadb_query: exec(self: RawMariadbQuery): owned(Future[void])
• mysql_query: exec(self: RawMysqlQuery): owned(Future[void])
• postgres_query: exec(self: RawPostgresQuery): owned(Future[void])
• sqlite_query: exec(self: RawSqliteQuery): owned(Future[void])
• surreal_query: exec(self: RawSurrealQuery): owned(Future[void])
• schema_utils: exec(rdb: MariadbConnections; queries: seq[string])
• schema_utils: exec(rdb: MysqlConnections; queries: seq[string])
• schema_utils: exec(rdb: PostgresConnections; queries: seq[string])
• schema_utils: exec(rdb: SqliteConnections; queries: seq[string])
• schema_utils: exec(rdb: SurrealConnections; queries: seq[string])

execGetValue:

• mariadb_impl: execGetValue(db: PMySQL; query: string; args: JsonNode; columns: seq[seq[string]]; timeout: int): Future[ (seq[database_types.Row], DbRows)]
• mysql_impl: execGetValue(db: PMySQL; query: string; args: JsonNode; columns: seq[seq[string]]; timeout: int): Future[ (seq[database_types.Row], DbRows)]
• postgres_impl: execGetValue(db: PPGconn; query: string; args: JsonNode; columns: seq[Row]; timeout: int): Future[(seq[Row], DbRows)]

ExecStatusType:

• postgres_rdb: ExecStatusType

execThenSaveHistory:

• schema_utils: execThenSaveHistory(rdb: MariadbConnections; tableName: string; queries: seq[string]; checksum: string)
• schema_utils: execThenSaveHistory(rdb: MariadbConnections; tableName: string; query: string; checksum: string)
• schema_utils: execThenSaveHistory(rdb: MysqlConnections; tableName: string; queries: seq[string]; checksum: string)
• schema_utils: execThenSaveHistory(rdb: MysqlConnections; tableName: string; query: string; checksum: string)
• schema_utils: execThenSaveHistory(rdb: PostgresConnections; tableName: string; queries: seq[string]; checksum: string)
• schema_utils: execThenSaveHistory(rdb: PostgresConnections; tableName: string; query: string; checksum: string)
• schema_utils: execThenSaveHistory(rdb: SqliteConnections; tableName: string; queries: seq[string]; checksum: string)
• schema_utils: execThenSaveHistory(rdb: SqliteConnections; tableName: string; query: string; checksum: string)
• schema_utils: execThenSaveHistory(rdb: SurrealConnections; tableName: string; queries: seq[string]; checksum: string)
• schema_utils: execThenSaveHistory(rdb: SurrealConnections; tableName: string; query: string; checksum: string)

false:

• my_bool.false
• my_bool.false

fetch:

• surreal_query: fetch(self: SurrealQuery; columnsArg: varargs[string]): SurrealQuery

fetch_field:

• mariadb_rdb: fetch_field(result: PRES): PFIELD
• mysql_rdb: fetch_field(result: PRES): PFIELD

fetch_field_direct:

• mariadb_rdb: fetch_field_direct(res: PRES; fieldnr: cuint): PFIELD
• mysql_rdb: fetch_field_direct(res: PRES; fieldnr: cuint): PFIELD

fetch_fields:

• mariadb_rdb: fetch_fields(res: PRES): PFIELD
• mysql_rdb: fetch_fields(res: PRES): PFIELD

fetch_lengths:

• mariadb_rdb: fetch_lengths(result: PRES): ptr int
• mysql_rdb: fetch_lengths(result: PRES): ptr int

fetch_next_result_nonblocking:

• mariadb_rdb: fetch_next_result_nonblocking(MySQL: PMySQL): NetAsyncStatus
• mysql_rdb: fetch_next_result_nonblocking(MySQL: PMySQL): NetAsyncStatus

fetch_row:

• mariadb_rdb: fetch_row(result: PRES): ROW
• mysql_rdb: fetch_row(result: PRES): ROW

fetch_row_nonblocking:

• mariadb_rdb: fetch_row_nonblocking(MYSQL_RES: PRES; MYSQL_ROW: PROW): NetAsyncStatus
• mysql_rdb: fetch_row_nonblocking(MYSQL_RES: PRES; MYSQL_ROW: PROW): NetAsyncStatus

fetchSql:

• surreal_generator: fetchSql(self: SurrealQuery): SurrealQuery

FIELD:

• mariadb_rdb: FIELD
• mysql_rdb: FIELD

field_count:

• mariadb_rdb: field_count(MySQL: PMySQL): cuint
• mysql_rdb: field_count(MySQL: PMySQL): cuint

FIELD_OFFSET:

• mariadb_rdb: FIELD_OFFSET
• mysql_rdb: FIELD_OFFSET

field_seek:

• mariadb_rdb: field_seek(result: PRES; offset: FIELD_OFFSET): FIELD_OFFSET
• mysql_rdb: field_seek(result: PRES; offset: FIELD_OFFSET): FIELD_OFFSET

field_tell:

• mariadb_rdb: field_tell(res: PRES): FIELD_OFFSET
• mysql_rdb: field_tell(res: PRES): FIELD_OFFSET

FIELD_TYPE_BIT:

• mariadb_rdb: FIELD_TYPE_BIT
• mysql_rdb: FIELD_TYPE_BIT

FIELD_TYPE_BLOB:

• mariadb_rdb: FIELD_TYPE_BLOB
• mysql_rdb: FIELD_TYPE_BLOB

FIELD_TYPE_CHAR:

• mariadb_rdb: FIELD_TYPE_CHAR
• mysql_rdb: FIELD_TYPE_CHAR

FIELD_TYPE_DATE:

• mariadb_rdb: FIELD_TYPE_DATE
• mysql_rdb: FIELD_TYPE_DATE

FIELD_TYPE_DATETIME:

• mariadb_rdb: FIELD_TYPE_DATETIME
• mysql_rdb: FIELD_TYPE_DATETIME

FIELD_TYPE_DECIMAL:

• mariadb_rdb: FIELD_TYPE_DECIMAL
• mysql_rdb: FIELD_TYPE_DECIMAL

FIELD_TYPE_DOUBLE:

• mariadb_rdb: FIELD_TYPE_DOUBLE
• mysql_rdb: FIELD_TYPE_DOUBLE

FIELD_TYPE_ENUM:

• mariadb_rdb: FIELD_TYPE_ENUM
• mysql_rdb: FIELD_TYPE_ENUM

FIELD_TYPE_FLOAT:

• mariadb_rdb: FIELD_TYPE_FLOAT
• mysql_rdb: FIELD_TYPE_FLOAT

FIELD_TYPE_GEOMETRY:

• mariadb_rdb: FIELD_TYPE_GEOMETRY
• mysql_rdb: FIELD_TYPE_GEOMETRY

FIELD_TYPE_INT24:

• mariadb_rdb: FIELD_TYPE_INT24
• mysql_rdb: FIELD_TYPE_INT24

FIELD_TYPE_INTERVAL:

• mariadb_rdb: FIELD_TYPE_INTERVAL
• mysql_rdb: FIELD_TYPE_INTERVAL

FIELD_TYPE_LONG:

• mariadb_rdb: FIELD_TYPE_LONG
• mysql_rdb: FIELD_TYPE_LONG

FIELD_TYPE_LONG_BLOB:

• mariadb_rdb: FIELD_TYPE_LONG_BLOB
• mysql_rdb: FIELD_TYPE_LONG_BLOB

FIELD_TYPE_LONGLONG:

• mariadb_rdb: FIELD_TYPE_LONGLONG
• mysql_rdb: FIELD_TYPE_LONGLONG

FIELD_TYPE_MEDIUM_BLOB:

• mariadb_rdb: FIELD_TYPE_MEDIUM_BLOB
• mysql_rdb: FIELD_TYPE_MEDIUM_BLOB

FIELD_TYPE_NEWDATE:

• mariadb_rdb: FIELD_TYPE_NEWDATE
• mysql_rdb: FIELD_TYPE_NEWDATE

FIELD_TYPE_NEWDECIMAL:

• mariadb_rdb: FIELD_TYPE_NEWDECIMAL
• mysql_rdb: FIELD_TYPE_NEWDECIMAL

FIELD_TYPE_NULL:

• mariadb_rdb: FIELD_TYPE_NULL
• mysql_rdb: FIELD_TYPE_NULL

FIELD_TYPE_SET:

• mariadb_rdb: FIELD_TYPE_SET
• mysql_rdb: FIELD_TYPE_SET

FIELD_TYPE_SHORT:

• mariadb_rdb: FIELD_TYPE_SHORT
• mysql_rdb: FIELD_TYPE_SHORT

FIELD_TYPE_STRING:

• mariadb_rdb: FIELD_TYPE_STRING
• mysql_rdb: FIELD_TYPE_STRING

FIELD_TYPE_TIME:

• mariadb_rdb: FIELD_TYPE_TIME
• mysql_rdb: FIELD_TYPE_TIME

FIELD_TYPE_TIMESTAMP:

• mariadb_rdb: FIELD_TYPE_TIMESTAMP
• mysql_rdb: FIELD_TYPE_TIMESTAMP

FIELD_TYPE_TINY:

• mariadb_rdb: FIELD_TYPE_TINY
• mysql_rdb: FIELD_TYPE_TINY

FIELD_TYPE_TINY_BLOB:

• mariadb_rdb: FIELD_TYPE_TINY_BLOB
• mysql_rdb: FIELD_TYPE_TINY_BLOB

FIELD_TYPE_VAR_STRING:

• mariadb_rdb: FIELD_TYPE_VAR_STRING
• mysql_rdb: FIELD_TYPE_VAR_STRING

FIELD_TYPE_YEAR:

• mariadb_rdb: FIELD_TYPE_YEAR
• mysql_rdb: FIELD_TYPE_YEAR

finalize:

• sqlite_rdb: finalize(PStmt: PStmt): int32

find:

• mariadb_query: find(self: MariadbQuery; id: int; key = "id"): Future[Option[JsonNode]]
• mariadb_query: find[T](self: MariadbQuery; id: int; typ: typedesc[T]; key = "id"): Future[ Option[T]]
• mariadb_query: find(self: MariadbQuery; id: string; key = "id"): Future[Option[JsonNode]]
• mariadb_query: find[T](self: MariadbQuery; id: string; typ: typedesc[T]; key = "id"): Future[ Option[T]]
• mysql_query: find(self: MysqlQuery; id: int; key = "id"): Future[Option[JsonNode]]
• mysql_query: find[T](self: MysqlQuery; id: int; typ: typedesc[T]; key = "id"): Future[ Option[T]]
• mysql_query: find(self: MysqlQuery; id: string; key = "id"): Future[Option[JsonNode]]
• mysql_query: find[T](self: MysqlQuery; id: string; typ: typedesc[T]; key = "id"): Future[ Option[T]]
• postgres_query: find(self: PostgresQuery; id: int; key = "id"): Future[Option[JsonNode]]
• postgres_query: find[T](self: PostgresQuery; id: int; typ: typedesc[T]; key = "id"): Future[ Option[T]]
• postgres_query: find(self: PostgresQuery; id: string; key = "id"): Future[Option[JsonNode]]
• postgres_query: find[T](self: PostgresQuery; id: string; typ: typedesc[T]; key = "id"): Future[ Option[T]]
• sqlite_query: find(self: SqliteQuery; id: int; key = "id"): Future[Option[JsonNode]]
• sqlite_query: find[T](self: SqliteQuery; id: int; typ: typedesc[T]; key = "id"): Future[ Option[T]]
• sqlite_query: find(self: SqliteQuery; id: string; key = "id"): Future[Option[JsonNode]]
• sqlite_query: find[T](self: SqliteQuery; id: string; typ: typedesc[T]; key = "id"): Future[ Option[T]]
• surreal_query: find(self: SurrealQuery; id: SurrealId; key = "id"): Future[Option[JsonNode]]

findPlain:

• mariadb_query: findPlain(self: MariadbQuery; id: int; key = "id"): Future[seq[string]]
• mariadb_query: findPlain(self: MariadbQuery; id: string; key = "id"): Future[seq[string]]
• mysql_query: findPlain(self: MysqlQuery; id: int; key = "id"): Future[seq[string]]
• mysql_query: findPlain(self: MysqlQuery; id: string; key = "id"): Future[seq[string]]
• postgres_query: findPlain(self: PostgresQuery; id: int; key = "id"): Future[seq[string]]
• postgres_query: findPlain(self: PostgresQuery; id: string; key = "id"): Future[seq[string]]
• sqlite_query: findPlain(self: SqliteQuery; id: int; key = "id"): Future[seq[string]]
• sqlite_query: findPlain(self: SqliteQuery; id: string; key = "id"): Future[seq[string]]

first:

• mariadb_query: first(self: MariadbQuery): Future[Option[JsonNode]]
• mariadb_query: first[T](self: MariadbQuery; typ: typedesc[T]): Future[Option[T]]
• mariadb_query: first(self: RawMariadbQuery): Future[Option[JsonNode]]
• mysql_query: first(self: MysqlQuery): Future[Option[JsonNode]]
• mysql_query: first[T](self: MysqlQuery; typ: typedesc[T]): Future[Option[T]]
• mysql_query: first(self: RawMysqlQuery): Future[Option[JsonNode]]
• postgres_query: first(self: PostgresQuery): Future[Option[JsonNode]]
• postgres_query: first[T](self: PostgresQuery; typ: typedesc[T]): Future[Option[T]]
• postgres_query: first(self: RawPostgresQuery): Future[Option[JsonNode]]
• sqlite_query: first(self: RawSqliteQuery): Future[Option[JsonNode]]
• sqlite_query: first(self: SqliteQuery): Future[Option[JsonNode]]
• sqlite_query: first[T](self: SqliteQuery; typ: typedesc[T]): Future[Option[T]]
• surreal_query: first(self: RawSurrealQuery): Future[Option[JsonNode]]
• surreal_query: first(self: SurrealQuery): Future[Option[JsonNode]]

firstPlain:

• mariadb_query: firstPlain(self: MariadbQuery): Future[seq[string]]
• mariadb_query: firstPlain(self: RawMariadbQuery): Future[seq[string]]
• mysql_query: firstPlain(self: MysqlQuery): Future[seq[string]]
• mysql_query: firstPlain(self: RawMysqlQuery): Future[seq[string]]
• postgres_query: firstPlain(self: PostgresQuery): Future[seq[string]]
• postgres_query: firstPlain(self: RawPostgresQuery): Future[seq[string]]
• sqlite_query: firstPlain(self: RawSqliteQuery): Future[seq[string]]
• sqlite_query: firstPlain(self: SqliteQuery): Future[seq[string]]

float:

• column: float(_: type Column; name: string): Column

foreign:

• column: foreign(_: type Column; name: string): Column

ForeignOnDelete:

• enums: ForeignOnDelete

free:

• sqlite_rdb: free(z: cstring)

free_result:

• mariadb_rdb: free_result(result: PRES)
• mysql_rdb: free_result(result: PRES)

free_result_nonblocking:

• mariadb_rdb: free_result_nonblocking(MYSQL_RES: PRES): NetAsyncStatus
• mysql_rdb: free_result_nonblocking(MYSQL_RES: PRES): NetAsyncStatus

free_table:

• sqlite_rdb: free_table(result: cstringArray)

fromArray:

• postgres_lib: fromArray(_: type PGParams; args: JsonNode): PGParams

fromObj:

• mariadb_lib: fromObj(_: type MariadbParams; args: JsonNode; columns: seq[seq[string]]): MariadbParams
• mysql_lib: fromObj(_: type MysqlParams; args: JsonNode; columns: seq[seq[string]]): MysqlParams

fromObjArray:

• postgres_lib: fromObjArray(_: type PGParams; args: JsonNode): PGParams
• postgres_lib: fromObjArray(_: type PGParams; args: JsonNode; columns: seq[Row]): PGParams

fromSql:

• mariadb_generator: fromSql(self: MariadbQuery): MariadbQuery
• mysql_generator: fromSql(self: MysqlQuery): MysqlQuery
• postgres_generator: fromSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: fromSql(self: SqliteQuery): SqliteQuery
• surreal_generator: fromSql(self: SurrealQuery): SurrealQuery

get:

• mariadb_query: get(self: MariadbQuery): Future[seq[JsonNode]]
• mariadb_query: get[T](self: MariadbQuery; typ: typedesc[T]): Future[seq[T]]
• mariadb_query: get(self: RawMariadbQuery): Future[seq[JsonNode]]
• mysql_query: get(self: MysqlQuery): Future[seq[JsonNode]]
• mysql_query: get[T](self: MysqlQuery; typ: typedesc[T]): Future[seq[T]]
• mysql_query: get(self: RawMysqlQuery): Future[seq[JsonNode]]
• postgres_query: get(self: PostgresQuery): Future[seq[JsonNode]]
• postgres_query: get[T](self: PostgresQuery; typ: typedesc[T]): Future[seq[T]]
• postgres_query: get(self: RawPostgresQuery): Future[seq[JsonNode]]
• sqlite_query: get(self: RawSqliteQuery): Future[seq[JsonNode]]
• sqlite_query: get(self: SqliteQuery): Future[seq[JsonNode]]
• sqlite_query: get[T](self: SqliteQuery; typ: typedesc[T]): Future[seq[T]]
• surreal_query: get(self: RawSurrealQuery): Future[seq[JsonNode]]
• surreal_query: get(self: SurrealQuery): Future[seq[JsonNode]]

get_auxdata:

• sqlite_rdb: get_auxdata(para1: Pcontext; para2: int32): pointer

get_character_set_info:

• mariadb_rdb: get_character_set_info(MySQL: PMySQL; charset: PMY_CHARSET_INFO)
• mysql_rdb: get_character_set_info(MySQL: PMySQL; charset: PMY_CHARSET_INFO)

get_client_info:

• mariadb_rdb: get_client_info(): cstring
• mysql_rdb: get_client_info(): cstring

get_client_version:

• mariadb_rdb: get_client_version(): int
• mysql_rdb: get_client_version(): int

getColumns:

• mariadb_impl: getColumns(db: PMySQL; query: string; args: seq[string]; timeout: int): Future[ seq[string]]
• mysql_impl: getColumns(db: PMySQL; query: string; args: seq[string]; timeout: int): Future[ seq[string]]
• postgres_impl: getColumns(db: PPGconn; query: string; args: seq[string]; timeout: int): Future[ seq[string]]
• sqlite_impl: getColumns(db: PSqlite3; query: string; args: seq[string]; timeout: int): Future[ seq[string]]
• sqlite_lib: getColumns(db: PSqlite3; dbRows: var DbRows; query: string; args: seq[string]): seq[ string]

getColumnTypes:

• mariadb_impl: getColumnTypes(db: PMySQL; database, table: string; timeout: int): Future[ seq[database_types.Row]]
• mysql_impl: getColumnTypes(db: PMySQL; database, table: string; timeout: int): Future[ seq[database_types.Row]]
• sqlite_impl: getColumnTypes(db: PSqlite3; query: string): Future[seq[(string, string)]]

get_host_info:

• mariadb_rdb: get_host_info(MySQL: PMySQL): cstring
• mysql_rdb: get_host_info(MySQL: PMySQL): cstring

getOsName:

• mariadb_rdb: getOsName(): string
• mysql_rdb: getOsName(): string

get_parameters:

• mariadb_rdb: get_parameters(): PPARAMETERS
• mysql_rdb: get_parameters(): PPARAMETERS

getPlain:

• mariadb_query: getPlain(self: MariadbQuery): Future[seq[seq[string]]]
• mariadb_query: getPlain(self: RawMariadbQuery): Future[seq[seq[string]]]
• mysql_query: getPlain(self: MysqlQuery): Future[seq[seq[string]]]
• mysql_query: getPlain(self: RawMysqlQuery): Future[seq[seq[string]]]
• postgres_query: getPlain(self: PostgresQuery): Future[seq[seq[string]]]
• postgres_query: getPlain(self: RawPostgresQuery): Future[seq[seq[string]]]
• sqlite_query: getPlain(self: RawSqliteQuery): Future[seq[seq[string]]]
• sqlite_query: getPlain(self: SqliteQuery): Future[seq[seq[string]]]

get_proto_info:

• mariadb_rdb: get_proto_info(MySQL: PMySQL): cuint
• mysql_rdb: get_proto_info(MySQL: PMySQL): cuint

get_salt_from_password:

• mariadb_rdb: get_salt_from_password(res: pointer; password: cstring)
• mysql_rdb: get_salt_from_password(res: pointer; password: cstring)

get_salt_from_password_323:

• mariadb_rdb: get_salt_from_password_323(res: ptr int; password: cstring)
• mysql_rdb: get_salt_from_password_323(res: ptr int; password: cstring)

get_server_info:

• mariadb_rdb: get_server_info(MySQL: PMySQL): cstring
• mysql_rdb: get_server_info(MySQL: PMySQL): cstring

get_server_version:

• mariadb_rdb: get_server_version(MySQL: PMySQL): int
• mysql_rdb: get_server_version(MySQL: PMySQL): int

get_table:

• sqlite_rdb: get_table(para1: PSqlite3; sql: cstring; resultp: var cstringArray; nrow, ncolumn: var cint; errmsg: ptr cstring): int32

get_tty_password:

• mariadb_rdb: get_tty_password(opt_message: cstring): cstring
• mysql_rdb: get_tty_password(opt_message: cstring): cstring

gptr:

• mariadb_rdb: gptr
• mysql_rdb: gptr

groupAllSql:

• surreal_generator: groupAllSql(self: SurrealQuery): SurrealQuery

groupBy:

• mariadb_query: groupBy(self: MariadbQuery; column: string): MariadbQuery
• mysql_query: groupBy(self: MysqlQuery; column: string): MysqlQuery
• postgres_query: groupBy(self: PostgresQuery; column: string): PostgresQuery
• sqlite_query: groupBy(self: SqliteQuery; column: string): SqliteQuery
• surreal_query: groupBy(self: SurrealQuery; column: string): SurrealQuery

groupBySql:

• mariadb_generator: groupBySql(self: MariadbQuery): MariadbQuery
• mysql_generator: groupBySql(self: MysqlQuery): MysqlQuery
• postgres_generator: groupBySql(self: PostgresQuery): PostgresQuery
• sqlite_generator: groupBySql(self: SqliteQuery): SqliteQuery
• surreal_generator: groupBySql(self: SurrealQuery): SurrealQuery

GROUP_FLAG:

• mariadb_rdb: GROUP_FLAG
• mysql_rdb: GROUP_FLAG

hash_password:

• mariadb_rdb: hash_password(fto: int; password: cstring; password_len: cuint)
• mysql_rdb: hash_password(fto: int; password: cstring; password_len: cuint)

having:

• mariadb_query: having(self: MariadbQuery; column: string; symbol: string; value: string | int | float | bool): MariadbQuery
• mariadb_query: having(self: MariadbQuery; column: string; symbol: string; value: nil.type): MariadbQuery
• mysql_query: having(self: MysqlQuery; column: string; symbol: string; value: string | int | float | bool): MysqlQuery
• mysql_query: having(self: MysqlQuery; column: string; symbol: string; value: nil.type): MysqlQuery
• postgres_query: having(self: PostgresQuery; column: string; symbol: string; value: string | int | float | bool): PostgresQuery
• postgres_query: having(self: PostgresQuery; column: string; symbol: string; value: nil.type): PostgresQuery
• sqlite_query: having(self: SqliteQuery; column: string; symbol: string; value: string | int | float | bool): SqliteQuery
• sqlite_query: having(self: SqliteQuery; column: string; symbol: string; value: nil.type): SqliteQuery
• surreal_query: having(self: SurrealQuery; column: string; symbol: string; value: bool | int | float | string): SurrealQuery
• surreal_query: having(self: SurrealQuery; column: string; symbol: string; value: nil.type): SurrealQuery

havingSql:

• mariadb_generator: havingSql(self: MariadbQuery): MariadbQuery
• mysql_generator: havingSql(self: MysqlQuery): MysqlQuery
• postgres_generator: havingSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: havingSql(self: SqliteQuery): SqliteQuery

hex_string:

• mariadb_rdb: hex_string(fto: cstring; from: cstring; from_length: int): int
• mysql_rdb: hex_string(fto: cstring; from: cstring; from_length: int): int

HOSTNAME_LENGTH:

• mariadb_rdb: HOSTNAME_LENGTH
• mysql_rdb: HOSTNAME_LENGTH

increments:

• column: increments(_: type Column; name: string): Column

index:

• column: index(c: Column): Column

info:

• mariadb_rdb: info(MySQL: PMySQL): cstring
• mysql_rdb: info(MySQL: PMySQL): cstring
• surreal_impl: info(db: SurrealConn; query: string; args: JsonNode; timeout: int): Future[ JsonNode]
• surreal_impl: info(db: SurrealConn; query: string; args: seq[string]; timeout: int): Future[ JsonNode]
• surreal_query: info(self: RawSurrealQuery): Future[JsonNode]

init:

• mariadb_rdb: init(MySQL: PMySQL): PMySQL
• mysql_rdb: init(MySQL: PMySQL): PMySQL

INIT_COMMAND:

• Option.INIT_COMMAND
• Option.INIT_COMMAND

insert:

• mariadb_query: insert(self: MariadbQuery; items: JsonNode): owned(Future[void])
• mariadb_query: insert(self: MariadbQuery; items: seq[JsonNode]): owned(Future[void])
• mysql_query: insert(self: MysqlQuery; items: JsonNode): owned(Future[void])
• mysql_query: insert(self: MysqlQuery; items: seq[JsonNode]): owned(Future[void])
• postgres_query: insert(self: PostgresQuery; items: JsonNode): owned(Future[void])
• postgres_query: insert(self: PostgresQuery; items: seq[JsonNode]): owned(Future[void])
• sqlite_query: insert(self: SqliteQuery; items: JsonNode): owned(Future[void])
• sqlite_query: insert(self: SqliteQuery; items: seq[JsonNode]): owned(Future[void])
• surreal_query: insert(self: SurrealQuery; items: JsonNode): owned(Future[void])
• surreal_query: insert(self: SurrealQuery; items: seq[JsonNode]): owned(Future[void])

insert_id:

• mariadb_rdb: insert_id(MySQL: PMySQL): my_ulonglong
• mysql_rdb: insert_id(MySQL: PMySQL): my_ulonglong

insertId:

• mariadb_query: insertId(self: MariadbQuery; items: JsonNode; key = "id"): Future[string]
• mariadb_query: insertId(self: MariadbQuery; items: seq[JsonNode]; key = "id"): Future[ seq[string]]
• mysql_query: insertId(self: MysqlQuery; items: JsonNode; key = "id"): Future[string]
• mysql_query: insertId(self: MysqlQuery; items: seq[JsonNode]; key = "id"): Future[seq[string]]
• postgres_query: insertId(self: PostgresQuery; items: JsonNode; key = "id"): Future[string]
• postgres_query: insertId(self: PostgresQuery; items: seq[JsonNode]; key = "id"): Future[ seq[string]]
• sqlite_query: insertId(self: SqliteQuery; items: JsonNode; key = "id"): Future[string]
• sqlite_query: insertId(self: SqliteQuery; items: seq[JsonNode]; key = "id"): Future[ seq[string]]
• surreal_query: insertId(self: SurrealQuery; items: JsonNode; key = "id"): Future[SurrealId]
• surreal_query: insertId(self: SurrealQuery; items: seq[JsonNode]; key = "id"): Future[ seq[SurrealId]]

insertSql:

• mariadb_generator: insertSql(self: MariadbQuery): MariadbQuery
• mysql_generator: insertSql(self: MysqlQuery): MysqlQuery
• postgres_generator: insertSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: insertSql(self: SqliteQuery): SqliteQuery
• surreal_generator: insertSql(self: SurrealQuery): SurrealQuery

insertValueBuilder:

• mariadb_builder: insertValueBuilder(self: MariadbQuery; items: JsonNode): string
• mysql_builder: insertValueBuilder(self: MysqlQuery; items: JsonNode): string
• postgres_builder: insertValueBuilder(self: PostgresQuery; items: JsonNode): string
• sqlite_builder: insertValueBuilder(self: SqliteQuery; items: JsonNode): string
• surreal_builder: insertValueBuilder(self: SurrealQuery; items: JsonNode): string

insertValuesBuilder:

• mariadb_builder: insertValuesBuilder(self: MariadbQuery; rows: openArray[JsonNode]): string
• mysql_builder: insertValuesBuilder(self: MysqlQuery; rows: openArray[JsonNode]): string
• postgres_builder: insertValuesBuilder(self: PostgresQuery; rows: openArray[JsonNode]): string
• sqlite_builder: insertValuesBuilder(self: SqliteQuery; rows: openArray[JsonNode]): string
• surreal_builder: insertValuesBuilder(self: SurrealQuery; items: openArray[JsonNode]): string

insertValueSql:

• mariadb_generator: insertValueSql(self: MariadbQuery; items: JsonNode): MariadbQuery
• mysql_generator: insertValueSql(self: MysqlQuery; items: JsonNode): MysqlQuery
• postgres_generator: insertValueSql(self: PostgresQuery; items: JsonNode): PostgresQuery
• sqlite_generator: insertValueSql(self: SqliteQuery; items: JsonNode): SqliteQuery
• surreal_generator: insertValueSql(self: SurrealQuery; items: JsonNode): SurrealQuery

insertValuesSql:

• mariadb_generator: insertValuesSql(self: MariadbQuery; rows: openArray[JsonNode]): MariadbQuery
• mysql_generator: insertValuesSql(self: MysqlQuery; rows: openArray[JsonNode]): MysqlQuery
• postgres_generator: insertValuesSql(self: PostgresQuery; rows: openArray[JsonNode]): PostgresQuery
• sqlite_generator: insertValuesSql(self: SqliteQuery; rows: openArray[JsonNode]): SqliteQuery
• surreal_generator: insertValuesSql(self: SurrealQuery; rows: openArray[JsonNode]): SurrealQuery

InstantRow:

• sqlite_rdb: InstantRow

instantRows:

• sqlite_lib: instantRows(db: PSqlite3; dbRows: var DbRows; sqliteStmt: PStmt): InstantRow
• sqlite_lib: instantRows(db: PSqlite3; dbRows: var DbRows; query: string; args: seq[string]): InstantRow

instantRowsPlain:

• sqlite_lib: instantRowsPlain(db: PSqlite3; query: string; args: seq[string]): InstantRow

integer:

• column: integer(_: type Column; name: string): Column

INTERNAL_NUM_FIELD:

• mariadb_rdb: INTERNAL_NUM_FIELD(f: Pst_mysql_field): bool
• mysql_rdb: INTERNAL_NUM_FIELD(f: Pst_mysql_field): bool

interrupt:

• sqlite_rdb: interrupt(para1: PSqlite3)

INT_RESULT:

• Item_result.INT_RESULT
• Item_result.INT_RESULT

IS_BLOB:

• mariadb_rdb: IS_BLOB(n: int32): bool
• mysql_rdb: IS_BLOB(n: int32): bool

ISchema:

• schema_interface: ISchema

isExistsIndex:

• is_exists: isExistsIndex(rdb: MysqlConnections; table: Table; column: Column): Future[bool]

isExistsMariadb:

• env: isExistsMariadb

isExistsMysql:

• env: isExistsMysql

isExistsPostgres:

• env: isExistsPostgres

isExistsSqlite:

• env: isExistsSqlite

isExistsSurrealdb:

• env: isExistsSurrealdb

isExistsUnique:

• is_exists: isExistsUnique(rdb: MysqlConnections; table: Table; column: Column): Future[bool]

IS_NOT_NULL:

• mariadb_rdb: IS_NOT_NULL(n: int32): bool
• mysql_rdb: IS_NOT_NULL(n: int32): bool

IS_NUM:

• mariadb_rdb: IS_NUM(t: Enum_field_types): bool
• mysql_rdb: IS_NUM(t: Enum_field_types): bool

IS_NUM_FIELD:

• mariadb_rdb: IS_NUM_FIELD(f: Pst_mysql_field): bool
• mysql_rdb: IS_NUM_FIELD(f: Pst_mysql_field): bool

IS_PRI_KEY:

• mariadb_rdb: IS_PRI_KEY(n: int32): bool
• mysql_rdb: IS_PRI_KEY(n: int32): bool

Item_result:

• mariadb_rdb: Item_result
• mysql_rdb: Item_result

join:

• mariadb_query: join(self: MariadbQuery; table: string; column1: string; symbol: string; column2: string): MariadbQuery
• mysql_query: join(self: MysqlQuery; table: string; column1: string; symbol: string; column2: string): MysqlQuery
• postgres_query: join(self: PostgresQuery; table: string; column1: string; symbol: string; column2: string): PostgresQuery
• sqlite_query: join(self: SqliteQuery; table: string; column1: string; symbol: string; column2: string): SqliteQuery

joinSql:

• mariadb_generator: joinSql(self: MariadbQuery): MariadbQuery
• mysql_generator: joinSql(self: MysqlQuery): MysqlQuery
• postgres_generator: joinSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: joinSql(self: SqliteQuery): SqliteQuery

json:

• column: json(_: type Column; name: string): Column

kill:

• mariadb_rdb: kill(MySQL: PMySQL; pid: int): cint
• mysql_rdb: kill(MySQL: PMySQL; pid: int): cint

KILL_CONNECTION:

• Enum_shutdown_level.KILL_CONNECTION
• Enum_shutdown_level.KILL_CONNECTION

KILL_QUERY:

• Enum_shutdown_level.KILL_QUERY
• Enum_shutdown_level.KILL_QUERY

last_insert_rowid:

• sqlite_rdb: last_insert_rowid(para1: PSqlite3): int64

leftJoin:

• mariadb_query: leftJoin(self: MariadbQuery; table: string; column1: string; symbol: string; column2: string): MariadbQuery
• mysql_query: leftJoin(self: MysqlQuery; table: string; column1: string; symbol: string; column2: string): MysqlQuery
• postgres_query: leftJoin(self: PostgresQuery; table: string; column1: string; symbol: string; column2: string): PostgresQuery
• sqlite_query: leftJoin(self: SqliteQuery; table: string; column1: string; symbol: string; column2: string): SqliteQuery

leftJoinSql:

• mariadb_generator: leftJoinSql(self: MariadbQuery): MariadbQuery
• mysql_generator: leftJoinSql(self: MysqlQuery): MysqlQuery
• postgres_generator: leftJoinSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: leftJoinSql(self: SqliteQuery): SqliteQuery

len:

• sqlite_lib: len(row: InstantRow): int32

library_end:

• mariadb_rdb: library_end()
• mysql_rdb: library_end()

library_init:

• mariadb_rdb: library_init(argc: cint; argv: cstringArray; groups: cstringArray): cint
• mysql_rdb: library_init(argc: cint; argv: cstringArray; groups: cstringArray): cint

libversion:

• sqlite_rdb: libversion(): cstring

libversion_number:

• sqlite_rdb: libversion_number(): int32

limit:

• mariadb_query: limit(self: MariadbQuery; num: int): MariadbQuery
• mysql_query: limit(self: MysqlQuery; num: int): MysqlQuery
• postgres_query: limit(self: PostgresQuery; num: int): PostgresQuery
• sqlite_query: limit(self: SqliteQuery; num: int): SqliteQuery
• surreal_query: limit(self: SurrealQuery; num: int): SurrealQuery

limitSql:

• mariadb_generator: limitSql(self: MariadbQuery): MariadbQuery
• mysql_generator: limitSql(self: MysqlQuery): MysqlQuery
• postgres_generator: limitSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: limitSql(self: SqliteQuery): SqliteQuery
• surreal_generator: limitSql(self: SurrealQuery): SurrealQuery

list_dbs:

• mariadb_rdb: list_dbs(MySQL: PMySQL; wild: cstring): PRES
• mysql_rdb: list_dbs(MySQL: PMySQL; wild: cstring): PRES

list_fields:

• mariadb_rdb: list_fields(MySQL: PMySQL; table: cstring; wild: cstring): PRES
• mysql_rdb: list_fields(MySQL: PMySQL; table: cstring; wild: cstring): PRES

list_processes:

• mariadb_rdb: list_processes(MySQL: PMySQL): PRES
• mysql_rdb: list_processes(MySQL: PMySQL): PRES

list_tables:

• mariadb_rdb: list_tables(MySQL: PMySQL; wild: cstring): PRES
• mysql_rdb: list_tables(MySQL: PMySQL; wild: cstring): PRES

load_defaults:

• mariadb_rdb: load_defaults(conf_file: cstring; groups: cstringArray; argc: ptr cint; argv: ptr cstringArray): cint
• mysql_rdb: load_defaults(conf_file: cstring; groups: cstringArray; argc: ptr cint; argv: ptr cstringArray): cint

LOCAL_HOST:

• mariadb_rdb: LOCAL_HOST
• mysql_rdb: LOCAL_HOST

LOCAL_HOST_NAMEDPIPE:

• mariadb_rdb: LOCAL_HOST_NAMEDPIPE
• mysql_rdb: LOCAL_HOST_NAMEDPIPE

LOCAL_INFILE_ERROR_LEN:

• mariadb_rdb: LOCAL_INFILE_ERROR_LEN
• mysql_rdb: LOCAL_INFILE_ERROR_LEN

lo_close:

• postgres_rdb: lo_close(conn: PPGconn; fd: int32): int32

lo_creat:

• postgres_rdb: lo_creat(conn: PPGconn; mode: int32): Oid

lo_export:

• postgres_rdb: lo_export(conn: PPGconn; lobjId: Oid; filename: cstring): int32

logger:

• log: logger(self: LogSetting; output: auto)

LogSetting:

• log: LogSetting

lo_import:

• postgres_rdb: lo_import(conn: PPGconn; filename: cstring): Oid

lo_lseek:

• postgres_rdb: lo_lseek(conn: PPGconn; fd: int32; offset: int32; whence: int32): int32

LONG_DATA_HEADER:

• mariadb_rdb: LONG_DATA_HEADER
• mysql_rdb: LONG_DATA_HEADER

longText:

• column: longText(_: type Column; name: string): Column

lo_open:

• postgres_rdb: lo_open(conn: PPGconn; lobjId: Oid; mode: int32): int32

lo_read:

• postgres_rdb: lo_read(conn: PPGconn; fd: int32; buf: cstring; length: int): int32

lo_tell:

• postgres_rdb: lo_tell(conn: PPGconn; fd: int32): int32

lo_unlink:

• postgres_rdb: lo_unlink(conn: PPGconn; lobjId: Oid): int32

lo_write:

• postgres_rdb: lo_write(conn: PPGconn; fd: int32; buf: cstring; length: int): int32

make_password_from_salt:

• mariadb_rdb: make_password_from_salt(fto: cstring; hash_stage2: pointer)
• mysql_rdb: make_password_from_salt(fto: cstring; hash_stage2: pointer)

make_password_from_salt_323:

• mariadb_rdb: make_password_from_salt_323(fto: cstring; salt: ptr int)
• mysql_rdb: make_password_from_salt_323(fto: cstring; salt: ptr int)

make_scrambled_password:

• mariadb_rdb: make_scrambled_password(fto: cstring; password: cstring)
• mysql_rdb: make_scrambled_password(fto: cstring; password: cstring)

make_scrambled_password_323:

• mariadb_rdb: make_scrambled_password_323(fto: cstring; password: cstring)
• mysql_rdb: make_scrambled_password_323(fto: cstring; password: cstring)

MANAGER:

• mariadb_rdb: MANAGER
• mysql_rdb: MANAGER

MANAGER_ACCESS:

• mariadb_rdb: MANAGER_ACCESS
• mysql_rdb: MANAGER_ACCESS

MANAGER_CLIENT_ERR:

• mariadb_rdb: MANAGER_CLIENT_ERR
• mysql_rdb: MANAGER_CLIENT_ERR

manager_close:

• mariadb_rdb: manager_close(con: PMANAGER)
• mysql_rdb: manager_close(con: PMANAGER)

manager_command:

• mariadb_rdb: manager_command(con: PMANAGER; cmd: cstring; cmd_len: cint): cint
• mysql_rdb: manager_command(con: PMANAGER; cmd: cstring; cmd_len: cint): cint

manager_connect:

• mariadb_rdb: manager_connect(con: PMANAGER; host: cstring; user: cstring; passwd: cstring; port: cuint): PMANAGER
• mysql_rdb: manager_connect(con: PMANAGER; host: cstring; user: cstring; passwd: cstring; port: cuint): PMANAGER

manager_fetch_line:

• mariadb_rdb: manager_fetch_line(con: PMANAGER; res_buf: cstring; res_buf_size: cint): cint
• mysql_rdb: manager_fetch_line(con: PMANAGER; res_buf: cstring; res_buf_size: cint): cint

MANAGER_INFO:

• mariadb_rdb: MANAGER_INFO
• mysql_rdb: MANAGER_INFO

manager_init:

• mariadb_rdb: manager_init(con: PMANAGER): PMANAGER
• mysql_rdb: manager_init(con: PMANAGER): PMANAGER

MANAGER_INTERNAL_ERR:

• mariadb_rdb: MANAGER_INTERNAL_ERR
• mysql_rdb: MANAGER_INTERNAL_ERR

MANAGER_OK:

• mariadb_rdb: MANAGER_OK
• mysql_rdb: MANAGER_OK

MariaDB:

• mariadb_types: MariaDB

MariadbConnection:

• mariadb_types: MariadbConnection

MariadbConnectionInfo:

• mariadb_types: MariadbConnectionInfo

MariadbConnections:

• mariadb_types: MariadbConnections

MariadbParams:

• mariadb_lib: MariadbParams

MariadbParamValue:

• mariadb_lib: MariadbParamValue

MariadbQuery:

• mariadb_types: MariadbQuery

MariadbSchema:

• mariadb_query_type: MariadbSchema

master_query:

• mariadb_rdb: master_query(MySQL: PMySQL; q: cstring; len: int): my_bool
• mysql_rdb: master_query(MySQL: PMySQL; q: cstring; len: int): my_bool

master_send_query:

• mariadb_rdb: master_send_query(MySQL: PMySQL; q: cstring; len: int): my_bool
• mysql_rdb: master_send_query(MySQL: PMySQL; q: cstring; len: int): my_bool

max:

• mariadb_query: max(self: MariadbQuery; column: string): Future[Option[string]]
• mysql_query: max(self: MysqlQuery; column: string): Future[Option[string]]
• postgres_query: max(self: PostgresQuery; column: string): Future[Option[string]]
• sqlite_query: max(self: SqliteQuery; column: string): Future[Option[string]]
• surreal_query: max(self: SurrealQuery; column: string; collaction: Collation = None): Future[ string]

MAX_BIGINT_WIDTH:

• mariadb_rdb: MAX_BIGINT_WIDTH
• mysql_rdb: MAX_BIGINT_WIDTH

MAX_BLOB_WIDTH:

• mariadb_rdb: MAX_BLOB_WIDTH
• mysql_rdb: MAX_BLOB_WIDTH

maxBuilder:

• mariadb_builder: maxBuilder(self: MariadbQuery; column: string): string
• mysql_builder: maxBuilder(self: MysqlQuery; column: string): string
• postgres_builder: maxBuilder(self: PostgresQuery; column: string): string
• sqlite_builder: maxBuilder(self: SqliteQuery; column: string): string

MAX_CHAR_WIDTH:

• mariadb_rdb: MAX_CHAR_WIDTH
• mysql_rdb: MAX_CHAR_WIDTH

maxFromSql:

• surreal_generator: maxFromSql(self: SurrealQuery; column: string): SurrealQuery

MAX_INT_WIDTH:

• mariadb_rdb: MAX_INT_WIDTH
• mysql_rdb: MAX_INT_WIDTH

MAX_MEDIUMINT_WIDTH:

• mariadb_rdb: MAX_MEDIUMINT_WIDTH
• mysql_rdb: MAX_MEDIUMINT_WIDTH

MAX_MYSQL_MANAGER_ERR:

• mariadb_rdb: MAX_MYSQL_MANAGER_ERR
• mysql_rdb: MAX_MYSQL_MANAGER_ERR

MAX_MYSQL_MANAGER_MSG:

• mariadb_rdb: MAX_MYSQL_MANAGER_MSG
• mysql_rdb: MAX_MYSQL_MANAGER_MSG

MAX_SMALLINT_WIDTH:

• mariadb_rdb: MAX_SMALLINT_WIDTH
• mysql_rdb: MAX_SMALLINT_WIDTH

MAX_TINYINT_WIDTH:

• mariadb_rdb: MAX_TINYINT_WIDTH
• mysql_rdb: MAX_TINYINT_WIDTH

mediumInteger:

• column: mediumInteger(_: type Column; name: string): Column

mediumText:

• column: mediumText(_: type Column; name: string): Column

MEM_ROOT:

• mariadb_rdb: MEM_ROOT
• mysql_rdb: MEM_ROOT

METHODS:

• mariadb_rdb: METHODS
• mysql_rdb: METHODS

migrationTable:

• migration_table_def: migrationTable

min:

• mariadb_query: min(self: MariadbQuery; column: string): Future[Option[string]]
• mysql_query: min(self: MysqlQuery; column: string): Future[Option[string]]
• postgres_query: min(self: PostgresQuery; column: string): Future[Option[string]]
• sqlite_query: min(self: SqliteQuery; column: string): Future[Option[string]]
• surreal_query: min(self: SurrealQuery; column: string; collaction: Collation = None): Future[ string]

minBuilder:

• mariadb_builder: minBuilder(self: MariadbQuery; column: string): string
• mysql_builder: minBuilder(self: MysqlQuery; column: string): string
• postgres_builder: minBuilder(self: PostgresQuery; column: string): string
• sqlite_builder: minBuilder(self: SqliteQuery; column: string): string

modify_defaults_file:

• mariadb_rdb: modify_defaults_file(file_location: cstring; option: cstring; option_value: cstring; section_name: cstring; remove_option: cint): cint
• mysql_rdb: modify_defaults_file(file_location: cstring; option: cstring; option_value: cstring; section_name: cstring; remove_option: cint): cint

more_results:

• mariadb_rdb: more_results(MySQL: PMySQL): my_bool
• mysql_rdb: more_results(MySQL: PMySQL): my_bool

mprintf:

• sqlite_rdb: mprintf(para1: cstring): cstring

MULTIPLE_KEY_FLAG:

• mariadb_rdb: MULTIPLE_KEY_FLAG
• mysql_rdb: MULTIPLE_KEY_FLAG

my_bool:

• mariadb_rdb: my_bool
• mysql_rdb: my_bool

MY_CHARSET_INFO:

• mariadb_rdb: MY_CHARSET_INFO
• mysql_rdb: MY_CHARSET_INFO

my_connect:

• mariadb_rdb: my_connect(s: my_socket; name: Psockaddr; namelen: cuint; timeout: cuint): cint
• mysql_rdb: my_connect(s: my_socket; name: Psockaddr; namelen: cuint; timeout: cuint): cint

my_init:

• mariadb_rdb: my_init(): my_bool
• mysql_rdb: my_init(): my_bool

my_net_init:

• mariadb_rdb: my_net_init(net: PNET; vio: PVIO): my_bool
• mysql_rdb: my_net_init(net: PNET; vio: PVIO): my_bool

my_net_local_init:

• mariadb_rdb: my_net_local_init(net: PNET)
• mysql_rdb: my_net_local_init(net: PNET)

my_net_read:

• mariadb_rdb: my_net_read(net: PNET): int
• mysql_rdb: my_net_read(net: PNET): int

my_net_write:

• mariadb_rdb: my_net_write(net: PNET; packet: cstring; length: int): my_bool
• mysql_rdb: my_net_write(net: PNET; packet: cstring; length: int): my_bool

myodbc_remove_escape:

• mariadb_rdb: myodbc_remove_escape(MySQL: PMySQL; name: cstring)
• mysql_rdb: myodbc_remove_escape(MySQL: PMySQL; name: cstring)

my_rnd:

• mariadb_rdb: my_rnd(para1: Prand_struct): cdouble
• mysql_rdb: my_rnd(para1: Prand_struct): cdouble

my_socket:

• mariadb_rdb: my_socket
• mysql_rdb: my_socket

MySQL:

• mariadb_rdb: MySQL
• mysql_types: MySQL

MysqlConnection:

• mysql_types: MysqlConnection

MysqlConnectionInfo:

• mysql_types: MysqlConnectionInfo

MysqlConnections:

• mysql_types: MysqlConnections

MYSQL_OPT_NONBLOCK:

• Option.MYSQL_OPT_NONBLOCK
• Option.MYSQL_OPT_NONBLOCK

MysqlParams:

• mysql_lib: MysqlParams

MysqlParamValue:

• mysql_lib: MysqlParamValue

MysqlQuery:

• mysql_types: MysqlQuery

MysqlSchema:

• mysql_query_type: MysqlSchema

my_thread_end:

• mariadb_rdb: my_thread_end()
• mysql_rdb: my_thread_end()

my_thread_init:

• mariadb_rdb: my_thread_init(): my_bool
• mysql_rdb: my_thread_init(): my_bool

my_ulonglong:

• mariadb_rdb: my_ulonglong
• mysql_rdb: my_ulonglong

NAMEDPIPE:

• mariadb_rdb: NAMEDPIPE
• mysql_rdb: NAMEDPIPE

NAME_LEN:

• mariadb_rdb: NAME_LEN
• mysql_rdb: NAME_LEN

NET:

• mariadb_rdb: NET
• mysql_rdb: NET

NET_ASYNC_COMPLETE:

• NetAsyncStatus.NET_ASYNC_COMPLETE
• NetAsyncStatus.NET_ASYNC_COMPLETE

NET_ASYNC_COMPLETE_NO_MORE_RESULTS:

• NetAsyncStatus.NET_ASYNC_COMPLETE_NO_MORE_RESULTS
• NetAsyncStatus.NET_ASYNC_COMPLETE_NO_MORE_RESULTS

NET_ASYNC_ERROR:

• NetAsyncStatus.NET_ASYNC_ERROR
• NetAsyncStatus.NET_ASYNC_ERROR

NET_ASYNC_NOT_READY:

• NetAsyncStatus.NET_ASYNC_NOT_READY
• NetAsyncStatus.NET_ASYNC_NOT_READY

NetAsyncStatus:

• mariadb_rdb: NetAsyncStatus
• mysql_rdb: NetAsyncStatus

net_clear:

• mariadb_rdb: net_clear(net: PNET)
• mysql_rdb: net_clear(net: PNET)

net_end:

• mariadb_rdb: net_end(net: PNET)
• mysql_rdb: net_end(net: PNET)

net_flush:

• mariadb_rdb: net_flush(net: PNET): my_bool
• mysql_rdb: net_flush(net: PNET): my_bool

NET_HEADER_SIZE:

• mariadb_rdb: NET_HEADER_SIZE
• mysql_rdb: NET_HEADER_SIZE

NET_READ_TIMEOUT:

• mariadb_rdb: NET_READ_TIMEOUT
• mysql_rdb: NET_READ_TIMEOUT

net_realloc:

• mariadb_rdb: net_realloc(net: PNET; len: int): my_bool
• mysql_rdb: net_realloc(net: PNET; len: int): my_bool

net_real_write:

• mariadb_rdb: net_real_write(net: PNET; packet: cstring; length: int): cint
• mysql_rdb: net_real_write(net: PNET; packet: cstring; length: int): cint

net_safe_read:

• mariadb_rdb: net_safe_read(MySQL: PMySQL): cuint
• mysql_rdb: net_safe_read(MySQL: PMySQL): cuint

NET_WAIT_TIMEOUT:

• mariadb_rdb: NET_WAIT_TIMEOUT
• mysql_rdb: NET_WAIT_TIMEOUT

net_write_command:

• mariadb_rdb: net_write_command(net: PNET; command: char; header: cstring; head_len: int; packet: cstring; length: int): my_bool
• mysql_rdb: net_write_command(net: PNET; command: char; header: cstring; head_len: int; packet: cstring; length: int): my_bool

NET_WRITE_TIMEOUT:

• mariadb_rdb: NET_WRITE_TIMEOUT
• mysql_rdb: NET_WRITE_TIMEOUT

new:

• surreal_types: new(_: type SurrealId): SurrealId
• surreal_types: new(_: type SurrealId; rawId: string): SurrealId
• surreal_types: new(_: type SurrealId; table, id: string): SurrealId
• surreal_types: new(_: type SurrealQuery; log: LogSetting; pools: seq[SurrealConnection]; timeout: int; query: JsonNode): SurrealQuery
• mariadb_query_type: new(_: type MariadbSchema; rdb: MariadbConnections; table: Table): MariadbSchema
• mariadb_query_type: new(_: type MariadbSchema; rdb: MariadbConnections; table: Table; column: Column): MariadbSchema
• mysql_query_type: new(_: type MysqlSchema; rdb: MysqlConnections; table: Table): MysqlSchema
• mysql_query_type: new(_: type MysqlSchema; rdb: MysqlConnections; table: Table; column: Column): MysqlSchema
• postgres_query_type: new(_: type PostgresSchema; rdb: PostgresConnections; table: Table): PostgresSchema
• postgres_query_type: new(_: type PostgresSchema; rdb: PostgresConnections; table: Table; column: Column): PostgresSchema
• sqlite_query_type: new(_: type SqliteSchema; rdb: SqliteConnections; table: Table): SqliteSchema
• sqlite_query_type: new(_: type SqliteSchema; rdb: SqliteConnections; table: Table; column: Column): SqliteSchema
• surreal_query_type: new(_: type SurrealSchema; rdb: SurrealConnections; table: Table): SurrealSchema
• surreal_query_type: new(_: type SurrealSchema; rdb: SurrealConnections; table: Table; column: Column): SurrealSchema

newRow:

• postgres_lib: newRow(L: int): Row

next_result:

• mariadb_rdb: next_result(MySQL: PMySQL): cint
• mysql_rdb: next_result(MySQL: PMySQL): cint

NO_ACTION:

• ForeignOnDelete.NO_ACTION

NO_DATA:

• mariadb_rdb: NO_DATA
• mysql_rdb: NO_DATA

NO_DEFAULT_VALUE_FLAG:

• mariadb_rdb: NO_DEFAULT_VALUE_FLAG
• mysql_rdb: NO_DEFAULT_VALUE_FLAG

None:

• Collation.None
• DefaultDateTime.None

notAllowedOption:

• schema_utils: notAllowedOption(option, typ, column: string)
• schema_utils: notAllowedOption(option, typ, column: string)
• schema_utils: notAllowedOption(option, typ, column: string)
• schema_utils: notAllowedOption(option, typ, column: string)
• schema_utils: notAllowedOption(option, typ, column: string)

notAllowedType:

• schema_utils: notAllowedType(typ: string)
• schema_utils: notAllowedType(typ: string)
• schema_utils: notAllowedType(typ: string)
• schema_utils: notAllowedType(typ: string)
• schema_utils: notAllowedType(typ: string)

NOT_NULL_FLAG:

• mariadb_rdb: NOT_NULL_FLAG
• mysql_rdb: NOT_NULL_FLAG

nullable:

• column: nullable(c: Column): Column

NULL_LENGTH:

• mariadb_rdb: NULL_LENGTH
• mysql_rdb: NULL_LENGTH

Numeric:

• Collation.Numeric

num_fields:

• mariadb_rdb: num_fields(res: PRES): cuint
• mysql_rdb: num_fields(res: PRES): cuint

NUM_FLAG:

• mariadb_rdb: NUM_FLAG
• mysql_rdb: NUM_FLAG

num_rows:

• mariadb_rdb: num_rows(res: PRES): my_ulonglong
• mysql_rdb: num_rows(res: PRES): my_ulonglong

numToAlphabet:

• surreal_lib: numToAlphabet(n: int): string

octet2hex:

• mariadb_rdb: octet2hex(fto: cstring; str: cstring; length: cuint): cstring
• mysql_rdb: octet2hex(fto: cstring; str: cstring; length: cuint): cstring

offset:

• mariadb_query: offset(self: MariadbQuery; num: int): MariadbQuery
• mysql_query: offset(self: MysqlQuery; num: int): MysqlQuery
• postgres_query: offset(self: PostgresQuery; num: int): PostgresQuery
• sqlite_query: offset(self: SqliteQuery; num: int): SqliteQuery

offsetSql:

• mariadb_generator: offsetSql(self: MariadbQuery): MariadbQuery
• mysql_generator: offsetSql(self: MysqlQuery): MysqlQuery
• postgres_generator: offsetSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: offsetSql(self: SqliteQuery): SqliteQuery

Oid:

• postgres_rdb: Oid

on:

• column: on(self: Column; table: string): Column

onDelete:

• column: onDelete(self: Column; kind: ForeignOnDelete): Column

ONLY_KILL_QUERY:

• mariadb_rdb: ONLY_KILL_QUERY
• mysql_rdb: ONLY_KILL_QUERY

open:

• sqlite_rdb: open(filename: cstring; ppDb: var PSqlite3): int32

open16:

• sqlite_rdb: open16(filename: pointer; ppDb: var PSqlite3): int32

OPT_COMPRESS:

• Option.OPT_COMPRESS
• Option.OPT_COMPRESS

OPT_CONNECT_TIMEOUT:

• Option.OPT_CONNECT_TIMEOUT
• Option.OPT_CONNECT_TIMEOUT

OPT_GUESS_CONNECTION:

• Option.OPT_GUESS_CONNECTION
• Option.OPT_GUESS_CONNECTION

Option:

• mariadb_rdb: Option
• mysql_rdb: Option

OPTION_MULTI_STATEMENTS_OFF:

• Enum_mysql_set_option.OPTION_MULTI_STATEMENTS_OFF
• Enum_mysql_set_option.OPTION_MULTI_STATEMENTS_OFF

OPTION_MULTI_STATEMENTS_ON:

• Enum_mysql_set_option.OPTION_MULTI_STATEMENTS_ON
• Enum_mysql_set_option.OPTION_MULTI_STATEMENTS_ON

options:

• mariadb_rdb: options(MySQL: PMySQL; option: Option; arg: cstring): cint
• mysql_rdb: options(MySQL: PMySQL; option: Option; arg: cstring): cint

OPT_LOCAL_INFILE:

• Option.OPT_LOCAL_INFILE
• Option.OPT_LOCAL_INFILE

OPT_NAMED_PIPE:

• Option.OPT_NAMED_PIPE
• Option.OPT_NAMED_PIPE

OPT_PROTOCOL:

• Option.OPT_PROTOCOL
• Option.OPT_PROTOCOL

OPT_READ_TIMEOUT:

• Option.OPT_READ_TIMEOUT
• Option.OPT_READ_TIMEOUT

OPT_RECONNECT:

• Option.OPT_RECONNECT
• Option.OPT_RECONNECT

OPT_USE_EMBEDDED_CONNECTION:

• Option.OPT_USE_EMBEDDED_CONNECTION
• Option.OPT_USE_EMBEDDED_CONNECTION

OPT_USE_REMOTE_CONNECTION:

• Option.OPT_USE_REMOTE_CONNECTION
• Option.OPT_USE_REMOTE_CONNECTION

OPT_USE_RESULT:

• Option.OPT_USE_RESULT
• Option.OPT_USE_RESULT

OPT_WRITE_TIMEOUT:

• Option.OPT_WRITE_TIMEOUT
• Option.OPT_WRITE_TIMEOUT

Order:

• enums: Order

orderBy:

• mariadb_query: orderBy(self: MariadbQuery; column: string; order: Order): MariadbQuery
• mysql_query: orderBy(self: MysqlQuery; column: string; order: Order): MysqlQuery
• postgres_query: orderBy(self: PostgresQuery; column: string; order: Order): PostgresQuery
• sqlite_query: orderBy(self: SqliteQuery; column: string; order: Order): SqliteQuery
• surreal_query: orderBy(self: SurrealQuery; column: string; collation: Collation; order: Order): SurrealQuery
• surreal_query: orderBy(self: SurrealQuery; column: string; order: Order): SurrealQuery

orderBySql:

• mariadb_generator: orderBySql(self: MariadbQuery): MariadbQuery
• mysql_generator: orderBySql(self: MysqlQuery): MysqlQuery
• postgres_generator: orderBySql(self: PostgresQuery): PostgresQuery
• sqlite_generator: orderBySql(self: SqliteQuery): SqliteQuery
• surreal_generator: orderBySql(self: SurrealQuery): SurrealQuery

orWhere:

• mariadb_query: orWhere(self: MariadbQuery; column: string; symbol: string; value: string | int | float | bool): MariadbQuery
• mariadb_query: orWhere(self: MariadbQuery; column: string; symbol: string; value: nil.type): MariadbQuery
• mysql_query: orWhere(self: MysqlQuery; column: string; symbol: string; value: string | int | float | bool): MysqlQuery
• mysql_query: orWhere(self: MysqlQuery; column: string; symbol: string; value: nil.type): MysqlQuery
• postgres_query: orWhere(self: PostgresQuery; column: string; symbol: string; value: string | int | float | bool): PostgresQuery
• postgres_query: orWhere(self: PostgresQuery; column: string; symbol: string; value: nil.type): PostgresQuery
• sqlite_query: orWhere(self: SqliteQuery; column: string; symbol: string; value: string | int | float | bool): SqliteQuery
• sqlite_query: orWhere(self: SqliteQuery; column: string; symbol: string; value: nil.type): SqliteQuery
• surreal_query: orWhere(self: SurrealQuery; column: string; symbol: string; value: bool | int | float | string | SurrealId): SurrealQuery
• surreal_query: orWhere(self: SurrealQuery; column: string; symbol: string; value: nil.type): SurrealQuery

orWhereSql:

• mariadb_generator: orWhereSql(self: MariadbQuery): MariadbQuery
• mysql_generator: orWhereSql(self: MysqlQuery): MysqlQuery
• postgres_generator: orWhereSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: orWhereSql(self: SqliteQuery): SqliteQuery
• surreal_generator: orWhereSql(self: SurrealQuery): SurrealQuery

packet_error:

• mariadb_rdb: packet_error
• mysql_rdb: packet_error

parallel:

• surreal_query: parallel(self: SurrealQuery): SurrealQuery

parallelSql:

• surreal_generator: parallelSql(self: SurrealQuery): SurrealQuery

PARAMETERS:

• mariadb_rdb: PARAMETERS
• mysql_rdb: PARAMETERS

PART_KEY_FLAG:

• mariadb_rdb: PART_KEY_FLAG
• mysql_rdb: PART_KEY_FLAG

PBIND:

• mariadb_rdb: PBIND
• mysql_rdb: PBIND

Pcharacter_set:

• mariadb_rdb: Pcharacter_set
• mysql_rdb: Pcharacter_set

Pcharset_info_st:

• mariadb_rdb: Pcharset_info_st
• mysql_rdb: Pcharset_info_st

PConnStatusType:

• postgres_rdb: PConnStatusType

Pcontext:

• sqlite_rdb: Pcontext

PDATA:

• mariadb_rdb: PDATA
• mysql_rdb: PDATA

PExecStatusType:

• postgres_rdb: PExecStatusType

PFIELD:

• mariadb_rdb: PFIELD
• mysql_rdb: PFIELD

PFIELD_OFFSET:

• mariadb_rdb: PFIELD_OFFSET
• mysql_rdb: PFIELD_OFFSET

PGCancel:

• postgres_rdb: PGCancel

PGconn:

• postgres_rdb: PGconn

PGlobjfuncs:

• postgres_rdb: PGlobjfuncs

pgNotify:

• postgres_rdb: pgNotify

PGParams:

• postgres_lib: PGParams

Pgptr:

• mariadb_rdb: Pgptr
• mysql_rdb: Pgptr

PGresAttDesc:

• postgres_rdb: PGresAttDesc

PGresAttValue:

• postgres_rdb: PGresAttValue

PGRES_BAD_RESPONSE:

• ExecStatusType.PGRES_BAD_RESPONSE

PGRES_COMMAND_OK:

• ExecStatusType.PGRES_COMMAND_OK

PGRES_COPY_BOTH:

• ExecStatusType.PGRES_COPY_BOTH

PGRES_COPY_IN:

• ExecStatusType.PGRES_COPY_IN

PGRES_COPY_OUT:

• ExecStatusType.PGRES_COPY_OUT

PGRES_EMPTY_QUERY:

• ExecStatusType.PGRES_EMPTY_QUERY

PGRES_FATAL_ERROR:

• ExecStatusType.PGRES_FATAL_ERROR

PGRES_NONFATAL_ERROR:

• ExecStatusType.PGRES_NONFATAL_ERROR

PGRES_POLLING_ACTIVE:

• PostgresPollingStatusType.PGRES_POLLING_ACTIVE

PGRES_POLLING_FAILED:

• PostgresPollingStatusType.PGRES_POLLING_FAILED

PGRES_POLLING_OK:

• PostgresPollingStatusType.PGRES_POLLING_OK

PGRES_POLLING_READING:

• PostgresPollingStatusType.PGRES_POLLING_READING

PGRES_POLLING_WRITING:

• PostgresPollingStatusType.PGRES_POLLING_WRITING

PGRES_SINGLE_TUPLE:

• ExecStatusType.PGRES_SINGLE_TUPLE

PGRES_TUPLES_OK:

• ExecStatusType.PGRES_TUPLES_OK

PGresult:

• postgres_rdb: PGresult

PGTransactionStatusType:

• postgres_rdb: PGTransactionStatusType

PGVerbosity:

• postgres_rdb: PGVerbosity

ping:

• mariadb_rdb: ping(MySQL: PMySQL): cint
• mysql_rdb: ping(MySQL: PMySQL): cint

PItem_result:

• mariadb_rdb: PItem_result
• mysql_rdb: PItem_result

PMANAGER:

• mariadb_rdb: PMANAGER
• mysql_rdb: PMANAGER

PMEM_ROOT:

• mariadb_rdb: PMEM_ROOT
• mysql_rdb: PMEM_ROOT

PMETHODS:

• mariadb_rdb: PMETHODS
• mysql_rdb: PMETHODS

Pmy_bool:

• mariadb_rdb: Pmy_bool
• mysql_rdb: Pmy_bool

PMY_CHARSET_INFO:

• mariadb_rdb: PMY_CHARSET_INFO
• mysql_rdb: PMY_CHARSET_INFO

Pmy_socket:

• mariadb_rdb: Pmy_socket
• mysql_rdb: Pmy_socket

PMySQL:

• mariadb_rdb: PMySQL
• mysql_rdb: PMySQL

Pmy_ulonglong:

• mariadb_rdb: Pmy_ulonglong
• mysql_rdb: Pmy_ulonglong

PNET:

• mariadb_rdb: PNET
• mysql_rdb: PNET

POid:

• postgres_rdb: POid

PostgresConnection:

• postgres_types: PostgresConnection

PostgresConnections:

• postgres_types: PostgresConnections

PostgresPollingStatusType:

• postgres_rdb: PostgresPollingStatusType

PostgreSQL:

• postgres_types: PostgreSQL

PostgresQuery:

• postgres_types: PostgresQuery

PostgresSchema:

• postgres_query_type: PostgresSchema

PPARAMETERS:

• mariadb_rdb: PPARAMETERS
• mysql_rdb: PPARAMETERS

PPByte:

• mariadb_rdb: PPByte
• mysql_rdb: PPByte

PPGcancel:

• postgres_rdb: PPGcancel

PPGconn:

• postgres_rdb: PPGconn

PPGlobjfuncs:

• postgres_rdb: PPGlobjfuncs

PPGNotify:

• postgres_rdb: PPGNotify

PPGresAttDesc:

• postgres_rdb: PPGresAttDesc

PPGresAttValue:

• postgres_rdb: PPGresAttValue

PPGresult:

• postgres_rdb: PPGresult

PPGTransactionStatusType:

• postgres_rdb: PPGTransactionStatusType

PPGVerbosity:

• postgres_rdb: PPGVerbosity

PPostgresPollingStatusType:

• postgres_rdb: PPostgresPollingStatusType

PPPGresAttDesc:

• postgres_rdb: PPPGresAttDesc

PPPGresAttValue:

• postgres_rdb: PPPGresAttValue

PPQArgBlock:

• postgres_rdb: PPQArgBlock

Ppqbool:

• postgres_rdb: Ppqbool

PPQconninfoOption:

• postgres_rdb: PPQconninfoOption

PPQprintOpt:

• postgres_rdb: PPQprintOpt

PPSqlite3:

• sqlite_rdb: PPSqlite3

PPSqlite3_Backup:

• sqlite_rdb: PPSqlite3_Backup

PQArgBlock:

• postgres_rdb: PQArgBlock

pqbackendPID:

• postgres_rdb: pqbackendPID(conn: PPGconn): int32

pqbinaryTuples:

• postgres_rdb: pqbinaryTuples(res: PPGresult): int32

pqbool:

• postgres_rdb: pqbool

pqCancel:

• postgres_rdb: pqCancel(cancel: PPGcancel; errbuf: cstring; errbufsize: int32): int32

pqclear:

• postgres_rdb: pqclear(res: PPGresult)

pqclientEncoding:

• postgres_rdb: pqclientEncoding(conn: PPGconn): int32

pqcmdStatus:

• postgres_rdb: pqcmdStatus(res: PPGresult): cstring

pqcmdTuples:

• postgres_rdb: pqcmdTuples(res: PPGresult): cstring

pqconndefaults:

• postgres_rdb: pqconndefaults(): PPQconninfoOption

pqconnectdb:

• postgres_rdb: pqconnectdb(conninfo: cstring): PPGconn

pqconnectionNeedsPassword:

• postgres_rdb: pqconnectionNeedsPassword(conn: PPGconn): int32

pqconnectionUsedPassword:

• postgres_rdb: pqconnectionUsedPassword(conn: PPGconn): int32

pqconnectPoll:

• postgres_rdb: pqconnectPoll(conn: PPGconn): PostgresPollingStatusType

pqconnectStart:

• postgres_rdb: pqconnectStart(conninfo: cstring): PPGconn

pqconninfoFree:

• postgres_rdb: pqconninfoFree(connOptions: PPQconninfoOption)

PQconninfoOption:

• postgres_rdb: PQconninfoOption

pqconsumeInput:

• postgres_rdb: pqconsumeInput(conn: PPGconn): int32

pqdb:

• postgres_rdb: pqdb(conn: PPGconn): cstring

pqdisplayTuples:

• postgres_rdb: pqdisplayTuples(res: PPGresult; fp: File; fillAlign: int32; fieldSep: cstring; printHeader: int32; quiet: int32)

pqendcopy:

• postgres_rdb: pqendcopy(conn: PPGconn): int32

pqenv2encoding:

• postgres_rdb: pqenv2encoding(): int32

pqerrorMessage:

• postgres_rdb: pqerrorMessage(conn: PPGconn): cstring

PQERRORS_DEFAULT:

• PGVerbosity.PQERRORS_DEFAULT

PQERRORS_SQLSTATE:

• PGVerbosity.PQERRORS_SQLSTATE

PQERRORS_TERSE:

• PGVerbosity.PQERRORS_TERSE

PQERRORS_VERBOSE:

• PGVerbosity.PQERRORS_VERBOSE

pqescapeBytea:

• postgres_rdb: pqescapeBytea(bintext: cstring; binlen: int; bytealen: var int): cstring

pqescapeString:

• postgres_rdb: pqescapeString(till, from: cstring; len: int): int

pqexec:

• postgres_rdb: pqexec(conn: PPGconn; query: cstring): PPGresult

pqexecParams:

• postgres_rdb: pqexecParams(conn: PPGconn; command: cstring; nParams: int32; paramTypes: POid; paramValues: cstringArray; paramLengths, paramFormats: ptr int32; resultFormat: int32): PPGresult

pqexecPrepared:

• postgres_rdb: pqexecPrepared(conn: PPGconn; stmtName: cstring; nParams: int32; paramValues: cstringArray; paramLengths, paramFormats: ptr int32; resultFormat: int32): PPGresult

pqfformat:

• postgres_rdb: pqfformat(res: PPGresult; field_num: int32): int32

pqfinish:

• postgres_rdb: pqfinish(conn: PPGconn)

pqflush:

• postgres_rdb: pqflush(conn: PPGconn): int32

pqfmod:

• postgres_rdb: pqfmod(res: PPGresult; field_num: int32): int32

pqfn:

• postgres_rdb: pqfn(conn: PPGconn; fnid: int32; result_buf, result_len: ptr int32; result_is_int: int32; args: PPQArgBlock; nargs: int32): PPGresult

pqfname:

• postgres_rdb: pqfname(res: PPGresult; field_num: int32): cstring

pqfnumber:

• postgres_rdb: pqfnumber(res: PPGresult; field_name: cstring): int32

pqFreeCancel:

• postgres_rdb: pqFreeCancel(cancel: PPGcancel)

pqfreemem:

• postgres_rdb: pqfreemem(p: pointer)

pqfsize:

• postgres_rdb: pqfsize(res: PPGresult; field_num: int32): int32

pqftable:

• postgres_rdb: pqftable(res: PPGresult; field_num: int32): Oid

pqftablecol:

• postgres_rdb: pqftablecol(res: PPGresult; field_num: int32): int32

pqftype:

• postgres_rdb: pqftype(res: PPGresult; field_num: int32): Oid

pqGetCancel:

• postgres_rdb: pqGetCancel(conn: PPGconn): PPGcancel

pqgetCopyData:

• postgres_rdb: pqgetCopyData(conn: PPGconn; buffer: cstringArray; async: int32): int32

pqgetisnull:

• postgres_rdb: pqgetisnull(res: PPGresult; tup_num: int32; field_num: int32): int32

pqgetlength:

• postgres_rdb: pqgetlength(res: PPGresult; tup_num: int32; field_num: int32): int32

pqgetline:

• postgres_rdb: pqgetline(conn: PPGconn; str: cstring; len: int32): int32

pqgetlineAsync:

• postgres_rdb: pqgetlineAsync(conn: PPGconn; buffer: cstring; bufsize: int32): int32

pqgetResult:

• postgres_rdb: pqgetResult(conn: PPGconn): PPGresult

pqgetvalue:

• postgres_rdb: pqgetvalue(res: PPGresult; tup_num: int32; field_num: int32): cstring

pqhost:

• postgres_rdb: pqhost(conn: PPGconn): cstring

pqinitOpenSSL:

• postgres_rdb: pqinitOpenSSL(do_ssl: int32; do_crypto: int32)

pqisBusy:

• postgres_rdb: pqisBusy(conn: PPGconn): int32

pqisnonblocking:

• postgres_rdb: pqisnonblocking(conn: PPGconn): int32

pqmakeEmptyPGresult:

• postgres_rdb: pqmakeEmptyPGresult(conn: PPGconn; status: ExecStatusType): PPGresult

pqmblen:

• postgres_rdb: pqmblen(s: cstring; encoding: int32): int32

pqnfields:

• postgres_rdb: pqnfields(res: PPGresult): int32

PQnoticeProcessor:

• postgres_rdb: PQnoticeProcessor

PQnoticeReceiver:

• postgres_rdb: PQnoticeReceiver

pqnotifies:

• postgres_rdb: pqnotifies(conn: PPGconn): PPGNotify

pqntuples:

• postgres_rdb: pqntuples(res: PPGresult): int32

pqoidStatus:

• postgres_rdb: pqoidStatus(res: PPGresult): cstring

pqoidValue:

• postgres_rdb: pqoidValue(res: PPGresult): Oid

pqoptions:

• postgres_rdb: pqoptions(conn: PPGconn): cstring

pqparameterStatus:

• postgres_rdb: pqparameterStatus(conn: PPGconn; paramName: cstring): cstring

pqpass:

• postgres_rdb: pqpass(conn: PPGconn): cstring

pqport:

• postgres_rdb: pqport(conn: PPGconn): cstring

pqprepare:

• postgres_rdb: pqprepare(conn: PPGconn; stmtName, query: cstring; nParams: int32; paramTypes: POid): PPGresult

pqprint:

• postgres_rdb: pqprint(fout: File; res: PPGresult; ps: PPQprintOpt)

PQprintOpt:

• postgres_rdb: PQprintOpt

pqprintTuples:

• postgres_rdb: pqprintTuples(res: PPGresult; fout: File; printAttName: int32; terseOutput: int32; width: int32)

pqprotocolVersion:

• postgres_rdb: pqprotocolVersion(conn: PPGconn): int32

pqputCopyData:

• postgres_rdb: pqputCopyData(conn: PPGconn; buffer: cstring; nbytes: int32): int32

pqputCopyEnd:

• postgres_rdb: pqputCopyEnd(conn: PPGconn; errormsg: cstring): int32

pqputline:

• postgres_rdb: pqputline(conn: PPGconn; str: cstring): int32

pqputnbytes:

• postgres_rdb: pqputnbytes(conn: PPGconn; buffer: cstring; nbytes: int32): int32

pqrequestCancel:

• postgres_rdb: pqrequestCancel(conn: PPGconn): int32

pqreset:

• postgres_rdb: pqreset(conn: PPGconn)

pqresetPoll:

• postgres_rdb: pqresetPoll(conn: PPGconn): PostgresPollingStatusType

pqresetStart:

• postgres_rdb: pqresetStart(conn: PPGconn): int32

pqresStatus:

• postgres_rdb: pqresStatus(status: ExecStatusType): cstring

pqresultErrorField:

• postgres_rdb: pqresultErrorField(res: PPGresult; fieldcode: int32): cstring

pqresultErrorMessage:

• postgres_rdb: pqresultErrorMessage(res: PPGresult): cstring

pqresultStatus:

• postgres_rdb: pqresultStatus(res: PPGresult): ExecStatusType

pqsendPrepare:

• postgres_rdb: pqsendPrepare(conn: PPGconn; stmtName: cstring; query: cstring; nParams: int32; paramTypes: POid): int32

pqsendQuery:

• postgres_rdb: pqsendQuery(conn: PPGconn; query: cstring): int32

pqsendQueryParams:

• postgres_rdb: pqsendQueryParams(conn: PPGconn; command: cstring; nParams: int32; paramTypes: POid; paramValues: cstringArray; paramLengths, paramFormats: ptr int32; resultFormat: int32): int32

pqsendQueryPrepared:

• postgres_rdb: pqsendQueryPrepared(conn: PPGconn; stmtName: cstring; nParams: int32; paramValues: cstringArray; paramLengths, paramFormats: ptr int32; resultFormat: int32): int32

pqserverVersion:

• postgres_rdb: pqserverVersion(conn: PPGconn): int32

pqsetClientEncoding:

• postgres_rdb: pqsetClientEncoding(conn: PPGconn; encoding: cstring): int32

pqsetdb:

• postgres_rdb: pqsetdb(M_PGHOST, M_PGPORT, M_PGOPT, M_PGTTY, M_DBNAME: cstring): PPGconn

pqsetdbLogin:

• postgres_rdb: pqsetdbLogin(pghost: cstring; pgport: cstring; pgoptions: cstring; pgtty: cstring; dbName: cstring; login: cstring; pwd: cstring): PPGconn

pqsetErrorVerbosity:

• postgres_rdb: pqsetErrorVerbosity(conn: PPGconn; verbosity: PGVerbosity): PGVerbosity

pqsetnonblocking:

• postgres_rdb: pqsetnonblocking(conn: PPGconn; arg: int32): int32

pqsetNoticeProcessor:

• postgres_rdb: pqsetNoticeProcessor(conn: PPGconn; theProc: PQnoticeProcessor; arg: pointer): PQnoticeProcessor

pqsetNoticeReceiver:

• postgres_rdb: pqsetNoticeReceiver(conn: PPGconn; theProc: PQnoticeReceiver; arg: pointer): PQnoticeReceiver

pqSetSingleRowMode:

• postgres_rdb: pqSetSingleRowMode(conn: PPGconn): int32

pqsocket:

• postgres_rdb: pqsocket(conn: PPGconn): int32

pqstatus:

• postgres_rdb: pqstatus(conn: PPGconn): ConnStatusType

pqtrace:

• postgres_rdb: pqtrace(conn: PPGconn; debug_port: File)

pqtransactionStatus:

• postgres_rdb: pqtransactionStatus(conn: PPGconn): PGTransactionStatusType

PQTRANS_ACTIVE:

• PGTransactionStatusType.PQTRANS_ACTIVE

PQTRANS_IDLE:

• PGTransactionStatusType.PQTRANS_IDLE

PQTRANS_INERROR:

• PGTransactionStatusType.PQTRANS_INERROR

PQTRANS_INTRANS:

• PGTransactionStatusType.PQTRANS_INTRANS

PQTRANS_UNKNOWN:

• PGTransactionStatusType.PQTRANS_UNKNOWN

pqtty:

• postgres_rdb: pqtty(conn: PPGconn): cstring

pqunescapeBytea:

• postgres_rdb: pqunescapeBytea(strtext: cstring; retbuflen: var int): cstring

pquntrace:

• postgres_rdb: pquntrace(conn: PPGconn)

pquser:

• postgres_rdb: pquser(conn: PPGconn): cstring

Prand_struct:

• mariadb_rdb: Prand_struct
• mysql_rdb: Prand_struct

prepare:

• postgres_impl: prepare(db: PPGconn; query: string; timeout: int; stmtName: string): Future[int]
• sqlite_impl: prepare(db: PSqlite3; query: string; timeout: int): Future[PStmt]
• sqlite_rdb: prepare(db: PSqlite3; zSql: cstring; nBytes: int32; ppStmt: var PStmt; pzTail: ptr cstring): int32

prepare16:

• sqlite_rdb: prepare16(db: PSqlite3; zSql: pointer; nBytes: int32; ppStmt: var PStmt; pzTail: var pointer): int32

preparedExec:

• postgres_impl: preparedExec(db: PPGconn; args: seq[string]; nArgs: int; timeout: int; stmtName: string): owned(Future[void])
• sqlite_impl: preparedExec(db: PSqlite3; args: seq[string] = @[]; sqliteStmt: PStmt): owned( Future[void])

preparedQuery:

• postgres_impl: preparedQuery(db: PPGconn; args: seq[string]; nArgs: int; timeout: int; stmtName: string): Future[(seq[Row], DbRows)]
• sqlite_impl: preparedQuery(db: PSqlite3; args: seq[string] = @[]; sqliteStmt: PStmt): Future[ (seq[Row], DbRows)]

prepare_v2:

• sqlite_rdb: prepare_v2(db: PSqlite3; zSql: cstring; nByte: cint; ppStmt: var PStmt; pzTail: ptr cstring): cint

PRES:

• mariadb_rdb: PRES
• mysql_rdb: PRES

PRI_KEY_FLAG:

• mariadb_rdb: PRI_KEY_FLAG
• mysql_rdb: PRI_KEY_FLAG

progress_handler:

• sqlite_rdb: progress_handler(para1: PSqlite3; para2: int32; para3: proc (para1: pointer): int32 {.cdecl.}; para4: pointer)

PROTOCOL_DEFAULT:

• Protocol_type.PROTOCOL_DEFAULT
• Protocol_type.PROTOCOL_DEFAULT

PROTOCOL_MEMORY:

• Protocol_type.PROTOCOL_MEMORY
• Protocol_type.PROTOCOL_MEMORY

PROTOCOL_PIPE:

• Protocol_type.PROTOCOL_PIPE
• Protocol_type.PROTOCOL_PIPE

PROTOCOL_SOCKET:

• Protocol_type.PROTOCOL_SOCKET
• Protocol_type.PROTOCOL_SOCKET

PROTOCOL_TCP:

• Protocol_type.PROTOCOL_TCP
• Protocol_type.PROTOCOL_TCP

Protocol_type:

• mariadb_rdb: Protocol_type
• mysql_rdb: Protocol_type

PROW:

• mariadb_rdb: PROW
• mysql_rdb: PROW

PROW_OFFSET:

• mariadb_rdb: PROW_OFFSET
• mysql_rdb: PROW_OFFSET

PROWS:

• mariadb_rdb: PROWS
• mysql_rdb: PROWS

Psockaddr:

• mariadb_rdb: Psockaddr
• mysql_rdb: Psockaddr

PSqlite3:

• sqlite_rdb: PSqlite3

PSqlite3_Backup:

• sqlite_rdb: PSqlite3_Backup

Pst_dynamic_array:

• mariadb_rdb: Pst_dynamic_array
• mysql_rdb: Pst_dynamic_array

Pst_mem_root:

• mariadb_rdb: Pst_mem_root
• mysql_rdb: Pst_mem_root

PSTMT:

• mariadb_rdb: PSTMT
• mysql_rdb: PSTMT

PStmt:

• sqlite_rdb: PStmt

Pst_mysql:

• mariadb_rdb: Pst_mysql
• mysql_rdb: Pst_mysql

Pst_mysql_bind:

• mariadb_rdb: Pst_mysql_bind
• mysql_rdb: Pst_mysql_bind

Pst_mysql_data:

• mariadb_rdb: Pst_mysql_data
• mysql_rdb: Pst_mysql_data

Pst_mysql_field:

• mariadb_rdb: Pst_mysql_field
• mysql_rdb: Pst_mysql_field

Pst_mysql_manager:

• mariadb_rdb: Pst_mysql_manager
• mysql_rdb: Pst_mysql_manager

Pst_mysql_methods:

• mariadb_rdb: Pst_mysql_methods
• mysql_rdb: Pst_mysql_methods

Pst_mysql_options:

• mariadb_rdb: Pst_mysql_options
• mysql_rdb: Pst_mysql_options

Pst_mysql_parameters:

• mariadb_rdb: Pst_mysql_parameters
• mysql_rdb: Pst_mysql_parameters

Pst_mysql_res:

• mariadb_rdb: Pst_mysql_res
• mysql_rdb: Pst_mysql_res

Pst_mysql_rows:

• mariadb_rdb: Pst_mysql_rows
• mysql_rdb: Pst_mysql_rows

Pst_mysql_stmt:

• mariadb_rdb: Pst_mysql_stmt
• mysql_rdb: Pst_mysql_stmt

Pst_net:

• mariadb_rdb: Pst_net
• mysql_rdb: Pst_net

Pst_udf_args:

• mariadb_rdb: Pst_udf_args
• mysql_rdb: Pst_udf_args

Pst_udf_init:

• mariadb_rdb: Pst_udf_init
• mysql_rdb: Pst_udf_init

Pst_used_mem:

• mariadb_rdb: Pst_used_mem
• mysql_rdb: Pst_used_mem

PUDF_ARGS:

• mariadb_rdb: PUDF_ARGS
• mysql_rdb: PUDF_ARGS

PUDF_INIT:

• mariadb_rdb: PUDF_INIT
• mysql_rdb: PUDF_INIT

PUSED_MEM:

• mariadb_rdb: PUSED_MEM
• mysql_rdb: PUSED_MEM

PValue:

• sqlite_rdb: PValue

PValueArg:

• sqlite_rdb: PValueArg

PVIO:

• mariadb_rdb: PVIO
• mysql_rdb: PVIO

query:

• mariadb_impl: query(db: PMySQL; query: string; args: JsonNode; timeout: int): Future[ (seq[database_types.Row], DbRows)]
• mariadb_impl: query(db: PMySQL; query: string; args: seq[string]; timeout: int): Future[ (seq[database_types.Row], DbRows)]
• mariadb_rdb: query(MySQL: PMySQL; q: cstring): cint
• mysql_impl: query(db: PMySQL; query: string; args: JsonNode; timeout: int): Future[ (seq[database_types.Row], DbRows)]
• mysql_impl: query(db: PMySQL; query: string; args: seq[string]; timeout: int): Future[ (seq[database_types.Row], DbRows)]
• mysql_rdb: query(MySQL: PMySQL; q: cstring): cint
• postgres_impl: query(db: PPGconn; query: string; args: JsonNode; timeout: int): Future[ (seq[Row], DbRows)]
• sqlite_impl: query(db: PSqlite3; query: string; args: seq[string]; timeout: int): Future[ (seq[Row], DbRows)]
• surreal_impl: query(db: SurrealConn; query: string; args: JsonNode; timeout: int): Future[ JsonNode]
• surreal_impl: query(db: SurrealConn; query: string; args: seq[string]; timeout: int): Future[ JsonNode]

queryPlain:

• mariadb_impl: queryPlain(db: PMySQL; query: string; args: JsonNode; timeout: int): Future[ seq[database_types.Row]]
• mariadb_impl: queryPlain(db: PMySQL; query: string; args: seq[string]; timeout: int): Future[ seq[database_types.Row]]
• mysql_impl: queryPlain(db: PMySQL; query: string; args: JsonNode; timeout: int): Future[ seq[database_types.Row]]
• mysql_impl: queryPlain(db: PMySQL; query: string; args: seq[string]; timeout: int): Future[ seq[database_types.Row]]
• postgres_impl: queryPlain(db: PPGconn; query: string; args: seq[string]; timeout: int): Future[ seq[Row]]
• sqlite_impl: queryPlain(db: PSqlite3; query: string; args: seq[string]; timeout: int): Future[ seq[Row]]

questionToDaller:

• postgres_lib: questionToDaller(s: string): string
• surreal_lib: questionToDaller(s: string): string

quoteColumn:

• surreal_generator: quoteColumn(input: var string)

quoteTable:

• surreal_generator: quoteTable(input: var string)

randominit:

• mariadb_rdb: randominit(para1: Prand_struct; seed1: int; seed2: int)
• mysql_rdb: randominit(para1: Prand_struct; seed1: int; seed2: int)

Rand_struct:

• mariadb_rdb: Rand_struct
• mysql_rdb: Rand_struct

raw:

• mariadb_connections: raw(self: MariadbConnections; sql: string; arges = newJArray()): RawMariadbQuery
• mysql_connections: raw(self: MysqlConnections; sql: string; arges = newJArray()): RawMysqlQuery
• postgres_connections: raw(self: PostgresConnections; sql: string; arges = newJArray()): RawPostgresQuery
• sqlite_connections: raw(self: SqliteConnections; sql: string; arges = newJArray()): RawSqliteQuery
• surreal_connections: raw(self: SurrealConnections; sql: string; arges = newJArray()): RawSurrealQuery

rawExec:

• postgres_impl: rawExec(db: PPGconn; query: string; args: JsonNode; timeout: int): owned( Future[void])

rawId:

• surreal_types: rawId(self: SurrealId): string

RawMariadbQuery:

• mariadb_types: RawMariadbQuery

RawMysqlQuery:

• mysql_types: RawMysqlQuery

RawPostgresQuery:

• postgres_types: RawPostgresQuery

rawQuery:

• mariadb_impl: rawQuery(db: PMySQL; query: string; args: JsonNode; timeout: int): Future[ (seq[database_types.Row], DbRows)]
• mysql_impl: rawQuery(db: PMySQL; query: string; args: JsonNode; timeout: int): Future[ (seq[database_types.Row], DbRows)]
• postgres_impl: rawQuery(db: PPGconn; query: string; args: JsonNode; timeout: int): Future[ (seq[Row], DbRows)]

RawSqliteQuery:

• sqlite_types: RawSqliteQuery

RawSurrealQuery:

• surreal_types: RawSurrealQuery

rdbBigInteger:

• RdbTypeKind.rdbBigInteger

rdbBinary:

• RdbTypeKind.rdbBinary

rdbBoolean:

• RdbTypeKind.rdbBoolean

rdbChar:

• RdbTypeKind.rdbChar

rdbDate:

• RdbTypeKind.rdbDate

rdbDatetime:

• RdbTypeKind.rdbDatetime

rdbDecimal:

• RdbTypeKind.rdbDecimal

rdbDouble:

• RdbTypeKind.rdbDouble

rdbEnumField:

• RdbTypeKind.rdbEnumField

rdbFloat:

• RdbTypeKind.rdbFloat

rdbForeign:

• RdbTypeKind.rdbForeign

rdbIncrements:

• RdbTypeKind.rdbIncrements

rdbInteger:

• RdbTypeKind.rdbInteger

rdbJson:

• RdbTypeKind.rdbJson

rdbLongText:

• RdbTypeKind.rdbLongText

rdbMediumInteger:

• RdbTypeKind.rdbMediumInteger

rdbMediumText:

• RdbTypeKind.rdbMediumText

rdbSmallInteger:

• RdbTypeKind.rdbSmallInteger

rdbSoftDelete:

• RdbTypeKind.rdbSoftDelete

rdbStrForeign:

• RdbTypeKind.rdbStrForeign

rdbString:

• RdbTypeKind.rdbString

rdbText:

• RdbTypeKind.rdbText

rdbTime:

• RdbTypeKind.rdbTime

rdbTimestamp:

• RdbTypeKind.rdbTimestamp

rdbTimestamps:

• RdbTypeKind.rdbTimestamps

RdbTypeKind:

• enums: RdbTypeKind

rdbUuid:

• RdbTypeKind.rdbUuid

ReadDbEffect:

• database_types: ReadDbEffect

READ_DEFAULT_FILE:

• Option.READ_DEFAULT_FILE
• Option.READ_DEFAULT_FILE

READ_DEFAULT_GROUP:

• Option.READ_DEFAULT_GROUP
• Option.READ_DEFAULT_GROUP

read_query_result:

• mariadb_rdb: read_query_result(MySQL: PMySQL): my_bool
• mysql_rdb: read_query_result(MySQL: PMySQL): my_bool

reads_from_master_enabled:

• mariadb_rdb: reads_from_master_enabled(MySQL: PMySQL): my_bool
• mysql_rdb: reads_from_master_enabled(MySQL: PMySQL): my_bool

real_connect:

• mariadb_rdb: real_connect(MySQL: PMySQL; host: cstring; user: cstring; passwd: cstring; db: cstring; port: cuint; unix_socket: cstring; clientflag: int): PMySQL
• mysql_rdb: real_connect(MySQL: PMySQL; host: cstring; user: cstring; passwd: cstring; db: cstring; port: cuint; unix_socket: cstring; clientflag: int): PMySQL

real_connect_start:

• mariadb_rdb: real_connect_start(ret: ptr PMySQL; mysql: PMySQL; host: cstring; user: cstring; passwd: cstring; db: cstring; port: cuint; unix_socket: cstring; clientflag: culong): cint
• mysql_rdb: real_connect_start(ret: ptr PMySQL; mysql: PMySQL; host: cstring; user: cstring; passwd: cstring; db: cstring; port: cuint; unix_socket: cstring; clientflag: culong): cint

real_escape_string:

• mariadb_rdb: real_escape_string(MySQL: PMySQL; fto: cstring; from: cstring; len: int): int
• mysql_rdb: real_escape_string(MySQL: PMySQL; fto: cstring; from: cstring; len: int): int

real_query:

• mariadb_rdb: real_query(MySQL: PMySQL; q: cstring; len: int): cint
• mysql_rdb: real_query(MySQL: PMySQL; q: cstring; len: int): cint

real_query_nonblocking:

• mariadb_rdb: real_query_nonblocking(MySQL: PMySQL; q: cstring; length: int): NetAsyncStatus
• mysql_rdb: real_query_nonblocking(MySQL: PMySQL; q: cstring; length: int): NetAsyncStatus

REAL_RESULT:

• Item_result.REAL_RESULT
• Item_result.REAL_RESULT

reference:

• column: reference(self: Column; column: string): Column

refresh:

• mariadb_rdb: refresh(sql: PMySQL; refresh_options: cuint): cint
• mysql_rdb: refresh(sql: PMySQL; refresh_options: cuint): cint

REFRESH_DES_KEY_FILE:

• mariadb_rdb: REFRESH_DES_KEY_FILE
• mysql_rdb: REFRESH_DES_KEY_FILE

REFRESH_FAST:

• mariadb_rdb: REFRESH_FAST
• mysql_rdb: REFRESH_FAST

REFRESH_GRANT:

• mariadb_rdb: REFRESH_GRANT
• mysql_rdb: REFRESH_GRANT

REFRESH_HOSTS:

• mariadb_rdb: REFRESH_HOSTS
• mysql_rdb: REFRESH_HOSTS

REFRESH_LOG:

• mariadb_rdb: REFRESH_LOG
• mysql_rdb: REFRESH_LOG

REFRESH_MASTER:

• mariadb_rdb: REFRESH_MASTER
• mysql_rdb: REFRESH_MASTER

REFRESH_QUERY_CACHE:

• mariadb_rdb: REFRESH_QUERY_CACHE
• mysql_rdb: REFRESH_QUERY_CACHE

REFRESH_QUERY_CACHE_FREE:

• mariadb_rdb: REFRESH_QUERY_CACHE_FREE
• mysql_rdb: REFRESH_QUERY_CACHE_FREE

REFRESH_READ_LOCK:

• mariadb_rdb: REFRESH_READ_LOCK
• mysql_rdb: REFRESH_READ_LOCK

REFRESH_SLAVE:

• mariadb_rdb: REFRESH_SLAVE
• mysql_rdb: REFRESH_SLAVE

REFRESH_STATUS:

• mariadb_rdb: REFRESH_STATUS
• mysql_rdb: REFRESH_STATUS

REFRESH_TABLES:

• mariadb_rdb: REFRESH_TABLES
• mysql_rdb: REFRESH_TABLES

REFRESH_THREADS:

• mariadb_rdb: REFRESH_THREADS
• mysql_rdb: REFRESH_THREADS

REFRESH_USER_RESOURCES:

• mariadb_rdb: REFRESH_USER_RESOURCES
• mysql_rdb: REFRESH_USER_RESOURCES

reload:

• mariadb_rdb: reload(x: PMySQL): cint
• mysql_rdb: reload(x: PMySQL): cint

RenameColumn:

• ColumnMigrationType.RenameColumn

renameColumn:

• column: renameColumn(_: type Column; src, dest: string): Column
• rename_column: renameColumn(self: MariadbSchema; isReset: bool)
• rename_column: renameColumn(self: MysqlSchema; isReset: bool)
• rename_column: renameColumn(self: PostgresSchema; isReset: bool)
• rename_column: renameColumn(self: SqliteSchema; isReset: bool)
• rename_column: renameColumn(self: SurrealSchema; isReset: bool)

RenameTable:

• TableMigrationType.RenameTable

renameTable:

• rename_table: renameTable(self: MariadbSchema; isReset: bool)
• rename_table: renameTable(self: MysqlSchema; isReset: bool)
• rename_table: renameTable(self: PostgresSchema; isReset: bool)
• rename_table: renameTable(self: SqliteSchema; isReset: bool)
• rename_table: renameTable(self: SurrealSchema; isReset: bool)

renameTo:

• table: renameTo(self: Table; name: string): Table

REPORT_DATA_TRUNCATION:

• Option.REPORT_DATA_TRUNCATION
• Option.REPORT_DATA_TRUNCATION

RES:

• mariadb_rdb: RES
• mysql_rdb: RES

reset:

• sqlite_rdb: reset(PStmt: PStmt): int32

resetMigrationTable:

• reset_table: resetMigrationTable(self: MariadbSchema)
• reset_table: resetMigrationTable(self: MysqlSchema)
• reset_table: resetMigrationTable(self: PostgresSchema)
• reset_table: resetMigrationTable(self: SqliteSchema)
• reset_table: resetMigrationTable(self: SurrealSchema)

resetSequence:

• create_sequence_table: resetSequence(rdb: SurrealConnections; table: Table)

resetTable:

• reset_table: resetTable(self: MariadbSchema)
• reset_table: resetTable(self: MysqlSchema)
• reset_table: resetTable(self: PostgresSchema)
• reset_table: resetTable(self: SqliteSchema)
• reset_table: resetTable(self: SurrealSchema)

RESTRICT:

• ForeignOnDelete.RESTRICT

result_blob:

• sqlite_rdb: result_blob(para1: Pcontext; para2: pointer; para3: int32; para4: Result_func)

result_double:

• sqlite_rdb: result_double(para1: Pcontext; para2: float64)

result_error:

• sqlite_rdb: result_error(para1: Pcontext; para2: cstring; para3: int32)

result_error16:

• sqlite_rdb: result_error16(para1: Pcontext; para2: pointer; para3: int32)

Result_func:

• sqlite_rdb: Result_func

result_int:

• sqlite_rdb: result_int(para1: Pcontext; para2: int32)

result_int64:

• sqlite_rdb: result_int64(para1: Pcontext; para2: int64)

result_null:

• sqlite_rdb: result_null(para1: Pcontext)

result_text:

• sqlite_rdb: result_text(para1: Pcontext; para2: cstring; para3: int32; para4: Result_func)

result_text16:

• sqlite_rdb: result_text16(para1: Pcontext; para2: pointer; para3: int32; para4: Result_func)

result_text16be:

• sqlite_rdb: result_text16be(para1: Pcontext; para2: pointer; para3: int32; para4: Result_func)

result_text16le:

• sqlite_rdb: result_text16le(para1: Pcontext; para2: pointer; para3: int32; para4: Result_func)

result_value:

• sqlite_rdb: result_value(para1: Pcontext; para2: PValue)

rollback:

• mariadb_rdb: rollback(MySQL: PMySQL): my_bool
• mysql_rdb: rollback(MySQL: PMySQL): my_bool
• mariadb_query: rollback(self: MariadbConnections): owned(Future[void])
• mysql_query: rollback(self: MysqlConnections): owned(Future[void])
• postgres_query: rollback(self: PostgresConnections): owned(Future[void])
• sqlite_query: rollback(self: SqliteConnections): owned(Future[void])

ROW:

• mariadb_rdb: ROW
• mysql_rdb: ROW

Row:

• database_types: Row

ROW_OFFSET:

• mariadb_rdb: ROW_OFFSET
• mysql_rdb: ROW_OFFSET

ROW_RESULT:

• Item_result.ROW_RESULT
• Item_result.ROW_RESULT

ROWS:

• mariadb_rdb: ROWS
• mysql_rdb: ROWS

row_seek:

• mariadb_rdb: row_seek(result: PRES; offset: ROW_OFFSET): ROW_OFFSET
• mysql_rdb: row_seek(result: PRES; offset: ROW_OFFSET): ROW_OFFSET

row_tell:

• mariadb_rdb: row_tell(res: PRES): ROW_OFFSET
• mysql_rdb: row_tell(res: PRES): ROW_OFFSET

RPL_ADMIN:

• Rpl_type.RPL_ADMIN
• Rpl_type.RPL_ADMIN

RPL_MASTER:

• Rpl_type.RPL_MASTER
• Rpl_type.RPL_MASTER

rpl_parse_enabled:

• mariadb_rdb: rpl_parse_enabled(MySQL: PMySQL): cint
• mysql_rdb: rpl_parse_enabled(MySQL: PMySQL): cint

rpl_probe:

• mariadb_rdb: rpl_probe(MySQL: PMySQL): my_bool
• mysql_rdb: rpl_probe(MySQL: PMySQL): my_bool

rpl_query_type:

• mariadb_rdb: rpl_query_type(q: cstring; length: cint): Rpl_type
• mysql_rdb: rpl_query_type(q: cstring; length: cint): Rpl_type

RPL_SLAVE:

• Rpl_type.RPL_SLAVE
• Rpl_type.RPL_SLAVE

Rpl_type:

• mariadb_rdb: Rpl_type
• mysql_rdb: Rpl_type

scramble:

• mariadb_rdb: scramble(fto: cstring; message: cstring; password: cstring)
• mysql_rdb: scramble(fto: cstring; message: cstring; password: cstring)

scramble_323:

• mariadb_rdb: scramble_323(fto: cstring; message: cstring; password: cstring)
• mysql_rdb: scramble_323(fto: cstring; message: cstring; password: cstring)

SCRAMBLED_PASSWORD_CHAR_LENGTH:

• mariadb_rdb: SCRAMBLED_PASSWORD_CHAR_LENGTH
• mysql_rdb: SCRAMBLED_PASSWORD_CHAR_LENGTH

SCRAMBLED_PASSWORD_CHAR_LENGTH_323:

• mariadb_rdb: SCRAMBLED_PASSWORD_CHAR_LENGTH_323
• mysql_rdb: SCRAMBLED_PASSWORD_CHAR_LENGTH_323

SCRAMBLE_LENGTH:

• mariadb_rdb: SCRAMBLE_LENGTH
• mysql_rdb: SCRAMBLE_LENGTH

SCRAMBLE_LENGTH_323:

• mariadb_rdb: SCRAMBLE_LENGTH_323
• mysql_rdb: SCRAMBLE_LENGTH_323

SECURE_AUTH:

• Option.SECURE_AUTH
• Option.SECURE_AUTH

seeder:

• mariadb_query: seeder(rdb: MariadbConnections; tableName, column: string; body: untyped): untyped
• mariadb_query: seeder(rdb: MariadbConnections; tableName: string; body: untyped): untyped
• mysql_query: seeder(rdb: MysqlConnections; tableName, column: string; body: untyped): untyped
• mysql_query: seeder(rdb: MysqlConnections; tableName: string; body: untyped): untyped
• postgres_query: seeder(rdb: PostgresConnections; tableName, column: string; body: untyped): untyped
• postgres_query: seeder(rdb: PostgresConnections; tableName: string; body: untyped): untyped
• sqlite_query: seeder(rdb: SqliteConnections; tableName, column: string; body: untyped): untyped
• sqlite_query: seeder(rdb: SqliteConnections; tableName: string; body: untyped): untyped
• surreal_query: seeder(rdb: SurrealConnections; tableName, column: string; body: untyped): untyped
• surreal_query: seeder(rdb: SurrealConnections; tableName: string; body: untyped): untyped

select:

• mariadb_connections: select(self: MariadbConnections; columnsArg: varargs[string]): MariadbQuery
• mysql_connections: select(self: MysqlConnections; columnsArg: varargs[string]): MysqlQuery
• postgres_connections: select(self: PostgresConnections; columnsArg: varargs[string]): PostgresQuery
• sqlite_connections: select(self: SqliteConnections; columnsArg: varargs[string]): SqliteQuery
• surreal_connections: select(self: SurrealConnections; columnsArg: varargs[string]): SurrealQuery

selectAvgBuilder:

• surreal_builder: selectAvgBuilder(self: SurrealQuery; column: string): string

selectAvgSql:

• mariadb_generator: selectAvgSql(self: MariadbQuery; column: string): MariadbQuery
• mysql_generator: selectAvgSql(self: MysqlQuery; column: string): MysqlQuery
• postgres_generator: selectAvgSql(self: PostgresQuery; column: string): PostgresQuery
• sqlite_generator: selectAvgSql(self: SqliteQuery; column: string): SqliteQuery
• surreal_generator: selectAvgSql(self: SurrealQuery; column: string): SurrealQuery

selectBuilder:

• mariadb_builder: selectBuilder(self: MariadbQuery): string
• mysql_builder: selectBuilder(self: MysqlQuery): string
• postgres_builder: selectBuilder(self: PostgresQuery): string
• sqlite_builder: selectBuilder(self: SqliteQuery): string
• surreal_builder: selectBuilder(self: SurrealQuery): string

selectByIdSql:

• mariadb_generator: selectByIdSql(self: MariadbQuery; key: string): MariadbQuery
• mysql_generator: selectByIdSql(self: MysqlQuery; key: string): MysqlQuery
• postgres_generator: selectByIdSql(self: PostgresQuery; key: string): PostgresQuery
• sqlite_generator: selectByIdSql(self: SqliteQuery; key: string): SqliteQuery
• surreal_generator: selectByIdSql(self: SurrealQuery; id: SurrealId; key: string): SurrealQuery

selectCountSql:

• mariadb_generator: selectCountSql(self: MariadbQuery): MariadbQuery
• mysql_generator: selectCountSql(self: MysqlQuery): MysqlQuery
• postgres_generator: selectCountSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: selectCountSql(self: SqliteQuery): SqliteQuery
• surreal_generator: selectCountSql(self: SurrealQuery): SurrealQuery

select_db:

• mariadb_rdb: select_db(MySQL: PMySQL; db: cstring): cint
• mysql_rdb: select_db(MySQL: PMySQL; db: cstring): cint

selectFindBuilder:

• mariadb_builder: selectFindBuilder(self: MariadbQuery; key: string): string
• mysql_builder: selectFindBuilder(self: MysqlQuery; key: string): string
• postgres_builder: selectFindBuilder(self: PostgresQuery; key: string): string
• sqlite_builder: selectFindBuilder(self: SqliteQuery; key: string): string
• surreal_builder: selectFindBuilder(self: SurrealQuery; id: SurrealId; key: string): string

selectFirstBuilder:

• mariadb_builder: selectFirstBuilder(self: MariadbQuery): string
• mysql_builder: selectFirstBuilder(self: MysqlQuery): string
• postgres_builder: selectFirstBuilder(self: PostgresQuery): string
• sqlite_builder: selectFirstBuilder(self: SqliteQuery): string
• surreal_builder: selectFirstBuilder(self: SurrealQuery): string

selectFirstSql:

• mariadb_generator: selectFirstSql(self: MariadbQuery): MariadbQuery
• mysql_generator: selectFirstSql(self: MysqlQuery): MysqlQuery
• postgres_generator: selectFirstSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: selectFirstSql(self: SqliteQuery): SqliteQuery
• surreal_generator: selectFirstSql(self: SurrealQuery): SurrealQuery

selectMaxSql:

• mariadb_generator: selectMaxSql(self: MariadbQuery; column: string): MariadbQuery
• mysql_generator: selectMaxSql(self: MysqlQuery; column: string): MysqlQuery
• postgres_generator: selectMaxSql(self: PostgresQuery; column: string): PostgresQuery
• sqlite_generator: selectMaxSql(self: SqliteQuery; column: string): SqliteQuery

selectMinSql:

• mariadb_generator: selectMinSql(self: MariadbQuery; column: string): MariadbQuery
• mysql_generator: selectMinSql(self: MysqlQuery; column: string): MysqlQuery
• postgres_generator: selectMinSql(self: PostgresQuery; column: string): PostgresQuery
• sqlite_generator: selectMinSql(self: SqliteQuery; column: string): SqliteQuery

selectSql:

• mariadb_generator: selectSql(self: MariadbQuery): MariadbQuery
• mysql_generator: selectSql(self: MysqlQuery): MysqlQuery
• postgres_generator: selectSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: selectSql(self: SqliteQuery): SqliteQuery
• surreal_generator: selectSql(self: SurrealQuery): SurrealQuery

selectSumBuilder:

• surreal_builder: selectSumBuilder(self: SurrealQuery; column: string): string

selectSumSql:

• mariadb_generator: selectSumSql(self: MariadbQuery; column: string): MariadbQuery
• mysql_generator: selectSumSql(self: MysqlQuery; column: string): MysqlQuery
• postgres_generator: selectSumSql(self: PostgresQuery; column: string): PostgresQuery
• sqlite_generator: selectSumSql(self: SqliteQuery; column: string): SqliteQuery
• surreal_generator: selectSumSql(self: SurrealQuery; column: string): SurrealQuery

send_query:

• mariadb_rdb: send_query(MySQL: PMySQL; q: cstring; len: int): cint
• mysql_rdb: send_query(MySQL: PMySQL; q: cstring; len: int): cint

server_end:

• mariadb_rdb: server_end()
• mysql_rdb: server_end()

server_init:

• mariadb_rdb: server_init(argc: cint; argv: cstringArray; groups: cstringArray): cint
• mysql_rdb: server_init(argc: cint; argv: cstringArray; groups: cstringArray): cint

SERVER_MORE_RESULTS_EXISTS:

• mariadb_rdb: SERVER_MORE_RESULTS_EXISTS
• mysql_rdb: SERVER_MORE_RESULTS_EXISTS

SERVER_QUERY_NO_GOOD_INDEX_USED:

• mariadb_rdb: SERVER_QUERY_NO_GOOD_INDEX_USED
• mysql_rdb: SERVER_QUERY_NO_GOOD_INDEX_USED

SERVER_QUERY_NO_INDEX_USED:

• mariadb_rdb: SERVER_QUERY_NO_INDEX_USED
• mysql_rdb: SERVER_QUERY_NO_INDEX_USED

SERVER_STATUS_AUTOCOMMIT:

• mariadb_rdb: SERVER_STATUS_AUTOCOMMIT
• mysql_rdb: SERVER_STATUS_AUTOCOMMIT

SERVER_STATUS_CURSOR_EXISTS:

• mariadb_rdb: SERVER_STATUS_CURSOR_EXISTS
• mysql_rdb: SERVER_STATUS_CURSOR_EXISTS

SERVER_STATUS_DB_DROPPED:

• mariadb_rdb: SERVER_STATUS_DB_DROPPED
• mysql_rdb: SERVER_STATUS_DB_DROPPED

SERVER_STATUS_IN_TRANS:

• mariadb_rdb: SERVER_STATUS_IN_TRANS
• mysql_rdb: SERVER_STATUS_IN_TRANS

SERVER_STATUS_LAST_ROW_SENT:

• mariadb_rdb: SERVER_STATUS_LAST_ROW_SENT
• mysql_rdb: SERVER_STATUS_LAST_ROW_SENT

SERVER_STATUS_MORE_RESULTS:

• mariadb_rdb: SERVER_STATUS_MORE_RESULTS
• mysql_rdb: SERVER_STATUS_MORE_RESULTS

SERVER_STATUS_NO_BACKSLASH_ESCAPES:

• mariadb_rdb: SERVER_STATUS_NO_BACKSLASH_ESCAPES
• mysql_rdb: SERVER_STATUS_NO_BACKSLASH_ESCAPES

SERVER_VERSION_LENGTH:

• mariadb_rdb: SERVER_VERSION_LENGTH
• mysql_rdb: SERVER_VERSION_LENGTH

SERVICENAME:

• mariadb_rdb: SERVICENAME
• mysql_rdb: SERVICENAME

set_authorizer:

• sqlite_rdb: set_authorizer(para1: PSqlite3; xAuth: proc (para1: pointer; para2: int32; para3: cstring; para4: cstring; para5: cstring; para6: cstring): int32 {. cdecl.}; pUserData: pointer): int32

set_auxdata:

• sqlite_rdb: set_auxdata(para1: Pcontext; para2: int32; para3: pointer; para4: proc (para1: pointer) {.cdecl.})

set_character_set:

• mariadb_rdb: set_character_set(MySQL: PMySQL; csname: cstring): int32
• mysql_rdb: set_character_set(MySQL: PMySQL; csname: cstring): int32

SET_CHARSET_DIR:

• Option.SET_CHARSET_DIR
• Option.SET_CHARSET_DIR

SET_CHARSET_NAME:

• Option.SET_CHARSET_NAME
• Option.SET_CHARSET_NAME

SET_CLIENT_IP:

• Option.SET_CLIENT_IP
• Option.SET_CLIENT_IP

setColumnInfo:

• mariadb_lib: setColumnInfo(columns: var DbColumns; res: PRES; L: int)
• mysql_lib: setColumnInfo(columns: var DbColumns; res: PRES; L: int)
• postgres_lib: setColumnInfo(res: PPGresult; dbRows: var DbRows; line, cols: int32)

SET_FLAG:

• mariadb_rdb: SET_FLAG
• mysql_rdb: SET_FLAG

set_local_infile_default:

• mariadb_rdb: set_local_infile_default(MySQL: PMySQL)
• mysql_rdb: set_local_infile_default(MySQL: PMySQL)

set_master:

• mariadb_rdb: set_master(MySQL: PMySQL; host: cstring; port: cuint; user: cstring; passwd: cstring): cint
• mysql_rdb: set_master(MySQL: PMySQL; host: cstring; port: cuint; user: cstring; passwd: cstring): cint

SET_NULL:

• ForeignOnDelete.SET_NULL

setRow:

• postgres_lib: setRow(res: PPGresult; r: var Row; line, cols: int32)

set_server_option:

• mariadb_rdb: set_server_option(MySQL: PMySQL; option: Enum_mysql_set_option): cint
• mysql_rdb: set_server_option(MySQL: PMySQL; option: Enum_mysql_set_option): cint

SHARED_MEMORY_BASE_NAME:

• Option.SHARED_MEMORY_BASE_NAME
• Option.SHARED_MEMORY_BASE_NAME

shouldRun:

• schema_utils: shouldRun(rdb: MariadbConnections; table: Table; checksum: string; isReset: bool): bool
• schema_utils: shouldRun(rdb: MysqlConnections; table: Table; checksum: string; isReset: bool): bool
• schema_utils: shouldRun(rdb: PostgresConnections; table: Table; checksum: string; isReset: bool): bool
• schema_utils: shouldRun(rdb: SqliteConnections; table: Table; checksum: string; isReset: bool): bool
• schema_utils: shouldRun(rdb: SurrealConnections; table: Table; checksum: string; isReset: bool): bool

shutdown:

• mariadb_rdb: shutdown(MySQL: PMySQL; shutdown_level: Enum_shutdown_level): cint
• mysql_rdb: shutdown(MySQL: PMySQL; shutdown_level: Enum_shutdown_level): cint

SHUTDOWN_DEFAULT:

• Enum_shutdown_level.SHUTDOWN_DEFAULT
• Enum_shutdown_level.SHUTDOWN_DEFAULT

SHUTDOWN_KILLABLE_CONNECT:

• mariadb_rdb: SHUTDOWN_KILLABLE_CONNECT
• mysql_rdb: SHUTDOWN_KILLABLE_CONNECT

SHUTDOWN_KILLABLE_LOCK_TABLE:

• mariadb_rdb: SHUTDOWN_KILLABLE_LOCK_TABLE
• mysql_rdb: SHUTDOWN_KILLABLE_LOCK_TABLE

SHUTDOWN_KILLABLE_TRANS:

• mariadb_rdb: SHUTDOWN_KILLABLE_TRANS
• mysql_rdb: SHUTDOWN_KILLABLE_TRANS

SHUTDOWN_KILLABLE_UPDATE:

• mariadb_rdb: SHUTDOWN_KILLABLE_UPDATE
• mysql_rdb: SHUTDOWN_KILLABLE_UPDATE

SHUTDOWN_WAIT_ALL_BUFFERS:

• Enum_shutdown_level.SHUTDOWN_WAIT_ALL_BUFFERS
• Enum_shutdown_level.SHUTDOWN_WAIT_ALL_BUFFERS

SHUTDOWN_WAIT_CONNECTIONS:

• Enum_shutdown_level.SHUTDOWN_WAIT_CONNECTIONS
• Enum_shutdown_level.SHUTDOWN_WAIT_CONNECTIONS

SHUTDOWN_WAIT_CRITICAL_BUFFERS:

• Enum_shutdown_level.SHUTDOWN_WAIT_CRITICAL_BUFFERS
• Enum_shutdown_level.SHUTDOWN_WAIT_CRITICAL_BUFFERS

SHUTDOWN_WAIT_TRANSACTIONS:

• Enum_shutdown_level.SHUTDOWN_WAIT_TRANSACTIONS
• Enum_shutdown_level.SHUTDOWN_WAIT_TRANSACTIONS

SHUTDOWN_WAIT_UPDATES:

• Enum_shutdown_level.SHUTDOWN_WAIT_UPDATES
• Enum_shutdown_level.SHUTDOWN_WAIT_UPDATES

slave_query:

• mariadb_rdb: slave_query(MySQL: PMySQL; q: cstring; len: int): my_bool
• mysql_rdb: slave_query(MySQL: PMySQL; q: cstring; len: int): my_bool

slave_send_query:

• mariadb_rdb: slave_send_query(MySQL: PMySQL; q: cstring; len: int): my_bool
• mysql_rdb: slave_send_query(MySQL: PMySQL; q: cstring; len: int): my_bool

smallInteger:

• column: smallInteger(_: type Column; name: string): Column

smallName:

• table: smallName(self: Table): string

snprintf:

• sqlite_rdb: snprintf(para1: int32; para2: cstring; para3: cstring): cstring

Sockaddr:

• mariadb_rdb: Sockaddr
• mysql_rdb: Sockaddr

SockAddr:

• postgres_rdb: SockAddr

softDelete:

• column: softDelete(_: type Column): Column

SQLite3:

• sqlite_types: SQLite3

sqlite3_sleep:

• sqlite_rdb: sqlite3_sleep(t: int64): int64

SQLITE_ABORT:

• sqlite_rdb: SQLITE_ABORT

SQLITE_ALTER_TABLE:

• sqlite_rdb: SQLITE_ALTER_TABLE

SQLITE_ANY:

• sqlite_rdb: SQLITE_ANY

SQLITE_ATTACH:

• sqlite_rdb: SQLITE_ATTACH

SQLITE_AUTH:

• sqlite_rdb: SQLITE_AUTH

SQLITE_BLOB:

• sqlite_rdb: SQLITE_BLOB

SQLITE_BUSY:

• sqlite_rdb: SQLITE_BUSY

SQLITE_CANTOPEN:

• sqlite_rdb: SQLITE_CANTOPEN

SqliteConnection:

• sqlite_types: SqliteConnection

SqliteConnections:

• sqlite_types: SqliteConnections

SQLITE_CONSTRAINT:

• sqlite_rdb: SQLITE_CONSTRAINT

SQLITE_COPY:

• sqlite_rdb: SQLITE_COPY

SQLITE_CORRUPT:

• sqlite_rdb: SQLITE_CORRUPT

SQLITE_CREATE_INDEX:

• sqlite_rdb: SQLITE_CREATE_INDEX

SQLITE_CREATE_TABLE:

• sqlite_rdb: SQLITE_CREATE_TABLE

SQLITE_CREATE_TEMP_INDEX:

• sqlite_rdb: SQLITE_CREATE_TEMP_INDEX

SQLITE_CREATE_TEMP_TABLE:

• sqlite_rdb: SQLITE_CREATE_TEMP_TABLE

SQLITE_CREATE_TEMP_TRIGGER:

• sqlite_rdb: SQLITE_CREATE_TEMP_TRIGGER

SQLITE_CREATE_TEMP_VIEW:

• sqlite_rdb: SQLITE_CREATE_TEMP_VIEW

SQLITE_CREATE_TRIGGER:

• sqlite_rdb: SQLITE_CREATE_TRIGGER

SQLITE_CREATE_VIEW:

• sqlite_rdb: SQLITE_CREATE_VIEW

SQLITE_DELETE:

• sqlite_rdb: SQLITE_DELETE

SQLITE_DENY:

• sqlite_rdb: SQLITE_DENY

SQLITE_DETACH:

• sqlite_rdb: SQLITE_DETACH

SQLITE_DETERMINISTIC:

• sqlite_rdb: SQLITE_DETERMINISTIC

SQLITE_DONE:

• sqlite_rdb: SQLITE_DONE

SQLITE_DROP_INDEX:

• sqlite_rdb: SQLITE_DROP_INDEX

SQLITE_DROP_TABLE:

• sqlite_rdb: SQLITE_DROP_TABLE

SQLITE_DROP_TEMP_INDEX:

• sqlite_rdb: SQLITE_DROP_TEMP_INDEX

SQLITE_DROP_TEMP_TABLE:

• sqlite_rdb: SQLITE_DROP_TEMP_TABLE

SQLITE_DROP_TEMP_TRIGGER:

• sqlite_rdb: SQLITE_DROP_TEMP_TRIGGER

SQLITE_DROP_TEMP_VIEW:

• sqlite_rdb: SQLITE_DROP_TEMP_VIEW

SQLITE_DROP_TRIGGER:

• sqlite_rdb: SQLITE_DROP_TRIGGER

SQLITE_DROP_VIEW:

• sqlite_rdb: SQLITE_DROP_VIEW

SQLITE_EMPTY:

• sqlite_rdb: SQLITE_EMPTY

SQLITE_ERROR:

• sqlite_rdb: SQLITE_ERROR

SQLITE_FLOAT:

• sqlite_rdb: SQLITE_FLOAT

SQLITE_FORMAT:

• sqlite_rdb: SQLITE_FORMAT

SQLITE_FULL:

• sqlite_rdb: SQLITE_FULL

SQLITE_IGNORE:

• sqlite_rdb: SQLITE_IGNORE

SQLITE_INSERT:

• sqlite_rdb: SQLITE_INSERT

SQLITE_INTEGER:

• sqlite_rdb: SQLITE_INTEGER

SQLITE_INTERNAL:

• sqlite_rdb: SQLITE_INTERNAL

SQLITE_INTERRUPT:

• sqlite_rdb: SQLITE_INTERRUPT

SQLITE_IOERR:

• sqlite_rdb: SQLITE_IOERR

SQLITE_LOCKED:

• sqlite_rdb: SQLITE_LOCKED

SQLITE_MISMATCH:

• sqlite_rdb: SQLITE_MISMATCH

SQLITE_MISUSE:

• sqlite_rdb: SQLITE_MISUSE

SQLITE_NOLFS:

• sqlite_rdb: SQLITE_NOLFS

SQLITE_NOMEM:

• sqlite_rdb: SQLITE_NOMEM

SQLITE_NOTADB:

• sqlite_rdb: SQLITE_NOTADB

SQLITE_NOTFOUND:

• sqlite_rdb: SQLITE_NOTFOUND

SQLITE_NULL:

• sqlite_rdb: SQLITE_NULL

SQLITE_OK:

• sqlite_rdb: SQLITE_OK

SQLITE_PERM:

• sqlite_rdb: SQLITE_PERM

SQLITE_PRAGMA:

• sqlite_rdb: SQLITE_PRAGMA

SQLITE_PROTOCOL:

• sqlite_rdb: SQLITE_PROTOCOL

SqliteQuery:

• sqlite_types: SqliteQuery

SQLITE_RANGE:

• sqlite_rdb: SQLITE_RANGE

SQLITE_READ:

• sqlite_rdb: SQLITE_READ

SQLITE_READONLY:

• sqlite_rdb: SQLITE_READONLY

SQLITE_REINDEX:

• sqlite_rdb: SQLITE_REINDEX

SQLITE_ROW:

• sqlite_rdb: SQLITE_ROW

SQLITE_SCHEMA:

• sqlite_rdb: SQLITE_SCHEMA

SqliteSchema:

• sqlite_query_type: SqliteSchema

SQLITE_SELECT:

• sqlite_rdb: SQLITE_SELECT

SQLITE_STATIC:

• sqlite_rdb: SQLITE_STATIC

SQLITE_TEXT:

• sqlite_rdb: SQLITE_TEXT

SQLITE_TOOBIG:

• sqlite_rdb: SQLITE_TOOBIG

SQLITE_TRANSACTION:

• sqlite_rdb: SQLITE_TRANSACTION

SQLITE_TRANSIENT:

• sqlite_rdb: SQLITE_TRANSIENT

SQLITE_UPDATE:

• sqlite_rdb: SQLITE_UPDATE

SQLITE_UTF16:

• sqlite_rdb: SQLITE_UTF16

SQLITE_UTF16BE:

• sqlite_rdb: SQLITE_UTF16BE

SQLITE_UTF16LE:

• sqlite_rdb: SQLITE_UTF16LE

SQLITE_UTF8:

• sqlite_rdb: SQLITE_UTF8

sqlstate:

• mariadb_rdb: sqlstate(MySQL: PMySQL): cstring
• mysql_rdb: sqlstate(MySQL: PMySQL): cstring

SQLSTATE_LENGTH:

• mariadb_rdb: SQLSTATE_LENGTH
• mysql_rdb: SQLSTATE_LENGTH

ssl_set:

• mariadb_rdb: ssl_set(MySQL: PMySQL; key: cstring; cert: cstring; ca: cstring; capath: cstring; cipher: cstring): my_bool
• mysql_rdb: ssl_set(MySQL: PMySQL; key: cstring; cert: cstring; ca: cstring; capath: cstring; cipher: cstring): my_bool

start:

• surreal_query: start(self: SurrealQuery; num: int): SurrealQuery

startSql:

• surreal_generator: startSql(self: SurrealQuery): SurrealQuery

stat:

• mariadb_rdb: stat(MySQL: PMySQL): cstring
• mysql_rdb: stat(MySQL: PMySQL): cstring

Status:

• mariadb_rdb: Status
• mysql_rdb: Status

STATUS_GET_RESULT:

• Status.STATUS_GET_RESULT
• Status.STATUS_GET_RESULT

STATUS_READY:

• Status.STATUS_READY
• Status.STATUS_READY

STATUS_USE_RESULT:

• Status.STATUS_USE_RESULT
• Status.STATUS_USE_RESULT

St_dynamic_array:

• mariadb_rdb: St_dynamic_array
• mysql_rdb: St_dynamic_array

step:

• sqlite_rdb: step(para1: PStmt): int32

St_mem_root:

• mariadb_rdb: St_mem_root
• mysql_rdb: St_mem_root

STMT:

• mariadb_rdb: STMT
• mysql_rdb: STMT

stmt_affected_rows:

• mariadb_rdb: stmt_affected_rows(stmt: PSTMT): my_ulonglong
• mysql_rdb: stmt_affected_rows(stmt: PSTMT): my_ulonglong

STMT_ATTR_CURSOR_TYPE:

• Enum_stmt_attr_type.STMT_ATTR_CURSOR_TYPE
• Enum_stmt_attr_type.STMT_ATTR_CURSOR_TYPE

stmt_attr_get:

• mariadb_rdb: stmt_attr_get(stmt: PSTMT; attr_type: Enum_stmt_attr_type; attr: pointer): my_bool
• mysql_rdb: stmt_attr_get(stmt: PSTMT; attr_type: Enum_stmt_attr_type; attr: pointer): my_bool

STMT_ATTR_PREFETCH_ROWS:

• Enum_stmt_attr_type.STMT_ATTR_PREFETCH_ROWS
• Enum_stmt_attr_type.STMT_ATTR_PREFETCH_ROWS

stmt_attr_set:

• mariadb_rdb: stmt_attr_set(stmt: PSTMT; attr_type: Enum_stmt_attr_type; attr: pointer): my_bool
• mysql_rdb: stmt_attr_set(stmt: PSTMT; attr_type: Enum_stmt_attr_type; attr: pointer): my_bool

STMT_ATTR_UPDATE_MAX_LENGTH:

• Enum_stmt_attr_type.STMT_ATTR_UPDATE_MAX_LENGTH
• Enum_stmt_attr_type.STMT_ATTR_UPDATE_MAX_LENGTH

stmt_bind_param:

• mariadb_rdb: stmt_bind_param(stmt: PSTMT; bnd: PBIND): my_bool
• mysql_rdb: stmt_bind_param(stmt: PSTMT; bnd: PBIND): my_bool

stmt_bind_result:

• mariadb_rdb: stmt_bind_result(stmt: PSTMT; bnd: PBIND): my_bool
• mysql_rdb: stmt_bind_result(stmt: PSTMT; bnd: PBIND): my_bool

stmt_close:

• mariadb_rdb: stmt_close(stmt: PSTMT): my_bool
• mysql_rdb: stmt_close(stmt: PSTMT): my_bool

stmt_data_seek:

• mariadb_rdb: stmt_data_seek(stmt: PSTMT; offset: my_ulonglong)
• mysql_rdb: stmt_data_seek(stmt: PSTMT; offset: my_ulonglong)

stmt_errno:

• mariadb_rdb: stmt_errno(stmt: PSTMT): cuint
• mysql_rdb: stmt_errno(stmt: PSTMT): cuint

stmt_error:

• mariadb_rdb: stmt_error(stmt: PSTMT): cstring
• mysql_rdb: stmt_error(stmt: PSTMT): cstring

stmt_execute:

• mariadb_rdb: stmt_execute(stmt: PSTMT): cint
• mysql_rdb: stmt_execute(stmt: PSTMT): cint

STMT_EXECUTE_DONE:

• Enum_mysql_stmt_state.STMT_EXECUTE_DONE
• Enum_mysql_stmt_state.STMT_EXECUTE_DONE

stmt_fetch:

• mariadb_rdb: stmt_fetch(stmt: PSTMT): cint
• mysql_rdb: stmt_fetch(stmt: PSTMT): cint

stmt_fetch_column:

• mariadb_rdb: stmt_fetch_column(stmt: PSTMT; bind: PBIND; column: cuint; offset: int): cint
• mysql_rdb: stmt_fetch_column(stmt: PSTMT; bind: PBIND; column: cuint; offset: int): cint

STMT_FETCH_DONE:

• Enum_mysql_stmt_state.STMT_FETCH_DONE
• Enum_mysql_stmt_state.STMT_FETCH_DONE

stmt_field_count:

• mariadb_rdb: stmt_field_count(stmt: PSTMT): cuint
• mysql_rdb: stmt_field_count(stmt: PSTMT): cuint

stmt_free_result:

• mariadb_rdb: stmt_free_result(stmt: PSTMT): my_bool
• mysql_rdb: stmt_free_result(stmt: PSTMT): my_bool

STMT_HEADER:

• mariadb_rdb: STMT_HEADER
• mysql_rdb: STMT_HEADER

stmt_init:

• mariadb_rdb: stmt_init(MySQL: PMySQL): PSTMT
• mysql_rdb: stmt_init(MySQL: PMySQL): PSTMT

STMT_INIT_DONE:

• Enum_mysql_stmt_state.STMT_INIT_DONE
• Enum_mysql_stmt_state.STMT_INIT_DONE

stmt_insert_id:

• mariadb_rdb: stmt_insert_id(stmt: PSTMT): my_ulonglong
• mysql_rdb: stmt_insert_id(stmt: PSTMT): my_ulonglong

stmt_num_rows:

• mariadb_rdb: stmt_num_rows(stmt: PSTMT): my_ulonglong
• mysql_rdb: stmt_num_rows(stmt: PSTMT): my_ulonglong

stmt_param_count:

• mariadb_rdb: stmt_param_count(stmt: PSTMT): int
• mysql_rdb: stmt_param_count(stmt: PSTMT): int

stmt_param_metadata:

• mariadb_rdb: stmt_param_metadata(stmt: PSTMT): PRES
• mysql_rdb: stmt_param_metadata(stmt: PSTMT): PRES

stmt_prepare:

• mariadb_rdb: stmt_prepare(stmt: PSTMT; query: cstring; len: int): cint
• mysql_rdb: stmt_prepare(stmt: PSTMT; query: cstring; len: int): cint

STMT_PREPARE_DONE:

• Enum_mysql_stmt_state.STMT_PREPARE_DONE
• Enum_mysql_stmt_state.STMT_PREPARE_DONE

stmt_reset:

• mariadb_rdb: stmt_reset(stmt: PSTMT): my_bool
• mysql_rdb: stmt_reset(stmt: PSTMT): my_bool

stmt_result_metadata:

• mariadb_rdb: stmt_result_metadata(stmt: PSTMT): PRES
• mysql_rdb: stmt_result_metadata(stmt: PSTMT): PRES

stmt_row_seek:

• mariadb_rdb: stmt_row_seek(stmt: PSTMT; offset: ROW_OFFSET): ROW_OFFSET
• mysql_rdb: stmt_row_seek(stmt: PSTMT; offset: ROW_OFFSET): ROW_OFFSET

stmt_row_tell:

• mariadb_rdb: stmt_row_tell(stmt: PSTMT): ROW_OFFSET
• mysql_rdb: stmt_row_tell(stmt: PSTMT): ROW_OFFSET

stmt_send_long_data:

• mariadb_rdb: stmt_send_long_data(stmt: PSTMT; param_number: cuint; data: cstring; len: int): my_bool
• mysql_rdb: stmt_send_long_data(stmt: PSTMT; param_number: cuint; data: cstring; len: int): my_bool

stmt_sqlstate:

• mariadb_rdb: stmt_sqlstate(stmt: PSTMT): cstring
• mysql_rdb: stmt_sqlstate(stmt: PSTMT): cstring

stmt_store_result:

• mariadb_rdb: stmt_store_result(stmt: PSTMT): cint
• mysql_rdb: stmt_store_result(stmt: PSTMT): cint

St_mysql:

• mariadb_rdb: St_mysql
• mysql_rdb: St_mysql

St_mysql_bind:

• mariadb_rdb: St_mysql_bind
• mysql_rdb: St_mysql_bind

St_mysql_data:

• mariadb_rdb: St_mysql_data
• mysql_rdb: St_mysql_data

St_mysql_field:

• mariadb_rdb: St_mysql_field
• mysql_rdb: St_mysql_field

St_mysql_manager:

• mariadb_rdb: St_mysql_manager
• mysql_rdb: St_mysql_manager

St_mysql_methods:

• mariadb_rdb: St_mysql_methods
• mysql_rdb: St_mysql_methods

St_mysql_options:

• mariadb_rdb: St_mysql_options
• mysql_rdb: St_mysql_options

St_mysql_parameters:

• mariadb_rdb: St_mysql_parameters
• mysql_rdb: St_mysql_parameters

St_mysql_res:

• mariadb_rdb: St_mysql_res
• mysql_rdb: St_mysql_res

St_mysql_rows:

• mariadb_rdb: St_mysql_rows
• mysql_rdb: St_mysql_rows

St_mysql_stmt:

• mariadb_rdb: St_mysql_stmt
• mysql_rdb: St_mysql_stmt

St_net:

• mariadb_rdb: St_net
• mysql_rdb: St_net

store_result:

• mariadb_rdb: store_result(MySQL: PMySQL): PRES
• mysql_rdb: store_result(MySQL: PMySQL): PRES

store_result_nonblocking:

• mariadb_rdb: store_result_nonblocking(MySQL: PMySQL; MYSQL_RES: ptr PRES): NetAsyncStatus
• mysql_rdb: store_result_nonblocking(MySQL: PMySQL; MYSQL_RES: ptr PRES): NetAsyncStatus

strForeign:

• column: strForeign(_: type Column; name: string; length = 255): Column

string:

• column: string(_: type Column; name: string; length = 255): Column

STRING_RESULT:

• Item_result.STRING_RESULT
• Item_result.STRING_RESULT

St_udf_args:

• mariadb_rdb: St_udf_args
• mysql_rdb: St_udf_args

St_udf_init:

• mariadb_rdb: St_udf_init
• mysql_rdb: St_udf_init

St_used_mem:

• mariadb_rdb: St_used_mem
• mysql_rdb: St_used_mem

sum:

• mariadb_query: sum(self: MariadbQuery; column: string): Future[Option[float]]
• mysql_query: sum(self: MysqlQuery; column: string): Future[Option[float]]
• postgres_query: sum(self: PostgresQuery; column: string): Future[Option[float]]
• sqlite_query: sum(self: SqliteQuery; column: string): Future[Option[float]]
• surreal_query: sum(self: SurrealQuery; column: string): Future[float]

sumBuilder:

• mariadb_builder: sumBuilder(self: MariadbQuery; column: string): string
• mysql_builder: sumBuilder(self: MysqlQuery; column: string): string
• postgres_builder: sumBuilder(self: PostgresQuery; column: string): string
• sqlite_builder: sumBuilder(self: SqliteQuery; column: string): string

SurrealConn:

• surreal_rdb: SurrealConn

SurrealConnection:

• surreal_types: SurrealConnection

SurrealConnections:

• surreal_types: SurrealConnections

SurrealDB:

• surreal_types: SurrealDB

SurrealId:

• surreal_types: SurrealId

SurrealImpl:

• surreal_impl: SurrealImpl

SurrealQuery:

• surreal_types: SurrealQuery

SurrealSchema:

• surreal_query_type: SurrealSchema

table:

• mariadb_connections: table(self: MariadbConnections; tableArg: string): MariadbQuery
• mariadb_query: table(self: MariadbQuery; tableArg: string): MariadbQuery
• mysql_connections: table(self: MysqlConnections; tableArg: string): MysqlQuery
• mysql_query: table(self: MysqlQuery; tableArg: string): MysqlQuery
• postgres_connections: table(self: PostgresConnections; tableArg: string): PostgresQuery
• postgres_query: table(self: PostgresQuery; tableArg: string): PostgresQuery
• sqlite_connections: table(self: SqliteConnections; tableArg: string): SqliteQuery
• sqlite_query: table(self: SqliteQuery; tableArg: string): SqliteQuery
• surreal_connections: table(self: SurrealConnections; tableArg: string): SurrealQuery
• surreal_query: table(self: SurrealQuery; tableArg: string): SurrealQuery

Table:

• table: Table

table:

• table: table(name: string; columns: seq[Column]; primary: seq[string] = @[]): Table
• table: table(name: string; columns: varargs[Column]): Table

TableMigrationType:

• enums: TableMigrationType

Tbind_destructor_func:

• sqlite_rdb: Tbind_destructor_func

text:

• column: text(_: type Column; name: string): Column

thread_end:

• mariadb_rdb: thread_end()
• mysql_rdb: thread_end()

thread_id:

• mariadb_rdb: thread_id(MySQL: PMySQL): int
• mysql_rdb: thread_id(MySQL: PMySQL): int

thread_init:

• mariadb_rdb: thread_init(): my_bool
• mysql_rdb: thread_init(): my_bool

thread_safe:

• mariadb_rdb: thread_safe(): cuint
• mysql_rdb: thread_safe(): cuint

time:

• column: time(_: type Column; name: string): Column

timestamp:

• column: timestamp(_: type Column; name: string): Column

TIMESTAMP_FLAG:

• mariadb_rdb: TIMESTAMP_FLAG
• mysql_rdb: TIMESTAMP_FLAG

timestamps:

• column: timestamps(_: type Column): Column

toInterface:

• mariadb_query_impl: toInterface(self: MariadbSchema): ISchema
• mysql_query_impl: toInterface(self: MysqlSchema): ISchema
• postgres_query_impl: toInterface(self: PostgresSchema): ISchema
• sqlite_query_impl: toInterface(self: SqliteSchema): ISchema
• surreal_query_impl: toInterface(self: SurrealSchema): ISchema

toSchema:

• column: toSchema(self: Column): JsonNode
• table: toSchema(self: Table): JsonNode

total_changes:

• sqlite_rdb: total_changes(para1: PSqlite3): int32

trace:

• sqlite_rdb: trace(para1: PSqlite3; xTrace: proc (para1: pointer; para2: cstring) {.cdecl.}; para3: pointer): pointer

transaction:

• mariadb_transaction: transaction(rdb: MariadbConnections; callback: untyped)
• mysql_transaction: transaction(rdb: MysqlConnections; callback: untyped)
• poatgres_transaction: transaction(rdb: PostgresConnections; callback: untyped)
• sqlite_transaction: transaction(rdb: SqliteConnections; callback: untyped)

true:

• my_bool.true
• my_bool.true

TYPE_BIT:

• Enum_field_types.TYPE_BIT
• Enum_field_types.TYPE_BIT

TYPE_BLOB:

• Enum_field_types.TYPE_BLOB
• Enum_field_types.TYPE_BLOB

TYPE_DATE:

• Enum_field_types.TYPE_DATE
• Enum_field_types.TYPE_DATE

TYPE_DATETIME:

• Enum_field_types.TYPE_DATETIME
• Enum_field_types.TYPE_DATETIME

TYPE_DECIMAL:

• Enum_field_types.TYPE_DECIMAL
• Enum_field_types.TYPE_DECIMAL

TYPE_DOUBLE:

• Enum_field_types.TYPE_DOUBLE
• Enum_field_types.TYPE_DOUBLE

TYPE_ENUM:

• Enum_field_types.TYPE_ENUM
• Enum_field_types.TYPE_ENUM

TYPE_FLOAT:

• Enum_field_types.TYPE_FLOAT
• Enum_field_types.TYPE_FLOAT

TYPE_GEOMETRY:

• Enum_field_types.TYPE_GEOMETRY
• Enum_field_types.TYPE_GEOMETRY

TYPE_INT24:

• Enum_field_types.TYPE_INT24
• Enum_field_types.TYPE_INT24

TYPE_LONG:

• Enum_field_types.TYPE_LONG
• Enum_field_types.TYPE_LONG

TYPE_LONG_BLOB:

• Enum_field_types.TYPE_LONG_BLOB
• Enum_field_types.TYPE_LONG_BLOB

TYPE_LONGLONG:

• Enum_field_types.TYPE_LONGLONG
• Enum_field_types.TYPE_LONGLONG

TYPE_MEDIUM_BLOB:

• Enum_field_types.TYPE_MEDIUM_BLOB
• Enum_field_types.TYPE_MEDIUM_BLOB

TYPE_NEWDATE:

• Enum_field_types.TYPE_NEWDATE
• Enum_field_types.TYPE_NEWDATE

TYPE_NEWDECIMAL:

• Enum_field_types.TYPE_NEWDECIMAL
• Enum_field_types.TYPE_NEWDECIMAL

TYPE_NULL:

• Enum_field_types.TYPE_NULL
• Enum_field_types.TYPE_NULL

TYPE_SET:

• Enum_field_types.TYPE_SET
• Enum_field_types.TYPE_SET

TYPE_SHORT:

• Enum_field_types.TYPE_SHORT
• Enum_field_types.TYPE_SHORT

TYPE_STRING:

• Enum_field_types.TYPE_STRING
• Enum_field_types.TYPE_STRING

TYPE_TIME:

• Enum_field_types.TYPE_TIME
• Enum_field_types.TYPE_TIME

TYPE_TIMESTAMP:

• Enum_field_types.TYPE_TIMESTAMP
• Enum_field_types.TYPE_TIMESTAMP

TYPE_TINY:

• Enum_field_types.TYPE_TINY
• Enum_field_types.TYPE_TINY

TYPE_TINY_BLOB:

• Enum_field_types.TYPE_TINY_BLOB
• Enum_field_types.TYPE_TINY_BLOB

TYPE_VARCHAR:

• Enum_field_types.TYPE_VARCHAR
• Enum_field_types.TYPE_VARCHAR

TYPE_VAR_STRING:

• Enum_field_types.TYPE_VAR_STRING
• Enum_field_types.TYPE_VAR_STRING

TYPE_YEAR:

• Enum_field_types.TYPE_YEAR
• Enum_field_types.TYPE_YEAR

U:

• mariadb_rdb: U
• mysql_rdb: U

UDF_ARGS:

• mariadb_rdb: UDF_ARGS
• mysql_rdb: UDF_ARGS

UDF_INIT:

• mariadb_rdb: UDF_INIT
• mysql_rdb: UDF_INIT

unique:

• column: unique(c: Column): Column

UNIQUE_FLAG:

• mariadb_rdb: UNIQUE_FLAG
• mysql_rdb: UNIQUE_FLAG

UNIQUE_KEY_FLAG:

• mariadb_rdb: UNIQUE_KEY_FLAG
• mysql_rdb: UNIQUE_KEY_FLAG

unsigned:

• column: unsigned(c: Column): Column

UNSIGNED_FLAG:

• mariadb_rdb: UNSIGNED_FLAG
• mysql_rdb: UNSIGNED_FLAG

update:

• mariadb_query: update(self: MariadbQuery; items: JsonNode): owned(Future[void])
• mysql_query: update(self: MysqlQuery; items: JsonNode): owned(Future[void])
• postgres_query: update(self: PostgresQuery; items: JsonNode): owned(Future[void])
• sqlite_query: update(self: SqliteQuery; items: JsonNode): owned(Future[void])
• surreal_query: update(self: SurrealConnections; id: SurrealId; items: JsonNode): owned( Future[void])
• surreal_query: update(self: SurrealQuery; items: JsonNode): owned(Future[void])

updateBuilder:

• mariadb_builder: updateBuilder(self: MariadbQuery; items: JsonNode): string
• mysql_builder: updateBuilder(self: MysqlQuery; items: JsonNode): string
• postgres_builder: updateBuilder(self: PostgresQuery; items: JsonNode): string
• sqlite_builder: updateBuilder(self: SqliteQuery; items: JsonNode): string
• surreal_builder: updateBuilder(self: SurrealQuery; items: JsonNode): string

updateMergeBuilder:

• surreal_builder: updateMergeBuilder(self: SurrealQuery; id: string; items: JsonNode): string

updateMergeSql:

• surreal_generator: updateMergeSql(self: SurrealQuery; id: string; items: JsonNode): SurrealQuery

updateSql:

• mariadb_generator: updateSql(self: MariadbQuery): MariadbQuery
• mysql_generator: updateSql(self: MysqlQuery): MysqlQuery
• postgres_generator: updateSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: updateSql(self: SqliteQuery): SqliteQuery
• surreal_generator: updateSql(self: SurrealQuery): SurrealQuery

updateValuesSql:

• mariadb_generator: updateValuesSql(self: MariadbQuery; items: JsonNode): MariadbQuery
• mysql_generator: updateValuesSql(self: MysqlQuery; items: JsonNode): MysqlQuery
• postgres_generator: updateValuesSql(self: PostgresQuery; items: JsonNode): PostgresQuery
• sqlite_generator: updateValuesSql(self: SqliteQuery; items: JsonNode): SqliteQuery
• surreal_generator: updateValuesSql(self: SurrealQuery; items: JsonNode): SurrealQuery

UsecaseType:

• enums: UsecaseType

USED_MEM:

• mariadb_rdb: USED_MEM
• mysql_rdb: USED_MEM

user_data:

• sqlite_rdb: user_data(para1: Pcontext): pointer

use_result:

• mariadb_rdb: use_result(MySQL: PMySQL): PRES
• mysql_rdb: use_result(MySQL: PMySQL): PRES

USERNAME_LENGTH:

• mariadb_rdb: USERNAME_LENGTH
• mysql_rdb: USERNAME_LENGTH

uuid:

• column: uuid(_: type Column; name: string): Column

value_blob:

• sqlite_rdb: value_blob(para1: PValue): pointer

value_bytes:

• sqlite_rdb: value_bytes(para1: PValue): int32

value_bytes16:

• sqlite_rdb: value_bytes16(para1: PValue): int32

value_double:

• sqlite_rdb: value_double(para1: PValue): float64

value_int:

• sqlite_rdb: value_int(para1: PValue): int32

value_int64:

• sqlite_rdb: value_int64(para1: PValue): int64

value_text:

• sqlite_rdb: value_text(para1: PValue): cstring

value_text16:

• sqlite_rdb: value_text16(para1: PValue): pointer

value_text16be:

• sqlite_rdb: value_text16be(para1: PValue): pointer

value_text16le:

• sqlite_rdb: value_text16le(para1: PValue): pointer

value_type:

• sqlite_rdb: value_type(para1: PValue): int32

version:

• sqlite_rdb: version(): cstring

warning_count:

• mariadb_rdb: warning_count(MySQL: PMySQL): cuint
• mysql_rdb: warning_count(MySQL: PMySQL): cuint

where:

• mariadb_query: where(self: MariadbQuery; column: string; symbol: string; value: string | int | float): MariadbQuery
• mariadb_query: where(self: MariadbQuery; column: string; symbol: string; value: nil.type): MariadbQuery
• mariadb_query: where(self: MariadbQuery; column: string; symbol: string; value: bool): MariadbQuery
• mysql_query: where(self: MysqlQuery; column: string; symbol: string; value: string | int | float): MysqlQuery
• mysql_query: where(self: MysqlQuery; column: string; symbol: string; value: nil.type): MysqlQuery
• mysql_query: where(self: MysqlQuery; column: string; symbol: string; value: bool): MysqlQuery
• postgres_query: where(self: PostgresQuery; column: string; symbol: string; value: string | int | float): PostgresQuery
• postgres_query: where(self: PostgresQuery; column: string; symbol: string; value: nil.type): PostgresQuery
• postgres_query: where(self: PostgresQuery; column: string; symbol: string; value: bool): PostgresQuery
• sqlite_query: where(self: SqliteQuery; column: string; symbol: string; value: string | int | float): SqliteQuery
• sqlite_query: where(self: SqliteQuery; column: string; symbol: string; value: nil.type): SqliteQuery
• sqlite_query: where(self: SqliteQuery; column: string; symbol: string; value: bool): SqliteQuery
• surreal_query: where(self: SurrealQuery; column: string; symbol: string; value: bool | int | float | string | SurrealId): SurrealQuery
• surreal_query: where(self: SurrealQuery; column: string; symbol: string; value: nil.type): SurrealQuery

whereBetween:

• mariadb_query: whereBetween(self: MariadbQuery; column: string; width: array[2, int | float]): MariadbQuery
• mariadb_query: whereBetween(self: MariadbQuery; column: string; width: array[2, string]): MariadbQuery
• mysql_query: whereBetween(self: MysqlQuery; column: string; width: array[2, int | float]): MysqlQuery
• mysql_query: whereBetween(self: MysqlQuery; column: string; width: array[2, string]): MysqlQuery
• postgres_query: whereBetween(self: PostgresQuery; column: string; width: array[2, int | float]): PostgresQuery
• postgres_query: whereBetween(self: PostgresQuery; column: string; width: array[2, string]): PostgresQuery
• sqlite_query: whereBetween(self: SqliteQuery; column: string; width: array[2, int | float]): SqliteQuery
• sqlite_query: whereBetween(self: SqliteQuery; column: string; width: array[2, string]): SqliteQuery
• surreal_query: whereBetween(self: SurrealQuery; column: string; width: array[2, int | float]): SurrealQuery

whereBetweenSql:

• mariadb_generator: whereBetweenSql(self: MariadbQuery): MariadbQuery
• mysql_generator: whereBetweenSql(self: MysqlQuery): MysqlQuery
• postgres_generator: whereBetweenSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: whereBetweenSql(self: SqliteQuery): SqliteQuery
• surreal_generator: whereBetweenSql(self: SurrealQuery): SurrealQuery

whereBetweenStringSql:

• mariadb_generator: whereBetweenStringSql(self: MariadbQuery): MariadbQuery
• mysql_generator: whereBetweenStringSql(self: MysqlQuery): MysqlQuery
• postgres_generator: whereBetweenStringSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: whereBetweenStringSql(self: SqliteQuery): SqliteQuery

whereIn:

• mariadb_query: whereIn(self: MariadbQuery; column: string; width: seq[int | float | string]): MariadbQuery
• mysql_query: whereIn(self: MysqlQuery; column: string; width: seq[int | float | string]): MysqlQuery
• postgres_query: whereIn(self: PostgresQuery; column: string; width: seq[int | float | string]): PostgresQuery
• sqlite_query: whereIn(self: SqliteQuery; column: string; width: seq[int | float | string]): SqliteQuery
• surreal_query: whereIn(self: SurrealQuery; column: string; width: seq[int | float | string]): SurrealQuery

whereInSql:

• mariadb_generator: whereInSql(self: MariadbQuery): MariadbQuery
• mysql_generator: whereInSql(self: MysqlQuery): MysqlQuery
• postgres_generator: whereInSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: whereInSql(self: SqliteQuery): SqliteQuery
• surreal_generator: whereInSql(self: SurrealQuery): SurrealQuery

whereNotBetween:

• mariadb_query: whereNotBetween(self: MariadbQuery; column: string; width: array[2, int | float]): MariadbQuery
• mariadb_query: whereNotBetween(self: MariadbQuery; column: string; width: array[2, string]): MariadbQuery
• mysql_query: whereNotBetween(self: MysqlQuery; column: string; width: array[2, int | float]): MysqlQuery
• mysql_query: whereNotBetween(self: MysqlQuery; column: string; width: array[2, string]): MysqlQuery
• postgres_query: whereNotBetween(self: PostgresQuery; column: string; width: array[2, int | float]): PostgresQuery
• postgres_query: whereNotBetween(self: PostgresQuery; column: string; width: array[2, string]): PostgresQuery
• sqlite_query: whereNotBetween(self: SqliteQuery; column: string; width: array[2, int | float]): SqliteQuery
• sqlite_query: whereNotBetween(self: SqliteQuery; column: string; width: array[2, string]): SqliteQuery
• surreal_query: whereNotBetween(self: SurrealQuery; column: string; width: array[2, int | float]): SurrealQuery

whereNotBetweenSql:

• mariadb_generator: whereNotBetweenSql(self: MariadbQuery): MariadbQuery
• mysql_generator: whereNotBetweenSql(self: MysqlQuery): MysqlQuery
• postgres_generator: whereNotBetweenSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: whereNotBetweenSql(self: SqliteQuery): SqliteQuery
• surreal_generator: whereNotBetweenSql(self: SurrealQuery): SurrealQuery

whereNotBetweenStringSql:

• mariadb_generator: whereNotBetweenStringSql(self: MariadbQuery): MariadbQuery
• mysql_generator: whereNotBetweenStringSql(self: MysqlQuery): MysqlQuery
• postgres_generator: whereNotBetweenStringSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: whereNotBetweenStringSql(self: SqliteQuery): SqliteQuery

whereNotIn:

• mariadb_query: whereNotIn(self: MariadbQuery; column: string; width: seq[int | float | string]): MariadbQuery
• mysql_query: whereNotIn(self: MysqlQuery; column: string; width: seq[int | float | string]): MysqlQuery
• postgres_query: whereNotIn(self: PostgresQuery; column: string; width: seq[int | float | string]): PostgresQuery
• sqlite_query: whereNotIn(self: SqliteQuery; column: string; width: seq[int | float | string]): SqliteQuery
• surreal_query: whereNotIn(self: SurrealQuery; column: string; width: seq[int | float | string]): SurrealQuery

whereNotInSql:

• mariadb_generator: whereNotInSql(self: MariadbQuery): MariadbQuery
• mysql_generator: whereNotInSql(self: MysqlQuery): MysqlQuery
• postgres_generator: whereNotInSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: whereNotInSql(self: SqliteQuery): SqliteQuery
• surreal_generator: whereNotInSql(self: SurrealQuery): SurrealQuery

whereNull:

• mariadb_query: whereNull(self: MariadbQuery; column: string): MariadbQuery
• mysql_query: whereNull(self: MysqlQuery; column: string): MysqlQuery
• postgres_query: whereNull(self: PostgresQuery; column: string): PostgresQuery
• sqlite_query: whereNull(self: SqliteQuery; column: string): SqliteQuery
• surreal_query: whereNull(self: SurrealQuery; column: string): SurrealQuery

whereNullSql:

• mariadb_generator: whereNullSql(self: MariadbQuery): MariadbQuery
• mysql_generator: whereNullSql(self: MysqlQuery): MysqlQuery
• postgres_generator: whereNullSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: whereNullSql(self: SqliteQuery): SqliteQuery
• surreal_generator: whereNullSql(self: SurrealQuery): SurrealQuery

whereSql:

• mariadb_generator: whereSql(self: MariadbQuery): MariadbQuery
• mysql_generator: whereSql(self: MysqlQuery): MysqlQuery
• postgres_generator: whereSql(self: PostgresQuery): PostgresQuery
• sqlite_generator: whereSql(self: SqliteQuery): SqliteQuery
• surreal_generator: whereSql(self: SurrealQuery): SurrealQuery

WriteDbEffect:

• database_types: WriteDbEffect

ZEROFILL_FLAG:

• mariadb_rdb: ZEROFILL_FLAG
• mysql_rdb: ZEROFILL_FLAG