Index

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

API symbols

`$`:

• database_url: proc `$`(value: DatabaseUrl): string
• mariadb_types: proc `$`(self: MariadbConnections | MariadbQuery | RawMariadbQuery): string
• mysql_types: proc `$`(self: MysqlConnections | MysqlQuery | RawMysqlQuery): string
• postgres_types: proc `$`(self: PostgresConnections | PostgresQuery | RawPostgresQuery): string
• sqlite_types: proc `$`(self: SqliteConnections | SqliteQuery | RawSqliteQuery): string
• surreal_types: proc `$`(self: SurrealConnections | SurrealQuery | RawSurrealQuery): string
• surreal_types: proc `$`(self: SurrealId): string

`%`:

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

`[]`:

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

`distinct`:

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

add:

• column: proc add(c: Column): Column

AddColumn:

• enums: ColumnMigrationType.AddColumn

addColumn:

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

addColumnString:

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

addIndexString:

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

aggregate_context:

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

aggregate_count:

• sqlite_rdb: proc aggregate_count(para1: Pcontext): int32

Alter:

• enums: UsecaseType.Alter

alter:

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

alterAddForeignKey:

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

appendDbRowWithBaseColumns:

• postgres_lib: proc appendDbRowWithBaseColumns(res: PPGresult; dbRows: var DbRows; line, cols: int32; base: DbColumns)

Asc:

• enums: Order.Asc

asDatabaseUrl:

• database_url: proc asDatabaseUrl(value: string): DatabaseUrl

autoIncrement:

• column: proc autoIncrement(c: Column): Column

avg:

• mariadb_exec: proc avg(self: MariadbQuery; column: string): Future[Option[float]]
• mysql_exec: proc avg(self: MysqlQuery; column: string): Future[Option[float]]
• postgres_exec: proc avg(self: PostgresQuery; column: string): Future[Option[float]]
• sqlite_exec: proc avg(self: SqliteQuery; column: string): Future[Option[float]]
• surreal_exec: proc avg(self: SurrealQuery; column: string): Future[float]

avgBuilder:

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

backup_finish:

• sqlite_rdb: proc backup_finish(pBackup: PSqlite3_Backup): int32

backup_init:

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

backup_pagecount:

• sqlite_rdb: proc backup_pagecount(pBackup: PSqlite3_Backup): int32

backup_remaining:

• sqlite_rdb: proc backup_remaining(pBackup: PSqlite3_Backup): int32

backup_step:

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

begin:

• mariadb_exec: proc begin(self: MariadbConnections): owned(Future[void])
• mysql_exec: proc begin(self: MysqlConnections): owned(Future[void])
• postgres_exec: proc begin(self: PostgresConnections): owned(Future[void])
• sqlite_exec: proc begin(self: SqliteConnections): owned(Future[void])

bigInteger:

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

binary:

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

BIND:

• mariadb_rdb: type BIND
• mysql_rdb: type BIND

bind_blob:

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

bind_double:

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

bind_int:

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

bind_int64:

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

bind_null:

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

bindParam:

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

bind_parameter_count:

• sqlite_rdb: proc bind_parameter_count(para1: PStmt): int32

bind_parameter_index:

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

bind_parameter_name:

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

bind_text:

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

bind_text16:

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

boolean:

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

buildBaseDbColumns:

• postgres_lib: proc buildBaseDbColumns(res: PPGresult; cols: int32): DbColumns

busy_handler:

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

busy_timeout:

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

Callback:

• sqlite_rdb: type Callback

CASCADE:

• enums: ForeignOnDelete.CASCADE

change:

• column: proc change(c: Column): Column

ChangeColumn:

• enums: ColumnMigrationType.ChangeColumn

changeColumn:

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

changeColumnString:

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

changeForeignKey:

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

changes:

• sqlite_rdb: proc changes(para1: PSqlite3): int32

ChangeTable:

• enums: TableMigrationType.ChangeTable

char:

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

Charset_info_st:

• mariadb_rdb: object Charset_info_st
• mysql_rdb: object Charset_info_st

checkError:

• postgres_lib: proc checkError(db: PPGconn)

clear_bindings:

• sqlite_rdb: proc clear_bindings(para1: PStmt): int32

close:

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

CMDSTATUS_LEN:

• postgres_rdb: const CMDSTATUS_LEN

Collate:

• enums: Collation.Collate

Collation:

• enums: enum Collation

collation_needed:

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

collation_needed16:

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

Collation_needed_func:

• sqlite_rdb: type Collation_needed_func

Column:

• column: type Column

column_blob:

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

columnBuilder:

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

column_bytes:

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

column_bytes16:

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

column_count:

• sqlite_rdb: proc column_count(PStmt: PStmt): int32

column_decltype:

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

column_decltype16:

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

column_double:

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

column_int:

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

column_int64:

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

ColumnMigrationType:

• enums: enum ColumnMigrationType

column_name:

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

column_name16:

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

columns:

• mariadb_exec: proc columns(self: MariadbQuery): Future[seq[string]]
• mysql_exec: proc columns(self: MysqlQuery): Future[seq[string]]
• postgres_exec: proc columns(self: PostgresQuery): Future[seq[string]]
• sqlite_exec: proc columns(self: SqliteQuery): Future[seq[string]]
• surreal_exec: proc columns(self: SurrealQuery): Future[seq[string]]

column_table_name:

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

column_text:

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

column_text16:

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

column_type:

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

comment:

• column: proc comment(c: Column; value: string): Column
• column: proc comment(c: Column; arg: type nil): Column

commit:

• mariadb_exec: proc commit(self: MariadbConnections): owned(Future[void])
• mysql_exec: proc commit(self: MysqlConnections): owned(Future[void])
• postgres_exec: proc commit(self: PostgresConnections): owned(Future[void])
• sqlite_exec: proc commit(self: SqliteConnections): owned(Future[void])

commit_hook:

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

complete:

• sqlite_rdb: proc complete(sql: cstring): int32

complete16:

• sqlite_rdb: proc complete16(sql: pointer): int32

Connection:

• mariadb_types: object Connection
• mysql_types: object Connection
• postgres_types: type Connection
• sqlite_types: type Connection
• surreal_types: object Connection

CONNECTION_AUTH_OK:

• postgres_rdb: ConnStatusType.CONNECTION_AUTH_OK

CONNECTION_AWAITING_RESPONSE:

• postgres_rdb: ConnStatusType.CONNECTION_AWAITING_RESPONSE

CONNECTION_BAD:

• postgres_rdb: ConnStatusType.CONNECTION_BAD

CONNECTION_CHECK_TARGET:

• postgres_rdb: ConnStatusType.CONNECTION_CHECK_TARGET

CONNECTION_CHECK_WRITABLE:

• postgres_rdb: ConnStatusType.CONNECTION_CHECK_WRITABLE

CONNECTION_CONSUME:

• postgres_rdb: ConnStatusType.CONNECTION_CONSUME

CONNECTION_GSS_STARTUP:

• postgres_rdb: ConnStatusType.CONNECTION_GSS_STARTUP

ConnectionInfo:

• mariadb_types: object ConnectionInfo
• mysql_types: object ConnectionInfo

CONNECTION_MADE:

• postgres_rdb: ConnStatusType.CONNECTION_MADE

CONNECTION_NEEDED:

• postgres_rdb: ConnStatusType.CONNECTION_NEEDED

CONNECTION_OK:

• postgres_rdb: ConnStatusType.CONNECTION_OK

Connections:

• mariadb_types: type Connections
• mysql_types: type Connections
• postgres_types: type Connections
• sqlite_types: type Connections
• surreal_types: type Connections

CONNECTION_SETENV:

• postgres_rdb: ConnStatusType.CONNECTION_SETENV

CONNECTION_SSL_STARTUP:

• postgres_rdb: ConnStatusType.CONNECTION_SSL_STARTUP

CONNECTION_STARTED:

• postgres_rdb: ConnStatusType.CONNECTION_STARTED

ConnStatusType:

• postgres_rdb: enum ConnStatusType

count:

• mariadb_exec: proc count(self: MariadbQuery): Future[int]
• mysql_exec: proc count(self: MysqlQuery): Future[int]
• postgres_exec: proc count(self: PostgresQuery): Future[int]
• sqlite_exec: proc count(self: SqliteQuery): Future[int]
• surreal_exec: proc count(self: SurrealQuery): Future[int]

countBuilder:

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

Create:

• enums: UsecaseType.Create

create:

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

create_collation:

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

create_collation16:

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

Create_collation_func:

• sqlite_rdb: type Create_collation_func

createColumnString:

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

createCommentColumn:

• create_column_query: proc createCommentColumn(table: Table; column: Column): string

createForeignKey:

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

createForeignString:

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

create_function:

• sqlite_rdb: proc 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: proc 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: type Create_function_final_func

Create_function_func_func:

• sqlite_rdb: type Create_function_func_func

Create_function_step_func:

• sqlite_rdb: type Create_function_step_func

createIndexString:

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

createMigrationTable:

• create_migration_table: proc createMigrationTable(self: MariadbSchema)
• create_migration_table: proc createMigrationTable(self: MysqlSchema)
• create_migration_table: proc createMigrationTable(self: PostgresSchema)
• create_migration_table: proc createMigrationTable(self: SqliteSchema)
• create_migration_table: proc createMigrationTable(self: SurrealSchema; isReset: bool = false)

createSchema:

• create_query_def: proc createSchema(rdb: MariadbConnections; table: Table): MariadbSchema
• create_query_def: proc createSchema(rdb: MariadbConnections; table: Table; column: Column): MariadbSchema
• create_schema: proc createSchema(rdb: MariadbConnections; schemaPath = ""): owned(Future[void])
• create_query_def: proc createSchema(rdb: MysqlConnections; table: Table): MysqlSchema
• create_query_def: proc createSchema(rdb: MysqlConnections; table: Table; column: Column): MysqlSchema
• create_schema: proc createSchema(rdb: MysqlConnections; schemaPath = ""): owned(Future[void])
• create_query_def: proc createSchema(rdb: PostgresConnections; table: Table): PostgresSchema
• create_query_def: proc createSchema(rdb: PostgresConnections; table: Table; column: Column): PostgresSchema
• create_schema: proc createSchema(rdb: PostgresConnections; schemaPath = ""): owned(Future[void])
• create_query_def: proc createSchema(rdb: SqliteConnections; table: Table): SqliteSchema
• create_query_def: proc createSchema(rdb: SqliteConnections; table: Table; column: Column): SqliteSchema
• create_schema: proc createSchema(rdb: SqliteConnections; schemaPath = ""): owned(Future[void])
• create_query_def: proc createSchema(rdb: SurrealConnections; table: Table): SurrealSchema
• create_query_def: proc createSchema(rdb: SurrealConnections; table: Table; column: Column): SurrealSchema
• create_schema: proc createSchema(rdb: SurrealConnections; schemaPath = ""): owned(Future[void])

createSequenceTable:

• create_sequence_table: proc createSequenceTable(rdb: SurrealConnections)

CreateTable:

• enums: TableMigrationType.CreateTable

createTable:

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

createUpdatedAtString:

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

cuint:

• mariadb_rdb: type cuint
• mysql_rdb: type cuint

Current:

• enums: DefaultDateTime.Current

CurrentOnUpdate:

• enums: DefaultDateTime.CurrentOnUpdate

DATA:

• mariadb_rdb: type DATA
• mysql_rdb: type DATA

databaseName:

• database_url: proc databaseName(value: ParsedDatabaseUrl): string

DatabaseUrl:

• database_url: type DatabaseUrl

DatabaseUrlQuery:

• database_url: tuple DatabaseUrlQuery

data_count:

• sqlite_rdb: proc data_count(PStmt: PStmt): int32

date:

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

datetime:

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

dbArray:

• database_types: DbTypeKind.dbArray

dbBindParamError:

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

dbBit:

• database_types: DbTypeKind.dbBit

dbBlob:

• database_types: DbTypeKind.dbBlob

dbBool:

• database_types: DbTypeKind.dbBool

dbBox:

• database_types: DbTypeKind.dbBox

dbCircle:

• database_types: DbTypeKind.dbCircle

DbColumn:

• database_types: object DbColumn

DbColumns:

• database_types: type DbColumns

dbComposite:

• database_types: DbTypeKind.dbComposite

dbDate:

• database_types: DbTypeKind.dbDate

dbDatetime:

• database_types: DbTypeKind.dbDatetime

dbDecimal:

• database_types: DbTypeKind.dbDecimal

DbEffect:

• database_types: object DbEffect

dbEnum:

• database_types: DbTypeKind.dbEnum

DbError:

• error: object DbError

dbError:

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

dbFixedChar:

• database_types: DbTypeKind.dbFixedChar

dbFloat:

• database_types: DbTypeKind.dbFloat

dbFormat:

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

dbGeometry:

• database_types: DbTypeKind.dbGeometry

dbInet:

• database_types: DbTypeKind.dbInet

dbInt:

• database_types: DbTypeKind.dbInt

dbJson:

• database_types: DbTypeKind.dbJson

dbLine:

• database_types: DbTypeKind.dbLine

dbLseg:

• database_types: DbTypeKind.dbLseg

dbMacAddress:

• database_types: DbTypeKind.dbMacAddress

dbNull:

• database_types: DbTypeKind.dbNull

dbOpen:

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

dbPath:

• database_types: DbTypeKind.dbPath

dbPoint:

• database_types: DbTypeKind.dbPoint

dbPolygon:

• database_types: DbTypeKind.dbPolygon

DbRows:

• database_types: type DbRows

dbSerial:

• database_types: DbTypeKind.dbSerial

dbSet:

• database_types: DbTypeKind.dbSet

dbTime:

• database_types: DbTypeKind.dbTime

dbTimeInterval:

• database_types: DbTypeKind.dbTimeInterval

dbTimestamp:

• database_types: DbTypeKind.dbTimestamp

DbType:

• database_types: object DbType

DbTypeKind:

• database_types: enum DbTypeKind

dbUInt:

• database_types: DbTypeKind.dbUInt

dbUnknown:

• database_types: DbTypeKind.dbUnknown

dbUrl:

• database_types: DbTypeKind.dbUrl

dbUser1:

• database_types: DbTypeKind.dbUser1

dbUser2:

• database_types: DbTypeKind.dbUser2

dbUser3:

• database_types: DbTypeKind.dbUser3

dbUser4:

• database_types: DbTypeKind.dbUser4

dbUser5:

• database_types: DbTypeKind.dbUser5

dbUuid:

• database_types: DbTypeKind.dbUuid

dbVarchar:

• database_types: DbTypeKind.dbVarchar

dbXml:

• database_types: DbTypeKind.dbXml

decimal:

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

default:

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

DefaultDateTime:

• enums: enum DefaultDateTime

delete:

• mariadb_exec: proc delete(self: MariadbQuery): owned(Future[void])
• mariadb_exec: proc delete(self: MariadbQuery; id: int; key = "id"): owned(Future[void])
• mysql_exec: proc delete(self: MysqlQuery): owned(Future[void])
• mysql_exec: proc delete(self: MysqlQuery; id: int; key = "id"): owned(Future[void])
• postgres_exec: proc delete(self: PostgresQuery): owned(Future[void])
• postgres_exec: proc delete(self: PostgresQuery; id: int; key = "id"): owned(Future[void])
• sqlite_exec: proc delete(self: SqliteQuery): owned(Future[void])
• sqlite_exec: proc delete(self: SqliteQuery; id: int; key = "id"): owned(Future[void])
• surreal_exec: proc delete(self: SurrealQuery): owned(Future[void])
• surreal_exec: proc delete(self: SurrealQuery; id: SurrealId): owned(Future[void])

deleteBuilder:

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

deleteByIdBuilder:

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

deleteByIdSql:

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

deleteSql:

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

Desc:

• enums: Order.Desc

double:

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

Drop:

• enums: UsecaseType.Drop

drop:

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

DropColumn:

• enums: ColumnMigrationType.DropColumn

dropColumn:

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

DropTable:

• enums: TableMigrationType.DropTable

dropTable:

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

echoErrorMsg:

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

echoWarningMsg:

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

enumField:

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

Enum_field_types:

• mariadb_rdb: enum Enum_field_types
• mysql_rdb: enum Enum_field_types

Enum_mysql_stmt_state:

• mariadb_rdb: enum Enum_mysql_stmt_state
• mysql_rdb: enum Enum_mysql_stmt_state

Enum_server_command:

• mariadb_rdb: enum Enum_server_command
• mysql_rdb: enum Enum_server_command

errcode:

• sqlite_rdb: proc errcode(db: PSqlite3): int32

errmsg:

• sqlite_rdb: proc errmsg(para1: PSqlite3): cstring

errmsg16:

• sqlite_rdb: proc errmsg16(para1: PSqlite3): pointer

ERRMSG_SIZE:

• mariadb_rdb: const ERRMSG_SIZE
• mysql_rdb: const ERRMSG_SIZE

error:

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

errorConnectionNum:

• database_types: const errorConnectionNum

ERROR_MSG_LENGTH:

• postgres_rdb: const ERROR_MSG_LENGTH

exec:

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

execGetValue:

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

ExecStatusType:

• postgres_rdb: enum ExecStatusType

execThenSaveHistory:

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

false:

• mariadb_rdb: my_bool.false
• mysql_rdb: my_bool.false

fetch:

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

fetch_field_direct:

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

fetch_row:

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

fetch_row_cont:

• mariadb_rdb: proc fetch_row_cont(ret: ptr ROW; result: PRES; status: cint): cint

fetch_row_start:

• mariadb_rdb: proc fetch_row_start(ret: ptr ROW; result: PRES): cint

fetchSql:

• surreal_generator: proc fetchSql(self: SurrealQuery): SurrealQuery

FIELD:

• mariadb_rdb: type FIELD
• mysql_rdb: type FIELD

finalize:

• sqlite_rdb: proc finalize(PStmt: PStmt): int32

find:

• mariadb_exec: proc find(self: MariadbQuery; id: int; key = "id"): Future[Option[JsonNode]]
• mariadb_exec: proc find(self: MariadbQuery; id: string; key = "id"): Future[Option[JsonNode]]
• mysql_exec: proc find(self: MysqlQuery; id: int; key = "id"): Future[Option[JsonNode]]
• mysql_exec: proc find(self: MysqlQuery; id: string; key = "id"): Future[Option[JsonNode]]
• postgres_exec: proc find(self: PostgresQuery; id: int; key = "id"): Future[Option[JsonNode]]
• postgres_exec: proc find(self: PostgresQuery; id: string; key = "id"): Future[Option[JsonNode]]
• sqlite_exec: proc find(self: SqliteQuery; id: int; key = "id"): Future[Option[JsonNode]]
• sqlite_exec: proc find(self: SqliteQuery; id: string; key = "id"): Future[Option[JsonNode]]
• surreal_exec: proc find(self: SurrealQuery; id: SurrealId; key = "id"): Future[Option[JsonNode]]

findPlain:

• mariadb_exec: proc findPlain(self: MariadbQuery; id: int; key = "id"): Future[seq[string]]
• mariadb_exec: proc findPlain(self: MariadbQuery; id: string; key = "id"): Future[seq[string]]
• mysql_exec: proc findPlain(self: MysqlQuery; id: int; key = "id"): Future[seq[string]]
• mysql_exec: proc findPlain(self: MysqlQuery; id: string; key = "id"): Future[seq[string]]
• postgres_exec: proc findPlain(self: PostgresQuery; id: int; key = "id"): Future[seq[string]]
• postgres_exec: proc findPlain(self: PostgresQuery; id: string; key = "id"): Future[seq[string]]
• sqlite_exec: proc findPlain(self: SqliteQuery; id: int; key = "id"): Future[seq[string]]
• sqlite_exec: proc findPlain(self: SqliteQuery; id: string; key = "id"): Future[seq[string]]

first:

• mariadb_exec: proc first(self: MariadbQuery): Future[Option[JsonNode]]
• mariadb_exec: proc first(self: RawMariadbQuery): Future[Option[JsonNode]]
• mysql_exec: proc first(self: MysqlQuery): Future[Option[JsonNode]]
• mysql_exec: proc first(self: RawMysqlQuery): Future[Option[JsonNode]]
• postgres_exec: proc first(self: PostgresQuery): Future[Option[JsonNode]]
• postgres_exec: proc first(self: RawPostgresQuery): Future[Option[JsonNode]]
• sqlite_exec: proc first(self: RawSqliteQuery): Future[Option[JsonNode]]
• sqlite_exec: proc first(self: SqliteQuery): Future[Option[JsonNode]]
• surreal_exec: proc first(self: RawSurrealQuery): Future[Option[JsonNode]]
• surreal_exec: proc first(self: SurrealQuery): Future[Option[JsonNode]]

firstPlain:

• mariadb_exec: proc firstPlain(self: MariadbQuery): Future[seq[string]]
• mariadb_exec: proc firstPlain(self: RawMariadbQuery): Future[seq[string]]
• mysql_exec: proc firstPlain(self: MysqlQuery): Future[seq[string]]
• mysql_exec: proc firstPlain(self: RawMysqlQuery): Future[seq[string]]
• postgres_exec: proc firstPlain(self: PostgresQuery): Future[seq[string]]
• postgres_exec: proc firstPlain(self: RawPostgresQuery): Future[seq[string]]
• sqlite_exec: proc firstPlain(self: RawSqliteQuery): Future[seq[string]]
• sqlite_exec: proc firstPlain(self: SqliteQuery): Future[seq[string]]

float:

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

foreign:

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

ForeignOnDelete:

• enums: enum ForeignOnDelete

free:

• sqlite_rdb: proc free(z: cstring)

free_result:

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

free_result_cont:

• mariadb_rdb: proc free_result_cont(result: PRES; status: cint): cint

free_result_start:

• mariadb_rdb: proc free_result_start(result: PRES): cint

free_table:

• sqlite_rdb: proc free_table(result: cstringArray)

fromArray:

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

fromObj:

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

fromObjArray:

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

fromSql:

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

get:

• mariadb_exec: proc get(self: MariadbQuery): Future[seq[JsonNode]]
• mariadb_exec: proc get(self: RawMariadbQuery): Future[seq[JsonNode]]
• mysql_exec: proc get(self: MysqlQuery): Future[seq[JsonNode]]
• mysql_exec: proc get(self: RawMysqlQuery): Future[seq[JsonNode]]
• postgres_exec: proc get(self: PostgresQuery): Future[seq[JsonNode]]
• postgres_exec: proc get(self: RawPostgresQuery): Future[seq[JsonNode]]
• sqlite_exec: proc get(self: RawSqliteQuery): Future[seq[JsonNode]]
• sqlite_exec: proc get(self: SqliteQuery): Future[seq[JsonNode]]
• surreal_exec: proc get(self: RawSurrealQuery): Future[seq[JsonNode]]
• surreal_exec: proc get(self: SurrealQuery): Future[seq[JsonNode]]

get_auxdata:

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

getColumns:

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

getColumnTypes:

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

getOsName:

• utils: proc getOsName(): string

getPlain:

• mariadb_exec: proc getPlain(self: MariadbQuery): Future[seq[seq[string]]]
• mariadb_exec: proc getPlain(self: RawMariadbQuery): Future[seq[seq[string]]]
• mysql_exec: proc getPlain(self: MysqlQuery): Future[seq[seq[string]]]
• mysql_exec: proc getPlain(self: RawMysqlQuery): Future[seq[seq[string]]]
• postgres_exec: proc getPlain(self: PostgresQuery): Future[seq[seq[string]]]
• postgres_exec: proc getPlain(self: RawPostgresQuery): Future[seq[seq[string]]]
• sqlite_exec: proc getPlain(self: RawSqliteQuery): Future[seq[seq[string]]]
• sqlite_exec: proc getPlain(self: SqliteQuery): Future[seq[seq[string]]]

get_socket:

• mariadb_rdb: proc get_socket(MySQL: PMySQL): my_socket

get_table:

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

get_timeout_value:

• mariadb_rdb: proc get_timeout_value(MySQL: PMySQL): cuint

get_timeout_value_ms:

• mariadb_rdb: proc get_timeout_value_ms(MySQL: PMySQL): cuint

gptr:

• mariadb_rdb: type gptr
• mysql_rdb: type gptr

groupAllSql:

• surreal_generator: proc groupAllSql(self: SurrealQuery): SurrealQuery

groupBy:

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

groupBySql:

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

having:

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

havingSql:

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

increments:

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

index:

• column: proc index(c: Column): Column

info:

• surreal_impl: proc info(db: SurrealConn; query: string; args: JsonNode; timeout: int): Future[ JsonNode]
• surreal_impl: proc info(db: SurrealConn; query: string; args: seq[string]; timeout: int): Future[ JsonNode]
• surreal_exec: proc info(self: RawSurrealQuery): Future[JsonNode]

init:

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

INIT_COMMAND:

• mariadb_rdb: Option.INIT_COMMAND
• mysql_rdb: Option.INIT_COMMAND

insert:

• mariadb_exec: proc insert(self: MariadbQuery; items: JsonNode): owned(Future[void])
• mariadb_exec: proc insert(self: MariadbQuery; items: seq[JsonNode]): owned(Future[void])
• mariadb_exec: proc insert[T](self: MariadbQuery; items: seq[T]): owned(Future[void])
• mariadb_exec: proc insert[T](self: MariadbQuery; items: T): owned(Future[void])
• mysql_exec: proc insert(self: MysqlQuery; items: JsonNode): owned(Future[void])
• mysql_exec: proc insert(self: MysqlQuery; items: seq[JsonNode]): owned(Future[void])
• mysql_exec: proc insert[T](self: MysqlQuery; items: seq[T]): owned(Future[void])
• mysql_exec: proc insert[T](self: MysqlQuery; items: T): owned(Future[void])
• postgres_exec: proc insert(self: PostgresQuery; items: JsonNode): owned(Future[void])
• postgres_exec: proc insert(self: PostgresQuery; items: seq[JsonNode]): owned(Future[void])
• postgres_exec: proc insert[T](self: PostgresQuery; items: seq[T]): owned(Future[void])
• postgres_exec: proc insert[T](self: PostgresQuery; items: T): owned(Future[void])
• sqlite_exec: proc insert(self: SqliteQuery; items: JsonNode): owned(Future[void])
• sqlite_exec: proc insert(self: SqliteQuery; items: seq[JsonNode]): owned(Future[void])
• sqlite_exec: proc insert[T](self: SqliteQuery; items: seq[T]): owned(Future[void])
• sqlite_exec: proc insert[T](self: SqliteQuery; items: T): owned(Future[void])
• surreal_exec: proc insert(self: SurrealQuery; items: JsonNode): owned(Future[void])
• surreal_exec: proc insert(self: SurrealQuery; items: seq[JsonNode]): owned(Future[void])
• surreal_exec: proc insert[T](self: SurrealQuery; items: seq[T]): owned(Future[void])
• surreal_exec: proc insert[T](self: SurrealQuery; items: T): owned(Future[void])

insertId:

• mariadb_exec: proc insertId(self: MariadbQuery; items: JsonNode; key = "id"): Future[string]
• mariadb_exec: proc insertId(self: MariadbQuery; items: seq[JsonNode]; key = "id"): Future[ seq[string]]
• mariadb_exec: proc insertId[T](self: MariadbQuery; items: seq[T]; key = "id"): Future[seq[string]]
• mariadb_exec: proc insertId[T](self: MariadbQuery; items: T; key = "id"): Future[string]
• mysql_exec: proc insertId(self: MysqlQuery; items: JsonNode; key = "id"): Future[string]
• mysql_exec: proc insertId(self: MysqlQuery; items: seq[JsonNode]; key = "id"): Future[seq[string]]
• mysql_exec: proc insertId[T](self: MysqlQuery; items: seq[T]; key = "id"): Future[seq[string]]
• mysql_exec: proc insertId[T](self: MysqlQuery; items: T; key = "id"): Future[string]
• postgres_exec: proc insertId(self: PostgresQuery; items: JsonNode; key = "id"): Future[string]
• postgres_exec: proc insertId(self: PostgresQuery; items: seq[JsonNode]; key = "id"): Future[ seq[string]]
• postgres_exec: proc insertId[T](self: PostgresQuery; items: seq[T]; key = "id"): Future[seq[string]]
• postgres_exec: proc insertId[T](self: PostgresQuery; items: T; key = "id"): Future[string]
• sqlite_exec: proc insertId(self: SqliteQuery; items: JsonNode; key = "id"): Future[string]
• sqlite_exec: proc insertId(self: SqliteQuery; items: seq[JsonNode]; key = "id"): Future[ seq[string]]
• sqlite_exec: proc insertId[T](self: SqliteQuery; items: seq[T]; key = "id"): Future[seq[string]]
• sqlite_exec: proc insertId[T](self: SqliteQuery; items: T; key = "id"): Future[string]
• surreal_exec: proc insertId(self: SurrealQuery; items: JsonNode; key = "id"): Future[SurrealId]
• surreal_exec: proc insertId(self: SurrealQuery; items: seq[JsonNode]; key = "id"): Future[ seq[SurrealId]]
• surreal_exec: proc insertId[T](self: SurrealQuery; items: seq[T]; key = "id"): Future[ seq[SurrealId]]
• surreal_exec: proc insertId[T](self: SurrealQuery; items: T; key = "id"): Future[SurrealId]

insertSql:

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

insertValueBuilder:

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

insertValuesBuilder:

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

insertValueSql:

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

insertValuesSql:

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

InstantRow:

• sqlite_rdb: type InstantRow

instantRows:

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

instantRowsPlain:

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

integer:

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

interrupt:

• sqlite_rdb: proc interrupt(para1: PSqlite3)

isConnected:

• mariadb_types: proc isConnected(self: MariadbConnections | MariadbQuery | RawMariadbQuery): bool
• mysql_types: proc isConnected(self: MysqlConnections | MysqlQuery | RawMysqlQuery): bool
• postgres_types: proc isConnected(self: PostgresConnections | PostgresQuery | RawPostgresQuery): bool

isExistsIndex:

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

isExistsMariadb:

• env: const isExistsMariadb

isExistsMysql:

• env: const isExistsMysql

isExistsPostgres:

• env: const isExistsPostgres

isExistsSqlite:

• env: const isExistsSqlite

isExistsSurrealdb:

• env: const isExistsSurrealdb

isExistsUnique:

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

join:

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

joinSql:

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

json:

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

last_insert_rowid:

• sqlite_rdb: proc last_insert_rowid(para1: PSqlite3): int64

leftJoin:

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

leftJoinSql:

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

len:

• sqlite_lib: proc len(row: InstantRow): int32

libversion:

• sqlite_rdb: proc libversion(): cstring

libversion_number:

• sqlite_rdb: proc libversion_number(): int32

limit:

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

limitSql:

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

lo_close:

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

lo_creat:

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

lo_export:

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

logger:

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

LogSetting:

• log: type LogSetting

lo_import:

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

lo_lseek:

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

longText:

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

lo_open:

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

lo_read:

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

lo_tell:

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

lo_unlink:

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

lo_write:

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

MariaDB:

• mariadb_types: object MariaDB

MariadbConnections:

• mariadb_types: type MariadbConnections

MariadbParams:

• mariadb_lib: type MariadbParams

MariadbParamValue:

• mariadb_lib: object MariadbParamValue

MariadbQuery:

• mariadb_types: type MariadbQuery

MariadbSchema:

• mariadb_query_type: type MariadbSchema

max:

• mariadb_exec: proc max(self: MariadbQuery; column: string): Future[Option[string]]
• mysql_exec: proc max(self: MysqlQuery; column: string): Future[Option[string]]
• postgres_exec: proc max(self: PostgresQuery; column: string): Future[Option[string]]
• sqlite_exec: proc max(self: SqliteQuery; column: string): Future[Option[string]]
• surreal_exec: proc max(self: SurrealQuery; column: string; collaction: Collation = None): Future[ string]

maxBuilder:

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

maxFromSql:

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

mediumInteger:

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

mediumText:

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

MEM_ROOT:

• mariadb_rdb: type MEM_ROOT
• mysql_rdb: type MEM_ROOT

migrationTable:

• migration_table_def: let migrationTable

min:

• mariadb_exec: proc min(self: MariadbQuery; column: string): Future[Option[string]]
• mysql_exec: proc min(self: MysqlQuery; column: string): Future[Option[string]]
• postgres_exec: proc min(self: PostgresQuery; column: string): Future[Option[string]]
• sqlite_exec: proc min(self: SqliteQuery; column: string): Future[Option[string]]
• surreal_exec: proc min(self: SurrealQuery; column: string; collaction: Collation = None): Future[ string]

minBuilder:

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

mprintf:

• sqlite_rdb: proc mprintf(para1: cstring): cstring

my_bool:

• mariadb_rdb: type my_bool
• mysql_rdb: type my_bool

my_socket:

• mariadb_rdb: type my_socket
• mysql_rdb: type my_socket

MySQL:

• mariadb_rdb: type MySQL
• mysql_types: object MySQL

MysqlConnections:

• mysql_types: type MysqlConnections

MYSQL_OPT_NONBLOCK:

• mariadb_rdb: Option.MYSQL_OPT_NONBLOCK
• mysql_rdb: Option.MYSQL_OPT_NONBLOCK

MysqlParams:

• mysql_lib: type MysqlParams

MysqlParamValue:

• mysql_lib: object MysqlParamValue

MysqlQuery:

• mysql_types: type MysqlQuery

MysqlSchema:

• mysql_query_type: type MysqlSchema

MYSQL_WAIT_EXCEPT:

• mariadb_rdb: const MYSQL_WAIT_EXCEPT

MYSQL_WAIT_READ:

• mariadb_rdb: const MYSQL_WAIT_READ

MYSQL_WAIT_TIMEOUT:

• mariadb_rdb: const MYSQL_WAIT_TIMEOUT

MYSQL_WAIT_WRITE:

• mariadb_rdb: const MYSQL_WAIT_WRITE

my_ulonglong:

• mariadb_rdb: type my_ulonglong
• mysql_rdb: type my_ulonglong

NET:

• mariadb_rdb: type NET
• mysql_rdb: type NET

new:

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

newRow:

• postgres_lib: proc newRow(L: int): Row

NO_ACTION:

• enums: ForeignOnDelete.NO_ACTION

None:

• enums: Collation.None
• enums: DefaultDateTime.None

notAllowedOption:

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

notAllowedType:

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

NOT_NULL_FLAG:

• mariadb_rdb: const NOT_NULL_FLAG
• mysql_rdb: const NOT_NULL_FLAG

nullable:

• column: proc nullable(c: Column): Column

Numeric:

• enums: Collation.Numeric

num_fields:

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

numToAlphabet:

• surreal_lib: proc numToAlphabet(n: int): string

offset:

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

offsetSql:

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

Oid:

• postgres_rdb: type Oid

onDelete:

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

onTable:

• column: proc onTable(self: Column; table: string): Column

open:

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

open16:

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

OPT_COMPRESS:

• mariadb_rdb: Option.OPT_COMPRESS
• mysql_rdb: Option.OPT_COMPRESS

OPT_CONNECT_TIMEOUT:

• mariadb_rdb: Option.OPT_CONNECT_TIMEOUT
• mysql_rdb: Option.OPT_CONNECT_TIMEOUT

OPT_GUESS_CONNECTION:

• mariadb_rdb: Option.OPT_GUESS_CONNECTION
• mysql_rdb: Option.OPT_GUESS_CONNECTION

Option:

• mariadb_rdb: enum Option
• mysql_rdb: enum Option

options:

• mariadb_rdb: proc options(MySQL: PMySQL; option: Option; arg: pointer): cint

optionsv:

• mariadb_rdb: proc optionsv(MySQL: PMySQL; option: Option): cint

OPT_LOCAL_INFILE:

• mariadb_rdb: Option.OPT_LOCAL_INFILE
• mysql_rdb: Option.OPT_LOCAL_INFILE

OPT_NAMED_PIPE:

• mariadb_rdb: Option.OPT_NAMED_PIPE
• mysql_rdb: Option.OPT_NAMED_PIPE

OPT_PROTOCOL:

• mariadb_rdb: Option.OPT_PROTOCOL
• mysql_rdb: Option.OPT_PROTOCOL

OPT_READ_TIMEOUT:

• mariadb_rdb: Option.OPT_READ_TIMEOUT
• mysql_rdb: Option.OPT_READ_TIMEOUT

OPT_RECONNECT:

• mariadb_rdb: Option.OPT_RECONNECT
• mysql_rdb: Option.OPT_RECONNECT

OPT_USE_EMBEDDED_CONNECTION:

• mariadb_rdb: Option.OPT_USE_EMBEDDED_CONNECTION
• mysql_rdb: Option.OPT_USE_EMBEDDED_CONNECTION

OPT_USE_REMOTE_CONNECTION:

• mariadb_rdb: Option.OPT_USE_REMOTE_CONNECTION
• mysql_rdb: Option.OPT_USE_REMOTE_CONNECTION

OPT_USE_RESULT:

• mariadb_rdb: Option.OPT_USE_RESULT
• mysql_rdb: Option.OPT_USE_RESULT

OPT_WRITE_TIMEOUT:

• mariadb_rdb: Option.OPT_WRITE_TIMEOUT
• mysql_rdb: Option.OPT_WRITE_TIMEOUT

Order:

• enums: enum Order

orderBy:

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

orderBySql:

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

orm:

• orm: proc orm[T](response: Future[Option[JsonNode]]; typ: typedesc[T]): Future[Option[T]]
• orm: proc orm[T](response: Future[seq[JsonNode]]; typ: typedesc[T]): Future[seq[T]]

orWhere:

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

orWhereSql:

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

parallel:

• surreal_query: proc parallel(self: SurrealQuery): SurrealQuery

parallelSql:

• surreal_generator: proc parallelSql(self: SurrealQuery): SurrealQuery

parseDatabaseUrl:

• database_url: proc parseDatabaseUrl(value: DatabaseUrl): ParsedDatabaseUrl
• database_url: proc parseDatabaseUrl(value: string): ParsedDatabaseUrl

ParsedDatabaseUrl:

• database_url: object ParsedDatabaseUrl

PBIND:

• mariadb_rdb: type PBIND
• mysql_rdb: type PBIND

Pcharset_info_st:

• mariadb_rdb: type Pcharset_info_st
• mysql_rdb: type Pcharset_info_st

PConnStatusType:

• postgres_rdb: type PConnStatusType

Pcontext:

• sqlite_rdb: type Pcontext

PDATA:

• mariadb_rdb: type PDATA
• mysql_rdb: type PDATA

PExecStatusType:

• postgres_rdb: type PExecStatusType

PFIELD:

• mariadb_rdb: type PFIELD
• mysql_rdb: type PFIELD

PGCancel:

• postgres_rdb: object PGCancel

PGconn:

• postgres_rdb: object PGconn

PGlobjfuncs:

• postgres_rdb: object PGlobjfuncs

pgNotify:

• postgres_rdb: object pgNotify

PGParams:

• postgres_lib: object PGParams

PGresAttDesc:

• postgres_rdb: object PGresAttDesc

PGresAttValue:

• postgres_rdb: object PGresAttValue

PGRES_BAD_RESPONSE:

• postgres_rdb: ExecStatusType.PGRES_BAD_RESPONSE

PGRES_COMMAND_OK:

• postgres_rdb: ExecStatusType.PGRES_COMMAND_OK

PGRES_COPY_BOTH:

• postgres_rdb: ExecStatusType.PGRES_COPY_BOTH

PGRES_COPY_IN:

• postgres_rdb: ExecStatusType.PGRES_COPY_IN

PGRES_COPY_OUT:

• postgres_rdb: ExecStatusType.PGRES_COPY_OUT

PGRES_EMPTY_QUERY:

• postgres_rdb: ExecStatusType.PGRES_EMPTY_QUERY

PGRES_FATAL_ERROR:

• postgres_rdb: ExecStatusType.PGRES_FATAL_ERROR

PGRES_NONFATAL_ERROR:

• postgres_rdb: ExecStatusType.PGRES_NONFATAL_ERROR

PGRES_POLLING_ACTIVE:

• postgres_rdb: PostgresPollingStatusType.PGRES_POLLING_ACTIVE

PGRES_POLLING_FAILED:

• postgres_rdb: PostgresPollingStatusType.PGRES_POLLING_FAILED

PGRES_POLLING_OK:

• postgres_rdb: PostgresPollingStatusType.PGRES_POLLING_OK

PGRES_POLLING_READING:

• postgres_rdb: PostgresPollingStatusType.PGRES_POLLING_READING

PGRES_POLLING_WRITING:

• postgres_rdb: PostgresPollingStatusType.PGRES_POLLING_WRITING

PGRES_SINGLE_TUPLE:

• postgres_rdb: ExecStatusType.PGRES_SINGLE_TUPLE

PGRES_TUPLES_OK:

• postgres_rdb: ExecStatusType.PGRES_TUPLES_OK

PGresult:

• postgres_rdb: object PGresult

PGTransactionStatusType:

• postgres_rdb: enum PGTransactionStatusType

PGVerbosity:

• postgres_rdb: enum PGVerbosity

ping:

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

Pmy_bool:

• mariadb_rdb: type Pmy_bool
• mysql_rdb: type Pmy_bool

PMySQL:

• mariadb_rdb: type PMySQL
• mysql_rdb: type PMySQL

PNET:

• mariadb_rdb: type PNET
• mysql_rdb: type PNET

POid:

• postgres_rdb: type POid

portOrDefault:

• database_url: proc portOrDefault(value: ParsedDatabaseUrl; defaultPort: int): int

PostgresConnections:

• postgres_types: type PostgresConnections

PostgresPollingStatusType:

• postgres_rdb: enum PostgresPollingStatusType

PostgreSQL:

• postgres_types: object PostgreSQL

PostgresQuery:

• postgres_types: type PostgresQuery

PostgresSchema:

• postgres_query_type: type PostgresSchema

PPByte:

• mariadb_rdb: type PPByte
• mysql_rdb: type PPByte

PPGcancel:

• postgres_rdb: type PPGcancel

PPGconn:

• postgres_rdb: type PPGconn

PPGlobjfuncs:

• postgres_rdb: type PPGlobjfuncs

PPGNotify:

• postgres_rdb: type PPGNotify

PPGresAttDesc:

• postgres_rdb: type PPGresAttDesc

PPGresAttValue:

• postgres_rdb: type PPGresAttValue

PPGresult:

• postgres_rdb: type PPGresult

PPGTransactionStatusType:

• postgres_rdb: type PPGTransactionStatusType

PPGVerbosity:

• postgres_rdb: type PPGVerbosity

PPostgresPollingStatusType:

• postgres_rdb: type PPostgresPollingStatusType

PPPGresAttDesc:

• postgres_rdb: type PPPGresAttDesc

PPPGresAttValue:

• postgres_rdb: type PPPGresAttValue

PPQArgBlock:

• postgres_rdb: type PPQArgBlock

Ppqbool:

• postgres_rdb: type Ppqbool

PPQconninfoOption:

• postgres_rdb: type PPQconninfoOption

PPQprintOpt:

• postgres_rdb: type PPQprintOpt

PPSqlite3:

• sqlite_rdb: type PPSqlite3

PPSqlite3_Backup:

• sqlite_rdb: type PPSqlite3_Backup

PQArgBlock:

• postgres_rdb: object PQArgBlock

pqbackendPID:

• postgres_rdb: proc pqbackendPID(conn: PPGconn): int32

pqbinaryTuples:

• postgres_rdb: proc pqbinaryTuples(res: PPGresult): int32

pqbool:

• postgres_rdb: type pqbool

pqCancel:

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

pqclear:

• postgres_rdb: proc pqclear(res: PPGresult)

pqclientEncoding:

• postgres_rdb: proc pqclientEncoding(conn: PPGconn): int32

pqcmdStatus:

• postgres_rdb: proc pqcmdStatus(res: PPGresult): cstring

pqcmdTuples:

• postgres_rdb: proc pqcmdTuples(res: PPGresult): cstring

pqconndefaults:

• postgres_rdb: proc pqconndefaults(): PPQconninfoOption

pqconnectdb:

• postgres_rdb: proc pqconnectdb(conninfo: cstring): PPGconn

pqconnectionNeedsPassword:

• postgres_rdb: proc pqconnectionNeedsPassword(conn: PPGconn): int32

pqconnectionUsedPassword:

• postgres_rdb: proc pqconnectionUsedPassword(conn: PPGconn): int32

pqconnectPoll:

• postgres_rdb: proc pqconnectPoll(conn: PPGconn): PostgresPollingStatusType

pqconnectStart:

• postgres_rdb: proc pqconnectStart(conninfo: cstring): PPGconn

pqconninfoFree:

• postgres_rdb: proc pqconninfoFree(connOptions: PPQconninfoOption)

PQconninfoOption:

• postgres_rdb: object PQconninfoOption

pqconsumeInput:

• postgres_rdb: proc pqconsumeInput(conn: PPGconn): int32

pqdb:

• postgres_rdb: proc pqdb(conn: PPGconn): cstring

pqdisplayTuples:

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

pqendcopy:

• postgres_rdb: proc pqendcopy(conn: PPGconn): int32

pqenv2encoding:

• postgres_rdb: proc pqenv2encoding(): int32

pqerrorMessage:

• postgres_rdb: proc pqerrorMessage(conn: PPGconn): cstring

PQERRORS_DEFAULT:

• postgres_rdb: PGVerbosity.PQERRORS_DEFAULT

PQERRORS_SQLSTATE:

• postgres_rdb: PGVerbosity.PQERRORS_SQLSTATE

PQERRORS_TERSE:

• postgres_rdb: PGVerbosity.PQERRORS_TERSE

PQERRORS_VERBOSE:

• postgres_rdb: PGVerbosity.PQERRORS_VERBOSE

pqescapeBytea:

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

pqescapeString:

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

pqexec:

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

pqexecParams:

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

pqexecPrepared:

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

pqfformat:

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

pqfinish:

• postgres_rdb: proc pqfinish(conn: PPGconn)

pqflush:

• postgres_rdb: proc pqflush(conn: PPGconn): int32

pqfmod:

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

pqfn:

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

pqfname:

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

pqfnumber:

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

pqFreeCancel:

• postgres_rdb: proc pqFreeCancel(cancel: PPGcancel)

pqfreemem:

• postgres_rdb: proc pqfreemem(p: pointer)

pqfsize:

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

pqftable:

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

pqftablecol:

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

pqftype:

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

pqGetCancel:

• postgres_rdb: proc pqGetCancel(conn: PPGconn): PPGcancel

pqgetCopyData:

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

pqgetisnull:

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

pqgetlength:

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

pqgetline:

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

pqgetlineAsync:

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

pqgetResult:

• postgres_rdb: proc pqgetResult(conn: PPGconn): PPGresult

pqgetvalue:

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

pqhost:

• postgres_rdb: proc pqhost(conn: PPGconn): cstring

pqinitOpenSSL:

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

pqisBusy:

• postgres_rdb: proc pqisBusy(conn: PPGconn): int32

pqisnonblocking:

• postgres_rdb: proc pqisnonblocking(conn: PPGconn): int32

pqmakeEmptyPGresult:

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

pqmblen:

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

pqnfields:

• postgres_rdb: proc pqnfields(res: PPGresult): int32

PQnoticeProcessor:

• postgres_rdb: type PQnoticeProcessor

PQnoticeReceiver:

• postgres_rdb: type PQnoticeReceiver

pqnotifies:

• postgres_rdb: proc pqnotifies(conn: PPGconn): PPGNotify

pqntuples:

• postgres_rdb: proc pqntuples(res: PPGresult): int32

pqoidStatus:

• postgres_rdb: proc pqoidStatus(res: PPGresult): cstring

pqoidValue:

• postgres_rdb: proc pqoidValue(res: PPGresult): Oid

pqoptions:

• postgres_rdb: proc pqoptions(conn: PPGconn): cstring

pqparameterStatus:

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

pqpass:

• postgres_rdb: proc pqpass(conn: PPGconn): cstring

pqport:

• postgres_rdb: proc pqport(conn: PPGconn): cstring

pqprepare:

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

pqprint:

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

PQprintOpt:

• postgres_rdb: object PQprintOpt

pqprintTuples:

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

pqprotocolVersion:

• postgres_rdb: proc pqprotocolVersion(conn: PPGconn): int32

pqputCopyData:

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

pqputCopyEnd:

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

pqputline:

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

pqputnbytes:

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

pqrequestCancel:

• postgres_rdb: proc pqrequestCancel(conn: PPGconn): int32

pqreset:

• postgres_rdb: proc pqreset(conn: PPGconn)

pqresetPoll:

• postgres_rdb: proc pqresetPoll(conn: PPGconn): PostgresPollingStatusType

pqresetStart:

• postgres_rdb: proc pqresetStart(conn: PPGconn): int32

pqresStatus:

• postgres_rdb: proc pqresStatus(status: ExecStatusType): cstring

pqresultErrorField:

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

pqresultErrorMessage:

• postgres_rdb: proc pqresultErrorMessage(res: PPGresult): cstring

pqresultStatus:

• postgres_rdb: proc pqresultStatus(res: PPGresult): ExecStatusType

pqsendPrepare:

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

pqsendQuery:

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

pqsendQueryParams:

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

pqsendQueryPrepared:

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

pqserverVersion:

• postgres_rdb: proc pqserverVersion(conn: PPGconn): int32

pqsetClientEncoding:

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

pqsetdb:

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

pqsetdbLogin:

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

pqsetErrorVerbosity:

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

pqsetnonblocking:

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

pqsetNoticeProcessor:

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

pqsetNoticeReceiver:

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

pqSetSingleRowMode:

• postgres_rdb: proc pqSetSingleRowMode(conn: PPGconn): int32

pqsocket:

• postgres_rdb: proc pqsocket(conn: PPGconn): int32

pqstatus:

• postgres_rdb: proc pqstatus(conn: PPGconn): ConnStatusType

pqtrace:

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

pqtransactionStatus:

• postgres_rdb: proc pqtransactionStatus(conn: PPGconn): PGTransactionStatusType

PQTRANS_ACTIVE:

• postgres_rdb: PGTransactionStatusType.PQTRANS_ACTIVE

PQTRANS_IDLE:

• postgres_rdb: PGTransactionStatusType.PQTRANS_IDLE

PQTRANS_INERROR:

• postgres_rdb: PGTransactionStatusType.PQTRANS_INERROR

PQTRANS_INTRANS:

• postgres_rdb: PGTransactionStatusType.PQTRANS_INTRANS

PQTRANS_UNKNOWN:

• postgres_rdb: PGTransactionStatusType.PQTRANS_UNKNOWN

pqtty:

• postgres_rdb: proc pqtty(conn: PPGconn): cstring

pqunescapeBytea:

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

pquntrace:

• postgres_rdb: proc pquntrace(conn: PPGconn)

pquser:

• postgres_rdb: proc pquser(conn: PPGconn): cstring

prepare:

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

prepare16:

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

preparedExec:

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

preparedQuery:

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

prepare_v2:

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

PRES:

• mariadb_rdb: type PRES
• mysql_rdb: type PRES

PRI_KEY_FLAG:

• mariadb_rdb: const PRI_KEY_FLAG
• mysql_rdb: const PRI_KEY_FLAG

progress_handler:

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

PROWS:

• mariadb_rdb: type PROWS
• mysql_rdb: type PROWS

PSqlite3:

• sqlite_rdb: type PSqlite3

PSqlite3_Backup:

• sqlite_rdb: type PSqlite3_Backup

Pst_dynamic_array:

• mariadb_rdb: type Pst_dynamic_array
• mysql_rdb: type Pst_dynamic_array

PSTMT:

• mariadb_rdb: type PSTMT
• mysql_rdb: type PSTMT

PStmt:

• sqlite_rdb: type PStmt

Pst_mysql:

• mariadb_rdb: type Pst_mysql
• mysql_rdb: type Pst_mysql

Pst_mysql_methods:

• mariadb_rdb: type Pst_mysql_methods
• mysql_rdb: type Pst_mysql_methods

Pst_mysql_rows:

• mariadb_rdb: type Pst_mysql_rows
• mysql_rdb: type Pst_mysql_rows

Pst_mysql_stmt:

• mariadb_rdb: type Pst_mysql_stmt
• mysql_rdb: type Pst_mysql_stmt

Pst_used_mem:

• mariadb_rdb: type Pst_used_mem
• mysql_rdb: type Pst_used_mem

PUSED_MEM:

• mariadb_rdb: type PUSED_MEM
• mysql_rdb: type PUSED_MEM

PValue:

• sqlite_rdb: type PValue

PValueArg:

• sqlite_rdb: type PValueArg

PVIO:

• mariadb_rdb: type PVIO
• mysql_rdb: type PVIO

query:

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

queryPlain:

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

questionToDaller:

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

quote:

• surreal_generator: proc quote(input: string): string

raw:

• mariadb_query: proc raw(self: MariadbConnections; sql: string; arges = newJArray()): RawMariadbQuery
• mysql_query: proc raw(self: MysqlConnections; sql: string; arges = newJArray()): RawMysqlQuery
• postgres_query: proc raw(self: PostgresConnections; sql: string; arges = newJArray()): RawPostgresQuery
• sqlite_query: proc raw(self: SqliteConnections; sql: string; arges = newJArray()): RawSqliteQuery
• surreal_query: proc raw(self: SurrealConnections; sql: string; arges = newJArray()): RawSurrealQuery

rawExec:

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

rawId:

• surreal_types: proc rawId(self: SurrealId): string

RawMariadbQuery:

• mariadb_types: type RawMariadbQuery

RawMysqlQuery:

• mysql_types: type RawMysqlQuery

RawPostgresQuery:

• postgres_types: type RawPostgresQuery

rawQuery:

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

RawSqliteQuery:

• sqlite_types: type RawSqliteQuery

RawSurrealQuery:

• surreal_types: type RawSurrealQuery

rdbBigInteger:

• enums: RdbTypeKind.rdbBigInteger

rdbBinary:

• enums: RdbTypeKind.rdbBinary

rdbBoolean:

• enums: RdbTypeKind.rdbBoolean

rdbChar:

• enums: RdbTypeKind.rdbChar

rdbDate:

• enums: RdbTypeKind.rdbDate

rdbDatetime:

• enums: RdbTypeKind.rdbDatetime

rdbDecimal:

• enums: RdbTypeKind.rdbDecimal

rdbDouble:

• enums: RdbTypeKind.rdbDouble

rdbEnumField:

• enums: RdbTypeKind.rdbEnumField

rdbFloat:

• enums: RdbTypeKind.rdbFloat

rdbForeign:

• enums: RdbTypeKind.rdbForeign

rdbIncrements:

• enums: RdbTypeKind.rdbIncrements

rdbInteger:

• enums: RdbTypeKind.rdbInteger

rdbJson:

• enums: RdbTypeKind.rdbJson

rdbLongText:

• enums: RdbTypeKind.rdbLongText

rdbMediumInteger:

• enums: RdbTypeKind.rdbMediumInteger

rdbMediumText:

• enums: RdbTypeKind.rdbMediumText

rdbSmallInteger:

• enums: RdbTypeKind.rdbSmallInteger

rdbSoftDelete:

• enums: RdbTypeKind.rdbSoftDelete

rdbStrForeign:

• enums: RdbTypeKind.rdbStrForeign

rdbString:

• enums: RdbTypeKind.rdbString

rdbText:

• enums: RdbTypeKind.rdbText

rdbTime:

• enums: RdbTypeKind.rdbTime

rdbTimestamp:

• enums: RdbTypeKind.rdbTimestamp

rdbTimestamps:

• enums: RdbTypeKind.rdbTimestamps

RdbTypeKind:

• enums: enum RdbTypeKind

rdbUuid:

• enums: RdbTypeKind.rdbUuid

ReadDbEffect:

• database_types: object ReadDbEffect

READ_DEFAULT_FILE:

• mariadb_rdb: Option.READ_DEFAULT_FILE
• mysql_rdb: Option.READ_DEFAULT_FILE

READ_DEFAULT_GROUP:

• mariadb_rdb: Option.READ_DEFAULT_GROUP
• mysql_rdb: Option.READ_DEFAULT_GROUP

read_query_result:

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

read_query_result_cont:

• mariadb_rdb: proc read_query_result_cont(ret: ptr my_bool; MySQL: PMySQL; status: cint): cint

read_query_result_start:

• mariadb_rdb: proc read_query_result_start(ret: ptr my_bool; MySQL: PMySQL): cint

real_connect:

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

real_connect_cont:

• mariadb_rdb: proc real_connect_cont(ret: ptr PMySQL; MySQL: PMySQL; status: cint): cint

real_connect_start:

• mariadb_rdb: proc 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: proc real_escape_string(MySQL: PMySQL; fto: cstring; from: cstring; len: int): int
• mysql_rdb: proc real_escape_string(MySQL: PMySQL; fto: cstring; from: cstring; len: int): int

real_query:

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

real_query_cont:

• mariadb_rdb: proc real_query_cont(ret: ptr cint; MySQL: PMySQL; status: cint): cint

real_query_start:

• mariadb_rdb: proc real_query_start(ret: ptr cint; MySQL: PMySQL; q: cstring; len: culong): cint

reference:

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

RenameColumn:

• enums: ColumnMigrationType.RenameColumn

renameColumn:

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

RenameTable:

• enums: TableMigrationType.RenameTable

renameTable:

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

renameTo:

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

REPORT_DATA_TRUNCATION:

• mariadb_rdb: Option.REPORT_DATA_TRUNCATION
• mysql_rdb: Option.REPORT_DATA_TRUNCATION

requireDatabaseUrlScheme:

• database_url: proc requireDatabaseUrlScheme(value: ParsedDatabaseUrl; expectedSchemes: openArray[string]; driverName: string)

RES:

• mariadb_rdb: type RES
• mysql_rdb: type RES

reset:

• sqlite_rdb: proc reset(PStmt: PStmt): int32

resetMigrationTable:

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

resetSequence:

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

resetTable:

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

RESTRICT:

• enums: ForeignOnDelete.RESTRICT

result_blob:

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

result_double:

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

result_error:

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

result_error16:

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

Result_func:

• sqlite_rdb: type Result_func

result_int:

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

result_int64:

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

result_null:

• sqlite_rdb: proc result_null(para1: Pcontext)

result_text:

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

result_text16:

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

result_text16be:

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

result_text16le:

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

result_value:

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

rollback:

• mariadb_exec: proc rollback(self: MariadbConnections): owned(Future[void])
• mysql_exec: proc rollback(self: MysqlConnections): owned(Future[void])
• postgres_exec: proc rollback(self: PostgresConnections): owned(Future[void])
• sqlite_exec: proc rollback(self: SqliteConnections): owned(Future[void])

ROW:

• mariadb_rdb: type ROW
• mysql_rdb: type ROW

Row:

• database_types: type Row

ROWS:

• mariadb_rdb: type ROWS
• mysql_rdb: type ROWS

SCRAMBLE_LENGTH:

• mariadb_rdb: const SCRAMBLE_LENGTH
• mysql_rdb: const SCRAMBLE_LENGTH

SECURE_AUTH:

• mariadb_rdb: Option.SECURE_AUTH
• mysql_rdb: Option.SECURE_AUTH

seeder:

• mariadb_exec: template seeder(rdb: MariadbConnections; tableName, column: string; body: untyped): untyped
• mariadb_exec: template seeder(rdb: MariadbConnections; tableName: string; body: untyped): untyped
• mysql_exec: template seeder(rdb: MysqlConnections; tableName, column: string; body: untyped): untyped
• mysql_exec: template seeder(rdb: MysqlConnections; tableName: string; body: untyped): untyped
• postgres_exec: template seeder(rdb: PostgresConnections; tableName, column: string; body: untyped): untyped
• postgres_exec: template seeder(rdb: PostgresConnections; tableName: string; body: untyped): untyped
• sqlite_exec: template seeder(rdb: SqliteConnections; tableName, column: string; body: untyped): untyped
• sqlite_exec: template seeder(rdb: SqliteConnections; tableName: string; body: untyped): untyped
• surreal_exec: template seeder(rdb: SurrealConnections; tableName, column: string; body: untyped): untyped
• surreal_exec: template seeder(rdb: SurrealConnections; tableName: string; body: untyped): untyped

select:

• mariadb_query: proc select(self: MariadbConnections; columnsArg: varargs[string]): MariadbQuery
• mysql_query: proc select(self: MysqlConnections; columnsArg: varargs[string]): MysqlQuery
• postgres_query: proc select(self: PostgresConnections; columnsArg: varargs[string]): PostgresQuery
• sqlite_query: proc select(self: SqliteConnections; columnsArg: varargs[string]): SqliteQuery
• surreal_query: proc select(self: SurrealConnections; columnsArg: varargs[string]): SurrealQuery

selectAvgBuilder:

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

selectAvgSql:

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

selectBuilder:

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

selectByIdSql:

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

selectCountSql:

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

selectFindBuilder:

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

selectFirstBuilder:

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

selectFirstSql:

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

selectMaxSql:

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

selectMinSql:

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

selectSql:

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

selectSumBuilder:

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

selectSumSql:

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

set_authorizer:

• sqlite_rdb: proc 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: proc set_auxdata(para1: Pcontext; para2: int32; para3: pointer; para4: proc (para1: pointer) {.cdecl.})

SET_CHARSET_DIR:

• mariadb_rdb: Option.SET_CHARSET_DIR
• mysql_rdb: Option.SET_CHARSET_DIR

SET_CHARSET_NAME:

• mariadb_rdb: Option.SET_CHARSET_NAME
• mysql_rdb: Option.SET_CHARSET_NAME

SET_CLIENT_IP:

• mariadb_rdb: Option.SET_CLIENT_IP
• mysql_rdb: Option.SET_CLIENT_IP

setColumnInfo:

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

SET_NULL:

• enums: ForeignOnDelete.SET_NULL

setRow:

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

SHARED_MEMORY_BASE_NAME:

• mariadb_rdb: Option.SHARED_MEMORY_BASE_NAME
• mysql_rdb: Option.SHARED_MEMORY_BASE_NAME

shouldRun:

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

smallInteger:

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

smallName:

• table: proc smallName(self: Table): string

snakeToCamel:

• snake_to_camel: proc snakeToCamel(s: string): string

snprintf:

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

SockAddr:

• postgres_rdb: type SockAddr

softDelete:

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

SQLite3:

• sqlite_types: object SQLite3

sqlite3_sleep:

• sqlite_rdb: proc sqlite3_sleep(t: int64): int64

SQLITE_ABORT:

• sqlite_rdb: const SQLITE_ABORT

SQLITE_ALTER_TABLE:

• sqlite_rdb: const SQLITE_ALTER_TABLE

SQLITE_ANY:

• sqlite_rdb: const SQLITE_ANY

SQLITE_ATTACH:

• sqlite_rdb: const SQLITE_ATTACH

SQLITE_AUTH:

• sqlite_rdb: const SQLITE_AUTH

SQLITE_BLOB:

• sqlite_rdb: const SQLITE_BLOB

SQLITE_BUSY:

• sqlite_rdb: const SQLITE_BUSY

SQLITE_CANTOPEN:

• sqlite_rdb: const SQLITE_CANTOPEN

SqliteConnections:

• sqlite_types: type SqliteConnections

SQLITE_CONSTRAINT:

• sqlite_rdb: const SQLITE_CONSTRAINT

SQLITE_COPY:

• sqlite_rdb: const SQLITE_COPY

SQLITE_CORRUPT:

• sqlite_rdb: const SQLITE_CORRUPT

SQLITE_CREATE_INDEX:

• sqlite_rdb: const SQLITE_CREATE_INDEX

SQLITE_CREATE_TABLE:

• sqlite_rdb: const SQLITE_CREATE_TABLE

SQLITE_CREATE_TEMP_INDEX:

• sqlite_rdb: const SQLITE_CREATE_TEMP_INDEX

SQLITE_CREATE_TEMP_TABLE:

• sqlite_rdb: const SQLITE_CREATE_TEMP_TABLE

SQLITE_CREATE_TEMP_TRIGGER:

• sqlite_rdb: const SQLITE_CREATE_TEMP_TRIGGER

SQLITE_CREATE_TEMP_VIEW:

• sqlite_rdb: const SQLITE_CREATE_TEMP_VIEW

SQLITE_CREATE_TRIGGER:

• sqlite_rdb: const SQLITE_CREATE_TRIGGER

SQLITE_CREATE_VIEW:

• sqlite_rdb: const SQLITE_CREATE_VIEW

sqliteDatabasePath:

• database_url: proc sqliteDatabasePath(value: ParsedDatabaseUrl): string

SQLITE_DELETE:

• sqlite_rdb: const SQLITE_DELETE

SQLITE_DENY:

• sqlite_rdb: const SQLITE_DENY

SQLITE_DETACH:

• sqlite_rdb: const SQLITE_DETACH

SQLITE_DETERMINISTIC:

• sqlite_rdb: const SQLITE_DETERMINISTIC

SQLITE_DONE:

• sqlite_rdb: const SQLITE_DONE

SQLITE_DROP_INDEX:

• sqlite_rdb: const SQLITE_DROP_INDEX

SQLITE_DROP_TABLE:

• sqlite_rdb: const SQLITE_DROP_TABLE

SQLITE_DROP_TEMP_INDEX:

• sqlite_rdb: const SQLITE_DROP_TEMP_INDEX

SQLITE_DROP_TEMP_TABLE:

• sqlite_rdb: const SQLITE_DROP_TEMP_TABLE

SQLITE_DROP_TEMP_TRIGGER:

• sqlite_rdb: const SQLITE_DROP_TEMP_TRIGGER

SQLITE_DROP_TEMP_VIEW:

• sqlite_rdb: const SQLITE_DROP_TEMP_VIEW

SQLITE_DROP_TRIGGER:

• sqlite_rdb: const SQLITE_DROP_TRIGGER

SQLITE_DROP_VIEW:

• sqlite_rdb: const SQLITE_DROP_VIEW

SQLITE_EMPTY:

• sqlite_rdb: const SQLITE_EMPTY

SQLITE_ERROR:

• sqlite_rdb: const SQLITE_ERROR

SQLITE_FLOAT:

• sqlite_rdb: const SQLITE_FLOAT

SQLITE_FORMAT:

• sqlite_rdb: const SQLITE_FORMAT

SQLITE_FULL:

• sqlite_rdb: const SQLITE_FULL

SQLITE_IGNORE:

• sqlite_rdb: const SQLITE_IGNORE

SQLITE_INSERT:

• sqlite_rdb: const SQLITE_INSERT

SQLITE_INTEGER:

• sqlite_rdb: const SQLITE_INTEGER

SQLITE_INTERNAL:

• sqlite_rdb: const SQLITE_INTERNAL

SQLITE_INTERRUPT:

• sqlite_rdb: const SQLITE_INTERRUPT

SQLITE_IOERR:

• sqlite_rdb: const SQLITE_IOERR

sqliteLengthCheck:

• schema_utils: proc sqliteLengthCheck(column: Column; maxLength: int): string

SQLITE_LOCKED:

• sqlite_rdb: const SQLITE_LOCKED

SQLITE_MISMATCH:

• sqlite_rdb: const SQLITE_MISMATCH

SQLITE_MISUSE:

• sqlite_rdb: const SQLITE_MISUSE

SQLITE_NOLFS:

• sqlite_rdb: const SQLITE_NOLFS

SQLITE_NOMEM:

• sqlite_rdb: const SQLITE_NOMEM

SQLITE_NOTADB:

• sqlite_rdb: const SQLITE_NOTADB

SQLITE_NOTFOUND:

• sqlite_rdb: const SQLITE_NOTFOUND

SQLITE_NULL:

• sqlite_rdb: const SQLITE_NULL

SQLITE_OK:

• sqlite_rdb: const SQLITE_OK

SQLITE_PERM:

• sqlite_rdb: const SQLITE_PERM

SQLITE_PRAGMA:

• sqlite_rdb: const SQLITE_PRAGMA

SQLITE_PROTOCOL:

• sqlite_rdb: const SQLITE_PROTOCOL

SqliteQuery:

• sqlite_types: type SqliteQuery

sqliteQuoteIdent:

• sqlite_lib: proc sqliteQuoteIdent(name: string): string

SQLITE_RANGE:

• sqlite_rdb: const SQLITE_RANGE

SQLITE_READ:

• sqlite_rdb: const SQLITE_READ

SQLITE_READONLY:

• sqlite_rdb: const SQLITE_READONLY

SQLITE_REINDEX:

• sqlite_rdb: const SQLITE_REINDEX

SQLITE_ROW:

• sqlite_rdb: const SQLITE_ROW

SQLITE_SCHEMA:

• sqlite_rdb: const SQLITE_SCHEMA

SqliteSchema:

• sqlite_query_type: type SqliteSchema

SQLITE_SELECT:

• sqlite_rdb: const SQLITE_SELECT

SQLITE_STATIC:

• sqlite_rdb: const SQLITE_STATIC

SQLITE_TEXT:

• sqlite_rdb: const SQLITE_TEXT

SQLITE_TOOBIG:

• sqlite_rdb: const SQLITE_TOOBIG

SQLITE_TRANSACTION:

• sqlite_rdb: const SQLITE_TRANSACTION

SQLITE_TRANSIENT:

• sqlite_rdb: const SQLITE_TRANSIENT

SQLITE_UPDATE:

• sqlite_rdb: const SQLITE_UPDATE

SQLITE_UTF16:

• sqlite_rdb: const SQLITE_UTF16

SQLITE_UTF16BE:

• sqlite_rdb: const SQLITE_UTF16BE

SQLITE_UTF16LE:

• sqlite_rdb: const SQLITE_UTF16LE

SQLITE_UTF8:

• sqlite_rdb: const SQLITE_UTF8

SQLSTATE_LENGTH:

• mariadb_rdb: const SQLSTATE_LENGTH
• mysql_rdb: const SQLSTATE_LENGTH

start:

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

startSql:

• surreal_generator: proc startSql(self: SurrealQuery): SurrealQuery

Status:

• mariadb_rdb: enum Status
• mysql_rdb: enum Status

STATUS_GET_RESULT:

• mariadb_rdb: Status.STATUS_GET_RESULT
• mysql_rdb: Status.STATUS_GET_RESULT

STATUS_READY:

• mariadb_rdb: Status.STATUS_READY
• mysql_rdb: Status.STATUS_READY

STATUS_USE_RESULT:

• mariadb_rdb: Status.STATUS_USE_RESULT
• mysql_rdb: Status.STATUS_USE_RESULT

St_dynamic_array:

• mariadb_rdb: object St_dynamic_array
• mysql_rdb: object St_dynamic_array

step:

• sqlite_rdb: proc step(para1: PStmt): int32

St_mem_root:

• mariadb_rdb: object St_mem_root
• mysql_rdb: object St_mem_root

STMT:

• mariadb_rdb: type STMT
• mysql_rdb: type STMT

STMT_EXECUTE_DONE:

• mariadb_rdb: Enum_mysql_stmt_state.STMT_EXECUTE_DONE
• mysql_rdb: Enum_mysql_stmt_state.STMT_EXECUTE_DONE

STMT_FETCH_DONE:

• mariadb_rdb: Enum_mysql_stmt_state.STMT_FETCH_DONE
• mysql_rdb: Enum_mysql_stmt_state.STMT_FETCH_DONE

stmt_init:

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

STMT_INIT_DONE:

• mariadb_rdb: Enum_mysql_stmt_state.STMT_INIT_DONE
• mysql_rdb: Enum_mysql_stmt_state.STMT_INIT_DONE

STMT_PREPARE_DONE:

• mariadb_rdb: Enum_mysql_stmt_state.STMT_PREPARE_DONE
• mysql_rdb: Enum_mysql_stmt_state.STMT_PREPARE_DONE

St_mysql:

• mariadb_rdb: object St_mysql
• mysql_rdb: object St_mysql

St_mysql_bind:

• mariadb_rdb: object St_mysql_bind
• mysql_rdb: object St_mysql_bind

St_mysql_data:

• mariadb_rdb: object St_mysql_data
• mysql_rdb: object St_mysql_data

St_mysql_field:

• mariadb_rdb: object St_mysql_field
• mysql_rdb: object St_mysql_field

St_mysql_methods:

• mariadb_rdb: object St_mysql_methods
• mysql_rdb: object St_mysql_methods

St_mysql_options:

• mariadb_rdb: object St_mysql_options
• mysql_rdb: object St_mysql_options

St_mysql_res:

• mariadb_rdb: object St_mysql_res
• mysql_rdb: object St_mysql_res

St_mysql_rows:

• mariadb_rdb: object St_mysql_rows
• mysql_rdb: object St_mysql_rows

St_mysql_stmt:

• mariadb_rdb: object St_mysql_stmt
• mysql_rdb: object St_mysql_stmt

St_net:

• mariadb_rdb: object St_net
• mysql_rdb: object St_net

store_result_cont:

• mariadb_rdb: proc store_result_cont(ret: ptr PRES; MySQL: PMySQL; status: cint): cint

store_result_start:

• mariadb_rdb: proc store_result_start(ret: ptr PRES; MySQL: PMySQL): cint

strForeign:

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

string:

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

St_used_mem:

• mariadb_rdb: object St_used_mem
• mysql_rdb: object St_used_mem

sum:

• mariadb_exec: proc sum(self: MariadbQuery; column: string): Future[Option[float]]
• mysql_exec: proc sum(self: MysqlQuery; column: string): Future[Option[float]]
• postgres_exec: proc sum(self: PostgresQuery; column: string): Future[Option[float]]
• sqlite_exec: proc sum(self: SqliteQuery; column: string): Future[Option[float]]
• surreal_exec: proc sum(self: SurrealQuery; column: string): Future[float]

sumBuilder:

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

SurrealConn:

• surreal_rdb: object SurrealConn

SurrealConnections:

• surreal_types: type SurrealConnections

SurrealDB:

• surreal_types: object SurrealDB

SurrealId:

• surreal_types: object SurrealId

SurrealImpl:

• surreal_impl: type SurrealImpl

SurrealQuery:

• surreal_types: type SurrealQuery

SurrealSchema:

• surreal_query_type: type SurrealSchema

table:

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

Table:

• table: type Table

table:

• table: proc table(name: string): Table
• table: proc table(name: string; columns: openArray[Column]; comment = ""): Table
• table: proc table(name: string; columns: seq[Column]; primary: seq[string] = @[]; comment = ""): Table

TableMigrationType:

• enums: enum TableMigrationType

Tbind_destructor_func:

• sqlite_rdb: type Tbind_destructor_func

text:

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

time:

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

timestamp:

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

timestamps:

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

toSchema:

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

total_changes:

• sqlite_rdb: proc total_changes(para1: PSqlite3): int32

trace:

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

transaction:

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

true:

• mariadb_rdb: my_bool.true
• mysql_rdb: my_bool.true

TYPE_BIT:

• mariadb_rdb: Enum_field_types.TYPE_BIT
• mysql_rdb: Enum_field_types.TYPE_BIT

TYPE_BLOB:

• mariadb_rdb: Enum_field_types.TYPE_BLOB
• mysql_rdb: Enum_field_types.TYPE_BLOB

TYPE_DATE:

• mariadb_rdb: Enum_field_types.TYPE_DATE
• mysql_rdb: Enum_field_types.TYPE_DATE

TYPE_DATETIME:

• mariadb_rdb: Enum_field_types.TYPE_DATETIME
• mysql_rdb: Enum_field_types.TYPE_DATETIME

TYPE_DECIMAL:

• mariadb_rdb: Enum_field_types.TYPE_DECIMAL
• mysql_rdb: Enum_field_types.TYPE_DECIMAL

TYPE_DOUBLE:

• mariadb_rdb: Enum_field_types.TYPE_DOUBLE
• mysql_rdb: Enum_field_types.TYPE_DOUBLE

TYPE_ENUM:

• mariadb_rdb: Enum_field_types.TYPE_ENUM
• mysql_rdb: Enum_field_types.TYPE_ENUM

TYPE_FLOAT:

• mariadb_rdb: Enum_field_types.TYPE_FLOAT
• mysql_rdb: Enum_field_types.TYPE_FLOAT

TYPE_GEOMETRY:

• mariadb_rdb: Enum_field_types.TYPE_GEOMETRY
• mysql_rdb: Enum_field_types.TYPE_GEOMETRY

TYPE_INT24:

• mariadb_rdb: Enum_field_types.TYPE_INT24
• mysql_rdb: Enum_field_types.TYPE_INT24

TYPE_LONG:

• mariadb_rdb: Enum_field_types.TYPE_LONG
• mysql_rdb: Enum_field_types.TYPE_LONG

TYPE_LONG_BLOB:

• mariadb_rdb: Enum_field_types.TYPE_LONG_BLOB
• mysql_rdb: Enum_field_types.TYPE_LONG_BLOB

TYPE_LONGLONG:

• mariadb_rdb: Enum_field_types.TYPE_LONGLONG
• mysql_rdb: Enum_field_types.TYPE_LONGLONG

TYPE_MEDIUM_BLOB:

• mariadb_rdb: Enum_field_types.TYPE_MEDIUM_BLOB
• mysql_rdb: Enum_field_types.TYPE_MEDIUM_BLOB

TYPE_NEWDATE:

• mariadb_rdb: Enum_field_types.TYPE_NEWDATE
• mysql_rdb: Enum_field_types.TYPE_NEWDATE

TYPE_NEWDECIMAL:

• mariadb_rdb: Enum_field_types.TYPE_NEWDECIMAL
• mysql_rdb: Enum_field_types.TYPE_NEWDECIMAL

TYPE_NULL:

• mariadb_rdb: Enum_field_types.TYPE_NULL
• mysql_rdb: Enum_field_types.TYPE_NULL

TYPE_SET:

• mariadb_rdb: Enum_field_types.TYPE_SET
• mysql_rdb: Enum_field_types.TYPE_SET

TYPE_SHORT:

• mariadb_rdb: Enum_field_types.TYPE_SHORT
• mysql_rdb: Enum_field_types.TYPE_SHORT

TYPE_STRING:

• mariadb_rdb: Enum_field_types.TYPE_STRING
• mysql_rdb: Enum_field_types.TYPE_STRING

TYPE_TIME:

• mariadb_rdb: Enum_field_types.TYPE_TIME
• mysql_rdb: Enum_field_types.TYPE_TIME

TYPE_TIMESTAMP:

• mariadb_rdb: Enum_field_types.TYPE_TIMESTAMP
• mysql_rdb: Enum_field_types.TYPE_TIMESTAMP

TYPE_TINY:

• mariadb_rdb: Enum_field_types.TYPE_TINY
• mysql_rdb: Enum_field_types.TYPE_TINY

TYPE_TINY_BLOB:

• mariadb_rdb: Enum_field_types.TYPE_TINY_BLOB
• mysql_rdb: Enum_field_types.TYPE_TINY_BLOB

TYPE_VARCHAR:

• mariadb_rdb: Enum_field_types.TYPE_VARCHAR
• mysql_rdb: Enum_field_types.TYPE_VARCHAR

TYPE_VAR_STRING:

• mariadb_rdb: Enum_field_types.TYPE_VAR_STRING
• mysql_rdb: Enum_field_types.TYPE_VAR_STRING

TYPE_YEAR:

• mariadb_rdb: Enum_field_types.TYPE_YEAR
• mysql_rdb: Enum_field_types.TYPE_YEAR

U:

• mariadb_rdb: object U
• mysql_rdb: object U

unique:

• column: proc unique(c: Column): Column

unsigned:

• column: proc unsigned(c: Column): Column

update:

• mariadb_exec: proc update(self: MariadbQuery; items: JsonNode): owned(Future[void])
• mariadb_exec: proc update[T](self: MariadbQuery; items: T): owned(Future[void])
• mysql_exec: proc update(self: MysqlQuery; items: JsonNode): owned(Future[void])
• mysql_exec: proc update[T](self: MysqlQuery; items: T): owned(Future[void])
• postgres_exec: proc update(self: PostgresQuery; items: JsonNode): owned(Future[void])
• postgres_exec: proc update[T](self: PostgresQuery; items: T): owned(Future[void])
• sqlite_exec: proc update(self: SqliteQuery; items: JsonNode): owned(Future[void])
• sqlite_exec: proc update[T](self: SqliteQuery; items: T): owned(Future[void])
• surreal_exec: proc update(self: SurrealConnections; id: SurrealId; items: JsonNode): owned( Future[void])
• surreal_exec: proc update[T](self: SurrealConnections; id: SurrealId; items: T): owned( Future[void])
• surreal_exec: proc update(self: SurrealQuery; items: JsonNode): owned(Future[void])
• surreal_exec: proc update[T](self: SurrealQuery; items: T): owned(Future[void])

updateBuilder:

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

updateMergeBuilder:

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

updateMergeSql:

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

updateSql:

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

updateValuesSql:

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

UsecaseType:

• enums: enum UsecaseType

USED_MEM:

• mariadb_rdb: type USED_MEM
• mysql_rdb: type USED_MEM

user_data:

• sqlite_rdb: proc user_data(para1: Pcontext): pointer

use_result:

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

uuid:

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

value_blob:

• sqlite_rdb: proc value_blob(para1: PValue): pointer

value_bytes:

• sqlite_rdb: proc value_bytes(para1: PValue): int32

value_bytes16:

• sqlite_rdb: proc value_bytes16(para1: PValue): int32

value_double:

• sqlite_rdb: proc value_double(para1: PValue): float64

value_int:

• sqlite_rdb: proc value_int(para1: PValue): int32

value_int64:

• sqlite_rdb: proc value_int64(para1: PValue): int64

value_text:

• sqlite_rdb: proc value_text(para1: PValue): cstring

value_text16:

• sqlite_rdb: proc value_text16(para1: PValue): pointer

value_text16be:

• sqlite_rdb: proc value_text16be(para1: PValue): pointer

value_text16le:

• sqlite_rdb: proc value_text16le(para1: PValue): pointer

value_type:

• sqlite_rdb: proc value_type(para1: PValue): int32

version:

• sqlite_rdb: proc version(): cstring

where:

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

whereBetween:

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

whereBetweenSql:

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

whereBetweenStringSql:

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

whereIn:

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

whereInSql:

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

whereNotBetween:

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

whereNotBetweenSql:

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

whereNotBetweenStringSql:

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

whereNotIn:

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

whereNotInSql:

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

whereNull:

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

whereNullSql:

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

whereSql:

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

WriteDbEffect:

• database_types: object WriteDbEffect