1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219/* HTML to rich text converter for libwww
**
** THE HTML TO RTF OBJECT CONVERTER
**
** This interprets the HTML semantics.
*/
#ifndef HTML_H
#define HTML_H
#ifdef EXP_CHARTRANS
#include "UCDefs.h"
#include "UCAux.h"
#endif
#ifndef HTUTILS_H
#include "HTUtils.h"
#endif /* HTUTILS_H */
#include "HTAnchor.h"
#include "HTMLDTD.h"
#ifdef SHORT_NAMES
#define HTMLPresentation HTMLPren
#define HTMLPresent HTMLPres
#endif /* SHORT_NAMES */
extern CONST HTStructuredClass HTMLPresentation;
#ifdef Lynx_HTML_Handler
/*
** This section is semi-private to HTML.c and it's helper modules. - FM
** --------------------------------------------------------------------
*/
typedef struct _stack_element {
HTStyle * style;
int tag_number;
} stack_element;
/* HTML Object
** -----------
*/
#define MAX_NESTING 800 /* Should be checked by parser */
struct _HTStructured {
CONST HTStructuredClass * isa;
HTParentAnchor * node_anchor;
HText * text;
HTStream* target; /* Output stream */
HTStreamClass targetClass; /* Output routines */
HTChildAnchor * CurrentA; /* current HTML_A anchor */
int CurrentANum; /* current HTML_A number */
char * base_href; /* current HTML_BASE href */
char * map_address; /* current HTML_MAP address */
HTChunk title; /* Grow by 128 */
HTChunk object; /* Grow by 128 */
BOOL object_started;
BOOL object_declare;
BOOL object_shapes;
BOOL object_ismap;
char * object_usemap;
char * object_id;
char * object_title;
char * object_data;
char * object_type;
char * object_classid;
char * object_codebase;
char * object_codetype;
char * object_name;
HTChunk option; /* Grow by 128 */
BOOL first_option; /* First OPTION in SELECT? */
char * LastOptionValue;
BOOL LastOptionChecked;
BOOL select_disabled;
HTChunk textarea; /* Grow by 128 */
char * textarea_name;
char * textarea_cols;
int textarea_rows;
int textarea_disabled;
char * textarea_id;
HTChunk math; /* Grow by 128 */
HTChunk style_block; /* Grow by 128 */
HTChunk script; /* Grow by 128 */
/*
* Used for nested lists. - FM
*/
int List_Nesting_Level; /* counter for list nesting level */
int OL_Counter[12]; /* counter for ordered lists */
char OL_Type[12]; /* types for ordered lists */
int Last_OL_Count; /* last count in ordered lists */
char Last_OL_Type; /* last type in ordered lists */
int Division_Level;
short DivisionAlignments[MAX_NESTING];
int Underline_Level;
int Quote_Level;
BOOL UsePlainSpace;
BOOL HiddenValue;
int lastraw;
char * comment_start; /* for literate programming */
char * comment_end;
HTTag * current_tag;
BOOL style_change;
HTStyle * new_style;
HTStyle * old_style;
int current_default_alignment;
BOOL in_word; /* Have just had a non-white char */
stack_element stack[MAX_NESTING];
stack_element *sp; /* Style stack pointer */
BOOL stack_overrun; /* Was MAX_NESTING exceeded? */
int skip_stack; /* flag to skip next style stack operation */
/*
** Track if we are in an anchor, paragraph, address, base, etc.
*/
BOOL inA;
BOOL inAPPLET;
BOOL inAPPLETwithP;
BOOL inBadBASE;
BOOL inBadHREF;
BOOL inBadHTML;
BOOL inBASE;
BOOL inBoldA;
BOOL inBoldH;
BOOL inCAPTION;
BOOL inCREDIT;
BOOL inFIG;
BOOL inFIGwithP;
BOOL inFONT;
BOOL inFORM;
BOOL inLABEL;
BOOL inP;
BOOL inPRE;
BOOL inSELECT;
BOOL inTABLE;
BOOL inTEXTAREA;
BOOL inUnderline;
BOOL needBoldH;
#ifdef EXP_CHARTRANS
LYUCcharset * UCI; /* pointer to node_anchor's UCInfo */
int UCLYhndl; /* tells us what charset we are fed */
UCTransParams T;
#endif
};
struct _HTStream {
CONST HTStreamClass * isa;
/* .... */
};
/*
* Semi-Private functions. - FM
*/
extern void HTML_put_character PARAMS((HTStructured *me, char c));
extern void HTML_put_string PARAMS((HTStructured *me, CONST char *s));
extern void HTML_write PARAMS((HTStructured *me, CONST char *s, int l));
extern int HTML_put_entity PARAMS((HTStructured *me, int entity_number));
#endif /* Lynx_HTML_Handler */
extern void strtolower PARAMS((char* i));
/* P U B L I C
*/
/*
** HTConverter to present HTML
*/
extern HTStream* HTMLToPlain PARAMS((
HTPresentation * pres,
HTParentAnchor * anchor,
HTStream * sink));
extern HTStream* HTMLToC PARAMS((
HTPresentation * pres,
HTParentAnchor * anchor,
HTStream * sink));
extern HTStream* HTMLPresent PARAMS((
HTPresentation * pres,
HTParentAnchor * anchor,
HTStream * sink));
extern HTStructured* HTML_new PARAMS((
HTParentAnchor * anchor,
pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */#
#
# Nim's Runtime Library
# (c) Copyright 2010 Andreas Rumpf
#
# See the file "copying.txt", included in this
# distribution, for details about the copyright.
#
{.deadCodeElim: on.}
{.push, callconv: cdecl.}
when defined(Unix):
when defined(macosx):
const
lib = "libmysqlclient.(15|16|17|18).dylib"
else:
const
lib = "libmysqlclient.so.(15|16|17|18)"
when defined(Windows):
const
lib = "libmysql.dll"
type
my_bool* = bool
Pmy_bool* = ptr my_bool
PVIO* = pointer
Pgptr* = ptr gptr
gptr* = cstring
Pmy_socket* = ptr my_socket
my_socket* = cint
PPByte* = pointer
cuint* = cint
# ------------ Start of declaration in "mysql_com.h" ---------------------
#
# ** Common definition between mysql server & client
#
# Field/table name length
const
NAME_LEN* = 64
HOSTNAME_LENGTH* = 60
USERNAME_LENGTH* = 16
SERVER_VERSION_LENGTH* = 60
SQLSTATE_LENGTH* = 5
LOCAL_HOST* = "localhost"
LOCAL_HOST_NAMEDPIPE* = '.'
const
NAMEDPIPE* = "MySQL"
SERVICENAME* = "MySQL"
type
Enum_server_command* = enum
COM_SLEEP, COM_QUIT, COM_INIT_DB, COM_QUERY, COM_FIELD_LIST, COM_CREATE_DB,
COM_DROP_DB, COM_REFRESH, COM_SHUTDOWN, COM_STATISTICS, COM_PROCESS_INFO,
COM_CONNECT, COM_PROCESS_KILL, COM_DEBUG, COM_PING, COM_TIME,
COM_DELAYED_INSERT, COM_CHANGE_USER, COM_BINLOG_DUMP, COM_TABLE_DUMP,
COM_CONNECT_OUT, COM_REGISTER_SLAVE, COM_STMT_PREPARE, COM_STMT_EXECUTE,
COM_STMT_SEND_LONG_DATA, COM_STMT_CLOSE, COM_STMT_RESET, COM_SET_OPTION,
COM_STMT_FETCH, COM_END
{.deprecated: [Tenum_server_command: Enum_server_command].}
const
SCRAMBLE_LENGTH* = 20 # Length of random string sent by server on handshake;
# this is also length of obfuscated password,
# received from client
SCRAMBLE_LENGTH_323* = 8 # length of password stored in the db:
# new passwords are preceded with '*'
SCRAMBLED_PASSWORD_CHAR_LENGTH* = SCRAMBLE_LENGTH * 2 + 1
SCRAMBLED_PASSWORD_CHAR_LENGTH_323* = SCRAMBLE_LENGTH_323 * 2
NOT_NULL_FLAG* = 1 # Field can't be NULL
PRI_KEY_FLAG* = 2 # Field is part of a primary key
UNIQUE_KEY_FLAG* = 4 # Field is part of a unique key
MULTIPLE_KEY_FLAG* = 8 # Field is part of a key
BLOB_FLAG* = 16 # Field is a blob
UNSIGNED_FLAG* = 32 # Field is unsigned
ZEROFILL_FLAG* = 64 # Field is zerofill
BINARY_FLAG* = 128 # Field is binary
# The following are only sent to new clients
ENUM_FLAG* = 256 # field is an enum
AUTO_INCREMENT_FLAG* = 512 # field is a autoincrement field
TIMESTAMP_FLAG* = 1024 # Field is a timestamp
SET_FLAG* = 2048 # field is a set
NO_DEFAULT_VALUE_FLAG* = 4096 # Field doesn't have default value
NUM_FLAG* = 32768 # Field is num (for clients)
PART_KEY_FLAG* = 16384 # Intern; Part of some key
GROUP_FLAG* = 32768 # Intern: Group field
UNIQUE_FLAG* = 65536 # Intern: Used by sql_yacc
BINCMP_FLAG* = 131072 # Intern: Used by sql_yacc
REFRESH_GRANT* = 1 # Refresh grant tables
REFRESH_LOG* = 2 # Start on new log file
REFRESH_TABLES* = 4 # close all tables
REFRESH_HOSTS* = 8 # Flush host cache
REFRESH_STATUS* = 16 # Flush status variables
REFRESH_THREADS* = 32 # Flush thread cache
REFRESH_SLAVE* = 64 # Reset master info and restart slave thread
REFRESH_MASTER* = 128 # Remove all bin logs in the index and truncate the index
# The following can't be set with mysql_refresh()
REFRESH_READ_LOCK* = 16384 # Lock tables for read
REFRESH_FAST* = 32768 # Intern flag
REFRESH_QUERY_CACHE* = 65536 # RESET (remove all queries) from query cache
REFRESH_QUERY_CACHE_FREE* = 0x00020000 # pack query cache
REFRESH_DES_KEY_FILE* = 0x00040000
REFRESH_USER_RESOURCES* = 0x00080000
CLIENT_LONG_PASSWORD* = 1 # new more secure passwords
CLIENT_FOUND_ROWS* = 2 # Found instead of affected rows
CLIENT_LONG_FLAG* = 4 # Get all column flags
CLIENT_CONNECT_WITH_DB* = 8 # One can specify db on connect
CLIENT_NO_SCHEMA* = 16 # Don't allow database.table.column
CLIENT_COMPRESS* = 32 # Can use compression protocol
CLIENT_ODBC* = 64 # Odbc client
CLIENT_LOCAL_FILES* = 128 # Can use LOAD DATA LOCAL
CLIENT_IGNORE_SPACE* = 256 # Ignore spaces before '('
CLIENT_PROTOCOL_41* = 512 # New 4.1 protocol
CLIENT_INTERACTIVE* = 1024 # This is an interactive client
CLIENT_SSL* = 2048 # Switch to SSL after handshake
CLIENT_IGNORE_SIGPIPE* = 4096 # IGNORE sigpipes
CLIENT_TRANSACTIONS* = 8192 # Client knows about transactions
CLIENT_RESERVED* = 16384 # Old flag for 4.1 protocol
CLIENT_SECURE_CONNECTION* = 32768 # New 4.1 authentication
CLIENT_MULTI_STATEMENTS* = 65536 # Enable/disable multi-stmt support
CLIENT_MULTI_RESULTS* = 131072 # Enable/disable multi-results
CLIENT_REMEMBER_OPTIONS*: int = 1 shl 31
SERVER_STATUS_IN_TRANS* = 1 # Transaction has started
SERVER_STATUS_AUTOCOMMIT* = 2 # Server in auto_commit mode
SERVER_STATUS_MORE_RESULTS* = 4 # More results on server
SERVER_MORE_RESULTS_EXISTS* = 8 # Multi query - next query exists
SERVER_QUERY_NO_GOOD_INDEX_USED* = 16
SERVER_QUERY_NO_INDEX_USED* = 32 # The server was able to fulfill the clients request and opened a
# read-only non-scrollable cursor for a query. This flag comes
# in reply to COM_STMT_EXECUTE and COM_STMT_FETCH commands.
SERVER_STATUS_CURSOR_EXISTS* = 64 # This flag is sent when a read-only cursor is exhausted, in reply to
# COM_STMT_FETCH command.
SERVER_STATUS_LAST_ROW_SENT* = 128
SERVER_STATUS_DB_DROPPED* = 256 # A database was dropped
SERVER_STATUS_NO_BACKSLASH_ESCAPES* = 512
ERRMSG_SIZE* = 200
NET_READ_TIMEOUT* = 30 # Timeout on read
NET_WRITE_TIMEOUT* = 60 # Timeout on write
NET_WAIT_TIMEOUT* = 8 * 60 * 60 # Wait for new query
ONLY_KILL_QUERY* = 1
const
MAX_TINYINT_WIDTH* = 3 # Max width for a TINY w.o. sign
MAX_SMALLINT_WIDTH* = 5 # Max width for a SHORT w.o. sign
MAX_MEDIUMINT_WIDTH* = 8 # Max width for a INT24 w.o. sign
MAX_INT_WIDTH* = 10 # Max width for a LONG w.o. sign
MAX_BIGINT_WIDTH* = 20 # Max width for a LONGLONG
MAX_CHAR_WIDTH* = 255 # Max length for a CHAR column
MAX_BLOB_WIDTH* = 8192 # Default width for blob
type
Pst_net* = ptr St_net
St_net*{.final.} = object
vio*: PVio
buff*: cstring
buff_end*: cstring
write_pos*: cstring
read_pos*: cstring
fd*: my_socket # For Perl DBI/dbd
max_packet*: int
max_packet_size*: int
pkt_nr*: cuint
compress_pkt_nr*: cuint
write_timeout*: cuint
read_timeout*: cuint
retry_count*: cuint
fcntl*: cint
compress*: my_bool # The following variable is set if we are doing several queries in one
# command ( as in LOAD TABLE ... FROM MASTER ),
# and do not want to confuse the client with OK at the wrong time
remain_in_buf*: int
len*: int
buf_length*: int
where_b*: int
return_status*: ptr cint
reading_or_writing*: char
save_char*: cchar
no_send_ok*: my_bool # For SPs and other things that do multiple stmts
no_send_eof*: my_bool # For SPs' first version read-only cursors
no_send_error*: my_bool # Set if OK packet is already sent, and
# we do not need to send error messages
# Pointer to query object in query cache, do not equal NULL (0) for
# queries in cache that have not stored its results yet
# $endif
last_error*: array[0..(ERRMSG_SIZE) - 1, char]
sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char]
last_errno*: cuint
error*: char
query_cache_query*: gptr
report_error*: my_bool # We should report error (we have unreported error)
return_errno*: my_bool
NET* = St_net
PNET* = ptr NET
{.deprecated: [Tst_net: St_net, TNET: NET].}
const
packet_error* = - 1
type
Enum_field_types* = enum # For backward compatibility
TYPE_DECIMAL, TYPE_TINY, TYPE_SHORT, TYPE_LONG, TYPE_FLOAT, TYPE_DOUBLE,
TYPE_NULL, TYPE_TIMESTAMP, TYPE_LONGLONG, TYPE_INT24, TYPE_DATE, TYPE_TIME,
TYPE_DATETIME, TYPE_YEAR, TYPE_NEWDATE, TYPE_VARCHAR, TYPE_BIT,
TYPE_NEWDECIMAL = 246, TYPE_ENUM = 247, TYPE_SET = 248,
TYPE_TINY_BLOB = 249, TYPE_MEDIUM_BLOB = 250, TYPE_LONG_BLOB = 251,
TYPE_BLOB = 252, TYPE_VAR_STRING = 253, TYPE_STRING = 254,
TYPE_GEOMETRY = 255
{.deprecated: [Tenum_field_types: Enum_field_types].}
const
CLIENT_MULTI_QUERIES* = CLIENT_MULTI_STATEMENTS
FIELD_TYPE_DECIMAL* = TYPE_DECIMAL
FIELD_TYPE_NEWDECIMAL* = TYPE_NEWDECIMAL
FIELD_TYPE_TINY* = TYPE_TINY
FIELD_TYPE_SHORT* = TYPE_SHORT
FIELD_TYPE_LONG* = TYPE_LONG
FIELD_TYPE_FLOAT* = TYPE_FLOAT
FIELD_TYPE_DOUBLE* = TYPE_DOUBLE
FIELD_TYPE_NULL* = TYPE_NULL
FIELD_TYPE_TIMESTAMP* = TYPE_TIMESTAMP
FIELD_TYPE_LONGLONG* = TYPE_LONGLONG
FIELD_TYPE_INT24* = TYPE_INT24
FIELD_TYPE_DATE* = TYPE_DATE
FIELD_TYPE_TIME* = TYPE_TIME
FIELD_TYPE_DATETIME* = TYPE_DATETIME
FIELD_TYPE_YEAR* = TYPE_YEAR
FIELD_TYPE_NEWDATE* = TYPE_NEWDATE
FIELD_TYPE_ENUM* = TYPE_ENUM
FIELD_TYPE_SET* = TYPE_SET
FIELD_TYPE_TINY_BLOB* = TYPE_TINY_BLOB
FIELD_TYPE_MEDIUM_BLOB* = TYPE_MEDIUM_BLOB
FIELD_TYPE_LONG_BLOB* = TYPE_LONG_BLOB
FIELD_TYPE_BLOB* = TYPE_BLOB
FIELD_TYPE_VAR_STRING* = TYPE_VAR_STRING
FIELD_TYPE_STRING* = TYPE_STRING
FIELD_TYPE_CHAR* = TYPE_TINY
FIELD_TYPE_INTERVAL* = TYPE_ENUM
FIELD_TYPE_GEOMETRY* = TYPE_GEOMETRY
FIELD_TYPE_BIT* = TYPE_BIT # Shutdown/kill enums and constants
# Bits for THD::killable.
SHUTDOWN_KILLABLE_CONNECT* = chr(1 shl 0)
SHUTDOWN_KILLABLE_TRANS* = chr(1 shl 1)
SHUTDOWN_KILLABLE_LOCK_TABLE* = chr(1 shl 2)
SHUTDOWN_KILLABLE_UPDATE* = chr(1 shl 3)
type
Enum_shutdown_level* = enum
SHUTDOWN_DEFAULT = 0, SHUTDOWN_WAIT_CONNECTIONS = 1,
SHUTDOWN_WAIT_TRANSACTIONS = 2, SHUTDOWN_WAIT_UPDATES = 8,
SHUTDOWN_WAIT_ALL_BUFFERS = 16, SHUTDOWN_WAIT_CRITICAL_BUFFERS = 17,
KILL_QUERY = 254, KILL_CONNECTION = 255
Enum_cursor_type* = enum # options for mysql_set_option
CURSOR_TYPE_NO_CURSOR = 0, CURSOR_TYPE_READ_ONLY = 1,
CURSOR_TYPE_FOR_UPDATE = 2, CURSOR_TYPE_SCROLLABLE = 4
Enum_mysql_set_option* = enum
OPTION_MULTI_STATEMENTS_ON, OPTION_MULTI_STATEMENTS_OFF
{.deprecated: [Tenum_shutdown_level: Enum_shutdown_level,
Tenum_cursor_type: Enum_cursor_type,
Tenum_mysql_set_option: Enum_mysql_set_option].}
proc my_net_init*(net: PNET, vio: PVio): my_bool{.cdecl, dynlib: lib,
importc: "my_net_init".}
proc my_net_local_init*(net: PNET){.cdecl, dynlib: lib,
importc: "my_net_local_init".}
proc net_end*(net: PNET){.cdecl, dynlib: lib, importc: "net_end".}
proc net_clear*(net: PNET){.cdecl, dynlib: lib, importc: "net_clear".}
proc net_realloc*(net: PNET, len: int): my_bool{.cdecl, dynlib: lib,
importc: "net_realloc".}
proc net_flush*(net: PNET): my_bool{.cdecl, dynlib: lib, importc: "net_flush".}
proc my_net_write*(net: PNET, packet: cstring, length: int): my_bool{.cdecl,
dynlib: lib, importc: "my_net_write".}
proc net_write_command*(net: PNET, command: char, header: cstring,
head_len: int, packet: cstring, length: int): my_bool{.
cdecl, dynlib: lib, importc: "net_write_command".}
proc net_real_write*(net: PNET, packet: cstring, length: int): cint{.cdecl,
dynlib: lib, importc: "net_real_write".}
proc my_net_read*(net: PNET): int{.cdecl, dynlib: lib, importc: "my_net_read".}
# The following function is not meant for normal usage
# Currently it's used internally by manager.c
type
Psockaddr* = ptr Sockaddr
Sockaddr*{.final.} = object # undefined structure
{.deprecated: [Tsockaddr: Sockaddr].}
proc my_connect*(s: my_socket, name: Psockaddr, namelen: cuint, timeout: cuint): cint{.
cdecl, dynlib: lib, importc: "my_connect".}
type
Prand_struct* = ptr Rand_struct
Rand_struct*{.final.} = object # The following is for user defined functions
seed1*: int
seed2*: int
max_value*: int
max_value_dbl*: cdouble
Item_result* = enum
STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT, DECIMAL_RESULT
PItem_result* = ptr Item_result
Pst_udf_args* = ptr St_udf_args
St_udf_args*{.final.} = object
arg_count*: cuint # Number of arguments
arg_type*: PItem_result # Pointer to item_results
args*: cstringArray # Pointer to item_results
lengths*: ptr int # Length of string arguments
maybe_null*: cstring # Length of string arguments
attributes*: cstringArray # Pointer to attribute name
attribute_lengths*: ptr int # Length of attribute arguments
UDF_ARGS* = St_udf_args
PUDF_ARGS* = ptr UDF_ARGS # This holds information about the result
Pst_udf_init* = ptr St_udf_init
St_udf_init*{.final.} = object
maybe_null*: my_bool # 1 if function can return NULL
decimals*: cuint # for real functions
max_length*: int # For string functions
theptr*: cstring # free pointer for function data
const_item*: my_bool # free pointer for function data
UDF_INIT* = St_udf_init
PUDF_INIT* = ptr UDF_INIT # Constants when using compression
{.deprecated: [Trand_stuct: Rand_struct, TItem_result: Item_result,
Tst_udf_args: St_udf_args, TUDF_ARGS: UDF_ARGS,
Tst_udf_init: St_udf_init, TUDF_INIT: UDF_INIT].}
const
NET_HEADER_SIZE* = 4 # standard header size
COMP_HEADER_SIZE* = 3 # compression header extra size
# Prototypes to password functions
# These functions are used for authentication by client and server and
# implemented in sql/password.c
proc randominit*(para1: Prand_struct, seed1: int, seed2: int){.cdecl,
dynlib: lib, importc: "randominit".}
proc my_rnd*(para1: Prand_struct): cdouble{.cdecl, dynlib: lib,
importc: "my_rnd".}
proc create_random_string*(fto: cstring, len: cuint, rand_st: Prand_struct){.
cdecl, dynlib: lib, importc: "create_random_string".}
proc hash_password*(fto: int, password: cstring, password_len: cuint){.cdecl,
dynlib: lib, importc: "hash_password".}
proc make_scrambled_password_323*(fto: cstring, password: cstring){.cdecl,
dynlib: lib, importc: "make_scrambled_password_323".}
proc scramble_323*(fto: cstring, message: cstring, password: cstring){.cdecl,
dynlib: lib, importc: "scramble_323".}
proc check_scramble_323*(para1: cstring, message: cstring, salt: int): my_bool{.
cdecl, dynlib: lib, importc: "check_scramble_323".}
proc get_salt_from_password_323*(res: ptr int, password: cstring){.cdecl,
dynlib: lib, importc: "get_salt_from_password_323".}
proc make_password_from_salt_323*(fto: cstring, salt: ptr int){.cdecl,
dynlib: lib, importc: "make_password_from_salt_323".}
proc octet2hex*(fto: cstring, str: cstring, length: cuint): cstring{.cdecl,
dynlib: lib, importc: "octet2hex".}
proc make_scrambled_password*(fto: cstring, password: cstring){.cdecl,
dynlib: lib, importc: "make_scrambled_password".}
proc scramble*(fto: cstring, message: cstring, password: cstring){.cdecl,
dynlib: lib, importc: "scramble".}
proc check_scramble*(reply: cstring, message: cstring, hash_stage2: pointer): my_bool{.
cdecl, dynlib: lib, importc: "check_scramble".}
proc get_salt_from_password*(res: pointer, password: cstring){.cdecl,
dynlib: lib, importc: "get_salt_from_password".}
proc make_password_from_salt*(fto: cstring, hash_stage2: pointer){.cdecl,
dynlib: lib, importc: "make_password_from_salt".}
# end of password.c
proc get_tty_password*(opt_message: cstring): cstring{.cdecl, dynlib: lib,
importc: "get_tty_password".}
proc errno_to_sqlstate*(errno: cuint): cstring{.cdecl, dynlib: lib,
importc: "mysql_errno_to_sqlstate".}
# Some other useful functions
proc modify_defaults_file*(file_location: cstring, option: cstring,
option_value: cstring, section_name: cstring,
remove_option: cint): cint{.cdecl, dynlib: lib,
importc: "load_defaults".}
proc load_defaults*(conf_file: cstring, groups: cstringArray, argc: ptr cint,
argv: ptr cstringArray): cint{.cdecl, dynlib: lib,
importc: "load_defaults".}
proc my_init*(): my_bool{.cdecl, dynlib: lib, importc: "my_init".}
proc my_thread_init*(): my_bool{.cdecl, dynlib: lib, importc: "my_thread_init".}
proc my_thread_end*(){.cdecl, dynlib: lib, importc: "my_thread_end".}
const
NULL_LENGTH*: int = int(not (0)) # For net_store_length
const
STMT_HEADER* = 4
LONG_DATA_HEADER* = 6 # ------------ Stop of declaration in "mysql_com.h" -----------------------
# $include "mysql_time.h"
# $include "mysql_version.h"
# $include "typelib.h"
# $include "my_list.h" /* for LISTs used in 'MYSQL' and 'MYSQL_STMT' */
# var
# mysql_port : cuint;cvar;external;
# mysql_unix_port : Pchar;cvar;external;
const
CLIENT_NET_READ_TIMEOUT* = 365 * 24 * 3600 # Timeout on read
CLIENT_NET_WRITE_TIMEOUT* = 365 * 24 * 3600 # Timeout on write
type
Pst_mysql_field* = ptr St_mysql_field
St_mysql_field*{.final.} = object
name*: cstring # Name of column
org_name*: cstring # Original column name, if an alias
table*: cstring # Table of column if column was a field
org_table*: cstring # Org table name, if table was an alias
db*: cstring # Database for table
catalog*: cstring # Catalog for table
def*: cstring # Default value (set by mysql_list_fields)
len*: int # Width of column (create length)
max_length*: int # Max width for selected set
name_length*: cuint
org_name_length*: cuint
table_length*: cuint
org_table_length*: cuint
db_length*: cuint
catalog_length*: cuint
def_length*: cuint
flags*: cuint # Div flags
decimals*: cuint # Number of decimals in field
charsetnr*: cuint # Character set
ftype*: Enum_field_types # Type of field. See mysql_com.h for types
extension*: pointer
FIELD* = St_mysql_field
PFIELD* = ptr FIELD
PROW* = ptr ROW # return data as array of strings
ROW* = cstringArray
PFIELD_OFFSET* = ptr FIELD_OFFSET # offset to current field
FIELD_OFFSET* = cuint
{.deprecated: [Tst_mysql_field: St_mysql_field, TFIELD: FIELD, TROW: ROW,
TFIELD_OFFSET: FIELD_OFFSET].}
proc IS_PRI_KEY*(n: int32): bool
proc IS_NOT_NULL*(n: int32): bool
proc IS_BLOB*(n: int32): bool
proc IS_NUM*(t: Enum_field_types): bool
proc INTERNAL_NUM_FIELD*(f: Pst_mysql_field): bool
proc IS_NUM_FIELD*(f: Pst_mysql_field): bool
type
my_ulonglong* = int64
Pmy_ulonglong* = ptr my_ulonglong
const
COUNT_ERROR* = not (my_ulonglong(0))
type
Pst_mysql_rows* = ptr St_mysql_rows
St_mysql_rows*{.final.} = object
next*: Pst_mysql_rows # list of rows
data*: ROW
len*: int
ROWS* = St_mysql_rows
PROWS* = ptr ROWS
PROW_OFFSET* = ptr ROW_OFFSET # offset to current row
ROW_OFFSET* = ROWS
{.deprecated: [Tst_mysql_rows: St_mysql_rows, TROWS: ROWS,
TROW_OFFSET: ROW_OFFSET].}
const
ALLOC_MAX_BLOCK_TO_DROP* = 4096
ALLOC_MAX_BLOCK_USAGE_BEFORE_DROP* = 10 # struct for once_alloc (block)
type
Pst_used_mem* = ptr St_used_mem
St_used_mem*{.final.} = object
next*: Pst_used_mem # Next block in use
left*: cuint # memory left in block
size*: cuint # size of block
USED_MEM* = St_used_mem
PUSED_MEM* = ptr USED_MEM
Pst_mem_root* = ptr St_mem_root
St_mem_root*{.final.} = object
free*: PUSED_MEM # blocks with free memory in it
used*: PUSED_MEM # blocks almost without free memory
pre_alloc*: PUSED_MEM # preallocated block
min_malloc*: cuint # if block have less memory it will be put in 'used' list
block_size*: cuint # initial block size
block_num*: cuint # allocated blocks counter
# first free block in queue test counter (if it exceed
# MAX_BLOCK_USAGE_BEFORE_DROP block will be dropped in 'used' list)
first_block_usage*: cuint
error_handler*: proc (){.cdecl.}
MEM_ROOT* = St_mem_root
PMEM_ROOT* = ptr MEM_ROOT # ------------ Stop of declaration in "my_alloc.h" ----------------------
{.deprecated: [Tst_used_mem: St_used_mem, TUSED_MEM: USED_MEM,
Tst_mem_root: St_mem_root, TMEM_ROOT: MEM_ROOT].}
type
Pst_mysql_data* = ptr St_mysql_data
St_mysql_data*{.final.} = object
rows*: my_ulonglong
fields*: cuint
data*: PROWS
alloc*: MEM_ROOT
prev_ptr*: ptr PROWS
DATA* = St_mysql_data
PDATA* = ptr DATA
Option* = enum
OPT_CONNECT_TIMEOUT, OPT_COMPRESS, OPT_NAMED_PIPE, INIT_COMMAND,
READ_DEFAULT_FILE, READ_DEFAULT_GROUP, SET_CHARSET_DIR, SET_CHARSET_NAME,
OPT_LOCAL_INFILE, OPT_PROTOCOL, SHARED_MEMORY_BASE_NAME, OPT_READ_TIMEOUT,
OPT_WRITE_TIMEOUT, OPT_USE_RESULT, OPT_USE_REMOTE_CONNECTION,
OPT_USE_EMBEDDED_CONNECTION, OPT_GUESS_CONNECTION, SET_CLIENT_IP,
SECURE_AUTH, REPORT_DATA_TRUNCATION, OPT_RECONNECT
{.deprecated: [Tst_mysql_data: St_mysql_data, TDATA: DATA, Toption: Option].}
const
MAX_MYSQL_MANAGER_ERR* = 256
MAX_MYSQL_MANAGER_MSG* = 256
MANAGER_OK* = 200
MANAGER_INFO* = 250
MANAGER_ACCESS* = 401
MANAGER_CLIENT_ERR* = 450
MANAGER_INTERNAL_ERR* = 500
type
St_dynamic_array*{.final.} = object
buffer*: cstring
elements*: cuint
max_element*: cuint
alloc_increment*: cuint
size_of_element*: cuint
DYNAMIC_ARRAY* = St_dynamic_array
Pst_dynamic_array* = ptr St_dynamic_array
Pst_mysql_options* = ptr St_mysql_options
St_mysql_options*{.final.} = object
connect_timeout*: cuint
read_timeout*: cuint
write_timeout*: cuint
port*: cuint
protocol*: cuint
client_flag*: int
host*: cstring
user*: cstring
password*: cstring
unix_socket*: cstring
db*: cstring
init_commands*: Pst_dynamic_array
my_cnf_file*: cstring
my_cnf_group*: cstring
charset_dir*: cstring
charset_name*: cstring
ssl_key*: cstring # PEM key file
ssl_cert*: cstring # PEM cert file
ssl_ca*: cstring # PEM CA file
ssl_capath*: cstring # PEM directory of CA-s?
ssl_cipher*: cstring # cipher to use
shared_memory_base_name*: cstring
max_allowed_packet*: int
use_ssl*: my_bool # if to use SSL or not
compress*: my_bool
named_pipe*: my_bool # On connect, find out the replication role of the server, and
# establish connections to all the peers
rpl_probe*: my_bool # Each call to mysql_real_query() will parse it to tell if it is a read
# or a write, and direct it to the slave or the master
rpl_parse*: my_bool # If set, never read from a master, only from slave, when doing
# a read that is replication-aware
no_master_reads*: my_bool
separate_thread*: my_bool
methods_to_use*: Option
client_ip*: cstring
secure_auth*: my_bool # Refuse client connecting to server if it uses old (pre-4.1.1) protocol
report_data_truncation*: my_bool # 0 - never report, 1 - always report (default)
# function pointers for local infile support
local_infile_init*: proc (para1: var pointer, para2: cstring, para3: pointer): cint{.
cdecl.}
local_infile_read*: proc (para1: pointer, para2: cstring, para3: cuint): cint
local_infile_end*: proc (para1: pointer)
local_infile_error*: proc (para1: pointer, para2: cstring, para3: cuint): cint
local_infile_userdata*: pointer
Status* = enum
STATUS_READY, STATUS_GET_RESULT, STATUS_USE_RESULT
Protocol_type* = enum # There are three types of queries - the ones that have to go to
# the master, the ones that go to a slave, and the administrative
# type which must happen on the pivot connectioin
PROTOCOL_DEFAULT, PROTOCOL_TCP, PROTOCOL_SOCKET, PROTOCOL_PIPE,
PROTOCOL_MEMORY
Rpl_type* = enum
RPL_MASTER, RPL_SLAVE, RPL_ADMIN
Charset_info_st*{.final.} = object
number*: cuint
primary_number*: cuint
binary_number*: cuint
state*: cuint
csname*: cstring
name*: cstring
comment*: cstring
tailoring*: cstring
ftype*: cstring
to_lower*: cstring
to_upper*: cstring
sort_order*: cstring
contractions*: ptr int16
sort_order_big*: ptr ptr int16
tab_to_uni*: ptr int16
tab_from_uni*: pointer # was ^MY_UNI_IDX
state_map*: cstring
ident_map*: cstring
strxfrm_multiply*: cuint
mbminlen*: cuint
mbmaxlen*: cuint
min_sort_char*: int16
max_sort_char*: int16
escape_with_backslash_is_dangerous*: my_bool
cset*: pointer # was ^MY_CHARSET_HANDLER
coll*: pointer # was ^MY_COLLATION_HANDLER;
CHARSET_INFO* = Charset_info_st
Pcharset_info_st* = ptr Charset_info_st
Pcharacter_set* = ptr Character_set
Character_set*{.final.} = object
number*: cuint
state*: cuint
csname*: cstring
name*: cstring
comment*: cstring
dir*: cstring
mbminlen*: cuint
mbmaxlen*: cuint
MY_CHARSET_INFO* = Character_set
PMY_CHARSET_INFO* = ptr MY_CHARSET_INFO
Pst_mysql_methods* = ptr St_mysql_methods
Pst_mysql* = ptr St_mysql
St_mysql*{.final.} = object
net*: NET # Communication parameters
connector_fd*: gptr # ConnectorFd for SSL
host*: cstring
user*: cstring
passwd*: cstring
unix_socket*: cstring
server_version*: cstring
host_info*: cstring
info*: cstring
db*: cstring
charset*: Pcharset_info_st
fields*: PFIELD
field_alloc*: MEM_ROOT
affected_rows*: my_ulonglong
insert_id*: my_ulonglong # id if insert on table with NEXTNR
extra_info*: my_ulonglong # Used by mysqlshow, not used by mysql 5.0 and up
thread_id*: int # Id for connection in server
packet_length*: int
port*: cuint
client_flag*: int
server_capabilities*: int
protocol_version*: cuint
field_count*: cuint
server_status*: cuint
server_language*: cuint
warning_count*: cuint
options*: St_mysql_options
status*: Status
free_me*: my_bool # If free in mysql_close
reconnect*: my_bool # set to 1 if automatic reconnect
scramble*: array[0..(SCRAMBLE_LENGTH + 1) - 1, char] # session-wide random string
# Set if this is the original connection, not a master or a slave we have
# added though mysql_rpl_probe() or mysql_set_master()/ mysql_add_slave()
rpl_pivot*: my_bool # Pointers to the master, and the next slave connections, points to
# itself if lone connection.
master*: Pst_mysql
next_slave*: Pst_mysql
last_used_slave*: Pst_mysql # needed for round-robin slave pick
last_used_con*: Pst_mysql # needed for send/read/store/use result to work correctly with replication
stmts*: pointer # was PList, list of all statements
methods*: Pst_mysql_methods
thd*: pointer # Points to boolean flag in MYSQL_RES or MYSQL_STMT. We set this flag
# from mysql_stmt_close if close had to cancel result set of this object.
unbuffered_fetch_owner*: Pmy_bool
MySQL* = St_mysql
PMySQL* = ptr MySQL
Pst_mysql_res* = ptr St_mysql_res
St_mysql_res*{.final.} = object
row_count*: my_ulonglong
fields*: PFIELD
data*: PDATA
data_cursor*: PROWS
lengths*: ptr int # column lengths of current row
handle*: PMySQL # for unbuffered reads
field_alloc*: MEM_ROOT
field_count*: cuint
current_field*: cuint
row*: ROW # If unbuffered read
current_row*: ROW # buffer to current row
eof*: my_bool # Used by mysql_fetch_row
unbuffered_fetch_cancelled*: my_bool # mysql_stmt_close() had to cancel this result
methods*: Pst_mysql_methods
RES* = St_mysql_res
PRES* = ptr RES
Pst_mysql_stmt* = ptr St_mysql_stmt
PSTMT* = ptr STMT
St_mysql_methods*{.final.} = object
read_query_result*: proc (MySQL: PMySQL): my_bool{.cdecl.}
advanced_command*: proc (MySQL: PMySQL, command: Enum_server_command, header: cstring,
header_length: int, arg: cstring, arg_length: int,
skip_check: my_bool): my_bool
read_rows*: proc (MySQL: PMySQL, fields: PFIELD, fields_count: cuint): PDATA
use_result*: proc (MySQL: PMySQL): PRES
fetch_lengths*: proc (fto: ptr int, column: ROW, field_count: cuint)
flush_use_result*: proc (MySQL: PMySQL)
list_fields*: proc (MySQL: PMySQL): PFIELD
read_prepare_result*: proc (MySQL: PMySQL, stmt: PSTMT): my_bool
stmt_execute*: proc (stmt: PSTMT): cint
read_binary_rows*: proc (stmt: PSTMT): cint
unbuffered_fetch*: proc (MySQL: PMySQL, row: cstringArray): cint
free_embedded_thd*: proc (MySQL: PMySQL)
read_statistics*: proc (MySQL: PMySQL): cstring
next_result*: proc (MySQL: PMySQL): my_bool
read_change_user_result*: proc (MySQL: PMySQL, buff: cstring, passwd: cstring): cint
read_rowsfrom_cursor*: proc (stmt: PSTMT): cint
METHODS* = St_mysql_methods
PMETHODS* = ptr METHODS
Pst_mysql_manager* = ptr St_mysql_manager
St_mysql_manager*{.final.} = object
net*: NET
host*: cstring
user*: cstring
passwd*: cstring
port*: cuint
free_me*: my_bool
eof*: my_bool
cmd_status*: cint
last_errno*: cint
net_buf*: cstring
net_buf_pos*: cstring
net_data_end*: cstring
net_buf_size*: cint
last_error*: array[0..(MAX_MYSQL_MANAGER_ERR) - 1, char]
MANAGER* = St_mysql_manager
PMANAGER* = ptr MANAGER
Pst_mysql_parameters* = ptr St_mysql_parameters
St_mysql_parameters*{.final.} = object
p_max_allowed_packet*: ptr int
p_net_buffer_length*: ptr int
PARAMETERS* = St_mysql_parameters
PPARAMETERS* = ptr PARAMETERS
Enum_mysql_stmt_state* = enum
STMT_INIT_DONE = 1, STMT_PREPARE_DONE, STMT_EXECUTE_DONE, STMT_FETCH_DONE
Pst_mysql_bind* = ptr St_mysql_bind
St_mysql_bind*{.final.} = object
len*: int # output length pointer
is_null*: Pmy_bool # Pointer to null indicator
buffer*: pointer # buffer to get/put data
error*: PMy_bool # set this if you want to track data truncations happened during fetch
buffer_type*: Enum_field_types # buffer type
buffer_length*: int # buffer length, must be set for str/binary
# Following are for internal use. Set by mysql_stmt_bind_param
row_ptr*: ptr byte # for the current data position
offset*: int # offset position for char/binary fetch
length_value*: int # Used if length is 0
param_number*: cuint # For null count and error messages
pack_length*: cuint # Internal length for packed data
error_value*: my_bool # used if error is 0
is_unsigned*: my_bool # set if integer type is unsigned
long_data_used*: my_bool # If used with mysql_send_long_data
is_null_value*: my_bool # Used if is_null is 0
store_param_func*: proc (net: PNET, param: Pst_mysql_bind){.cdecl.}
fetch_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte)
skip_result*: proc (para1: Pst_mysql_bind, para2: PFIELD, row: PPbyte)
BIND* = St_mysql_bind
PBIND* = ptr BIND # statement handler
St_mysql_stmt*{.final.} = object
mem_root*: MEM_ROOT # root allocations
mysql*: PMySQL # connection handle
params*: PBIND # input parameters
`bind`*: PBIND # input parameters
fields*: PFIELD # result set metadata
result*: DATA # cached result set
data_cursor*: PROWS # current row in cached result
affected_rows*: my_ulonglong # copy of mysql->affected_rows after statement execution
insert_id*: my_ulonglong
read_row_func*: proc (stmt: Pst_mysql_stmt, row: PPbyte): cint{.cdecl.}
stmt_id*: int # Id for prepared statement
flags*: int # i.e. type of cursor to open
prefetch_rows*: int # number of rows per one COM_FETCH
server_status*: cuint # Copied from mysql->server_status after execute/fetch to know
# server-side cursor status for this statement.
last_errno*: cuint # error code
param_count*: cuint # input parameter count
field_count*: cuint # number of columns in result set
state*: Enum_mysql_stmt_state # statement state
last_error*: array[0..(ERRMSG_SIZE) - 1, char] # error message
sqlstate*: array[0..(SQLSTATE_LENGTH + 1) - 1, char]
send_types_to_server*: my_bool # Types of input parameters should be sent to server
bind_param_done*: my_bool # input buffers were supplied
bind_result_done*: char # output buffers were supplied
unbuffered_fetch_cancelled*: my_bool
update_max_length*: my_bool
STMT* = St_mysql_stmt
Enum_stmt_attr_type* = enum
STMT_ATTR_UPDATE_MAX_LENGTH, STMT_ATTR_CURSOR_TYPE, STMT_ATTR_PREFETCH_ROWS
{.deprecated: [Tst_dynamic_array: St_dynamic_array, Tst_mysql_options: St_mysql_options,
TDYNAMIC_ARRAY: DYNAMIC_ARRAY, Tprotocol_type: Protocol_type,
Trpl_type: Rpl_type, Tcharset_info_st: Charset_info_st,
TCHARSET_INFO: CHARSET_INFO, Tcharacter_set: Character_set,
TMY_CHARSET_INFO: MY_CHARSET_INFO, Tst_mysql: St_mysql,
Tst_mysql_methods: St_mysql_methods, TMySql: MySql,
Tst_mysql_res: St_mysql_res, TMETHODS: METHODS, TRES: RES,
Tst_mysql_manager: St_mysql_manager, TMANAGER: MANAGER,
Tst_mysql_parameters: St_mysql_parameters, TPARAMETERS: PARAMETERS,
Tenum_mysql_stmt_state: Enum_mysql_stmt_state,
Tst_mysql_bind: St_mysql_bind, TBIND: BIND, Tst_mysql_stmt: St_mysql_stmt,
TSTMT: STMT, Tenum_stmt_attr_type: Enum_stmt_attr_type,
Tstatus: Status].}
proc server_init*(argc: cint, argv: cstringArray, groups: cstringArray): cint{.
cdecl, dynlib: lib, importc: "mysql_server_init".}
proc server_end*(){.cdecl, dynlib: lib, importc: "mysql_server_end".}
# mysql_server_init/end need to be called when using libmysqld or
# libmysqlclient (exactly, mysql_server_init() is called by mysql_init() so
# you don't need to call it explicitly; but you need to call
# mysql_server_end() to free memory). The names are a bit misleading
# (mysql_SERVER* to be used when using libmysqlCLIENT). So we add more general
# names which suit well whether you're using libmysqld or libmysqlclient. We
# intend to promote these aliases over the mysql_server* ones.
proc library_init*(argc: cint, argv: cstringArray, groups: cstringArray): cint{.
cdecl, dynlib: lib, importc: "mysql_server_init".}
proc library_end*(){.cdecl, dynlib: lib, importc: "mysql_server_end".}
proc get_parameters*(): PPARAMETERS{.stdcall, dynlib: lib,
importc: "mysql_get_parameters".}
# Set up and bring down a thread; these function should be called
# for each thread in an application which opens at least one MySQL
# connection. All uses of the connection(s) should be between these
# function calls.
proc thread_init*(): my_bool{.stdcall, dynlib: lib, importc: "mysql_thread_init".}
proc thread_end*(){.stdcall, dynlib: lib, importc: "mysql_thread_end".}
# Functions to get information from the MYSQL and MYSQL_RES structures
# Should definitely be used if one uses shared libraries.
proc num_rows*(res: PRES): my_ulonglong{.stdcall, dynlib: lib,
importc: "mysql_num_rows".}
proc num_fields*(res: PRES): cuint{.stdcall, dynlib: lib,
importc: "mysql_num_fields".}
proc eof*(res: PRES): my_bool{.stdcall, dynlib: lib, importc: "mysql_eof".}
proc fetch_field_direct*(res: PRES, fieldnr: cuint): PFIELD{.stdcall,
dynlib: lib, importc: "mysql_fetch_field_direct".}
proc fetch_fields*(res: PRES): PFIELD{.stdcall, dynlib: lib,
importc: "mysql_fetch_fields".}
proc row_tell*(res: PRES): ROW_OFFSET{.stdcall, dynlib: lib,
importc: "mysql_row_tell".}
proc field_tell*(res: PRES): FIELD_OFFSET{.stdcall, dynlib: lib,
importc: "mysql_field_tell".}
proc field_count*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib,
importc: "mysql_field_count".}
proc affected_rows*(MySQL: PMySQL): my_ulonglong{.stdcall, dynlib: lib,
importc: "mysql_affected_rows".}
proc insert_id*(MySQL: PMySQL): my_ulonglong{.stdcall, dynlib: lib,
importc: "mysql_insert_id".}
proc errno*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib, importc: "mysql_errno".}
proc error*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_error".}
proc sqlstate*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_sqlstate".}
proc warning_count*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib,
importc: "mysql_warning_count".}
proc info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_info".}
proc thread_id*(MySQL: PMySQL): int{.stdcall, dynlib: lib, importc: "mysql_thread_id".}
proc character_set_name*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib,
importc: "mysql_character_set_name".}
proc set_character_set*(MySQL: PMySQL, csname: cstring): int32{.stdcall, dynlib: lib,
importc: "mysql_set_character_set".}
proc init*(MySQL: PMySQL): PMySQL{.stdcall, dynlib: lib, importc: "mysql_init".}
proc ssl_set*(MySQL: PMySQL, key: cstring, cert: cstring, ca: cstring, capath: cstring,
cipher: cstring): my_bool{.stdcall, dynlib: lib,
importc: "mysql_ssl_set".}
proc change_user*(MySQL: PMySQL, user: cstring, passwd: cstring, db: cstring): my_bool{.
stdcall, dynlib: lib, importc: "mysql_change_user".}
proc real_connect*(MySQL: PMySQL, host: cstring, user: cstring, passwd: cstring,
db: cstring, port: cuint, unix_socket: cstring,
clientflag: int): PMySQL{.stdcall, dynlib: lib,
importc: "mysql_real_connect".}
proc select_db*(MySQL: PMySQL, db: cstring): cint{.stdcall, dynlib: lib,
importc: "mysql_select_db".}
proc query*(MySQL: PMySQL, q: cstring): cint{.stdcall, dynlib: lib, importc: "mysql_query".}
proc send_query*(MySQL: PMySQL, q: cstring, len: int): cint{.stdcall, dynlib: lib,
importc: "mysql_send_query".}
proc real_query*(MySQL: PMySQL, q: cstring, len: int): cint{.stdcall, dynlib: lib,
importc: "mysql_real_query".}
proc store_result*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib,
importc: "mysql_store_result".}
proc use_result*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib, importc: "mysql_use_result".}
# perform query on master
proc master_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall, dynlib: lib,
importc: "mysql_master_query".}
proc master_send_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall,
dynlib: lib, importc: "mysql_master_send_query".}
# perform query on slave
proc slave_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall, dynlib: lib,
importc: "mysql_slave_query".}
proc slave_send_query*(MySQL: PMySQL, q: cstring, len: int): my_bool{.stdcall,
dynlib: lib, importc: "mysql_slave_send_query".}
proc get_character_set_info*(MySQL: PMySQL, charset: PMY_CHARSET_INFO){.stdcall,
dynlib: lib, importc: "mysql_get_character_set_info".}
# local infile support
const
LOCAL_INFILE_ERROR_LEN* = 512
# procedure mysql_set_local_infile_handler(mysql:PMYSQL; local_infile_init:function (para1:Ppointer; para2:Pchar; para3:pointer):longint; local_infile_read:function (para1:pointer; para2:Pchar; para3:dword):longint; local_infile_end:procedure (_pa
# para6:pointer);cdecl;external mysqllib name 'mysql_set_local_infile_handler';
proc set_local_infile_default*(MySQL: PMySQL){.cdecl, dynlib: lib,
importc: "mysql_set_local_infile_default".}
# enable/disable parsing of all queries to decide if they go on master or
# slave
proc enable_rpl_parse*(MySQL: PMySQL){.stdcall, dynlib: lib,
importc: "mysql_enable_rpl_parse".}
proc disable_rpl_parse*(MySQL: PMySQL){.stdcall, dynlib: lib,
importc: "mysql_disable_rpl_parse".}
# get the value of the parse flag
proc rpl_parse_enabled*(MySQL: PMySQL): cint{.stdcall, dynlib: lib,
importc: "mysql_rpl_parse_enabled".}
# enable/disable reads from master
proc enable_reads_from_master*(MySQL: PMySQL){.stdcall, dynlib: lib,
importc: "mysql_enable_reads_from_master".}
proc disable_reads_from_master*(MySQL: PMySQL){.stdcall, dynlib: lib, importc: "mysql_disable_reads_from_master".}
# get the value of the master read flag
proc reads_from_master_enabled*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib,
importc: "mysql_reads_from_master_enabled".}
proc rpl_query_type*(q: cstring, length: cint): Rpl_type{.stdcall, dynlib: lib,
importc: "mysql_rpl_query_type".}
# discover the master and its slaves
proc rpl_probe*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_rpl_probe".}
# set the master, close/free the old one, if it is not a pivot
proc set_master*(MySQL: PMySQL, host: cstring, port: cuint, user: cstring, passwd: cstring): cint{.
stdcall, dynlib: lib, importc: "mysql_set_master".}
proc add_slave*(MySQL: PMySQL, host: cstring, port: cuint, user: cstring, passwd: cstring): cint{.
stdcall, dynlib: lib, importc: "mysql_add_slave".}
proc shutdown*(MySQL: PMySQL, shutdown_level: Enum_shutdown_level): cint{.stdcall,
dynlib: lib, importc: "mysql_shutdown".}
proc dump_debug_info*(MySQL: PMySQL): cint{.stdcall, dynlib: lib,
importc: "mysql_dump_debug_info".}
proc refresh*(sql: PMySQL, refresh_options: cuint): cint{.stdcall, dynlib: lib,
importc: "mysql_refresh".}
proc kill*(MySQL: PMySQL, pid: int): cint{.stdcall, dynlib: lib, importc: "mysql_kill".}
proc set_server_option*(MySQL: PMySQL, option: Enum_mysql_set_option): cint{.stdcall,
dynlib: lib, importc: "mysql_set_server_option".}
proc ping*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, importc: "mysql_ping".}
proc stat*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib, importc: "mysql_stat".}
proc get_server_info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib,
importc: "mysql_get_server_info".}
proc get_client_info*(): cstring{.stdcall, dynlib: lib,
importc: "mysql_get_client_info".}
proc get_client_version*(): int{.stdcall, dynlib: lib,
importc: "mysql_get_client_version".}
proc get_host_info*(MySQL: PMySQL): cstring{.stdcall, dynlib: lib,
importc: "mysql_get_host_info".}
proc get_server_version*(MySQL: PMySQL): int{.stdcall, dynlib: lib,
importc: "mysql_get_server_version".}
proc get_proto_info*(MySQL: PMySQL): cuint{.stdcall, dynlib: lib,
importc: "mysql_get_proto_info".}
proc list_dbs*(MySQL: PMySQL, wild: cstring): PRES{.stdcall, dynlib: lib,
importc: "mysql_list_dbs".}
proc list_tables*(MySQL: PMySQL, wild: cstring): PRES{.stdcall, dynlib: lib,
importc: "mysql_list_tables".}
proc list_processes*(MySQL: PMySQL): PRES{.stdcall, dynlib: lib,
importc: "mysql_list_processes".}
proc options*(MySQL: PMySQL, option: Option, arg: cstring): cint{.stdcall, dynlib: lib,
importc: "mysql_options".}
proc free_result*(result: PRES){.stdcall, dynlib: lib,
importc: "mysql_free_result".}
proc data_seek*(result: PRES, offset: my_ulonglong){.stdcall, dynlib: lib,
importc: "mysql_data_seek".}
proc row_seek*(result: PRES, offset: ROW_OFFSET): ROW_OFFSET{.stdcall,
dynlib: lib, importc: "mysql_row_seek".}
proc field_seek*(result: PRES, offset: FIELD_OFFSET): FIELD_OFFSET{.stdcall,
dynlib: lib, importc: "mysql_field_seek".}
proc fetch_row*(result: PRES): ROW{.stdcall, dynlib: lib,
importc: "mysql_fetch_row".}
proc fetch_lengths*(result: PRES): ptr int{.stdcall, dynlib: lib,
importc: "mysql_fetch_lengths".}
proc fetch_field*(result: PRES): PFIELD{.stdcall, dynlib: lib,
importc: "mysql_fetch_field".}
proc list_fields*(MySQL: PMySQL, table: cstring, wild: cstring): PRES{.stdcall,
dynlib: lib, importc: "mysql_list_fields".}
proc escape_string*(fto: cstring, `from`: cstring, from_length: int): int{.
stdcall, dynlib: lib, importc: "mysql_escape_string".}
proc hex_string*(fto: cstring, `from`: cstring, from_length: int): int{.stdcall,
dynlib: lib, importc: "mysql_hex_string".}
proc real_escape_string*(MySQL: PMySQL, fto: cstring, `from`: cstring, len: int): int{.
stdcall, dynlib: lib, importc: "mysql_real_escape_string".}
proc debug*(debug: cstring){.stdcall, dynlib: lib, importc: "mysql_debug".}
# function mysql_odbc_escape_string(mysql:PMYSQL; fto:Pchar; to_length:dword; from:Pchar; from_length:dword;
# param:pointer; extend_buffer:function (para1:pointer; to:Pchar; length:Pdword):Pchar):Pchar;stdcall;external mysqllib name 'mysql_odbc_escape_string';
proc myodbc_remove_escape*(MySQL: PMySQL, name: cstring){.stdcall, dynlib: lib,
importc: "myodbc_remove_escape".}
proc thread_safe*(): cuint{.stdcall, dynlib: lib, importc: "mysql_thread_safe".}
proc embedded*(): my_bool{.stdcall, dynlib: lib, importc: "mysql_embedded".}
proc manager_init*(con: PMANAGER): PMANAGER{.stdcall, dynlib: lib,
importc: "mysql_manager_init".}
proc manager_connect*(con: PMANAGER, host: cstring, user: cstring,
passwd: cstring, port: cuint): PMANAGER{.stdcall,
dynlib: lib, importc: "mysql_manager_connect".}
proc manager_close*(con: PMANAGER){.stdcall, dynlib: lib,
importc: "mysql_manager_close".}
proc manager_command*(con: PMANAGER, cmd: cstring, cmd_len: cint): cint{.
stdcall, dynlib: lib, importc: "mysql_manager_command".}
proc manager_fetch_line*(con: PMANAGER, res_buf: cstring, res_buf_size: cint): cint{.
stdcall, dynlib: lib, importc: "mysql_manager_fetch_line".}
proc read_query_result*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib,
importc: "mysql_read_query_result".}
proc stmt_init*(MySQL: PMySQL): PSTMT{.stdcall, dynlib: lib, importc: "mysql_stmt_init".}
proc stmt_prepare*(stmt: PSTMT, query: cstring, len: int): cint{.stdcall,
dynlib: lib, importc: "mysql_stmt_prepare".}
proc stmt_execute*(stmt: PSTMT): cint{.stdcall, dynlib: lib,
importc: "mysql_stmt_execute".}
proc stmt_fetch*(stmt: PSTMT): cint{.stdcall, dynlib: lib,
importc: "mysql_stmt_fetch".}
proc stmt_fetch_column*(stmt: PSTMT, `bind`: PBIND, column: cuint, offset: int): cint{.
stdcall, dynlib: lib, importc: "mysql_stmt_fetch_column".}
proc stmt_store_result*(stmt: PSTMT): cint{.stdcall, dynlib: lib,
importc: "mysql_stmt_store_result".}
proc stmt_param_count*(stmt: PSTMT): int{.stdcall, dynlib: lib,
importc: "mysql_stmt_param_count".}
proc stmt_attr_set*(stmt: PSTMT, attr_type: Enum_stmt_attr_type, attr: pointer): my_bool{.
stdcall, dynlib: lib, importc: "mysql_stmt_attr_set".}
proc stmt_attr_get*(stmt: PSTMT, attr_type: Enum_stmt_attr_type, attr: pointer): my_bool{.
stdcall, dynlib: lib, importc: "mysql_stmt_attr_get".}
proc stmt_bind_param*(stmt: PSTMT, bnd: PBIND): my_bool{.stdcall, dynlib: lib,
importc: "mysql_stmt_bind_param".}
proc stmt_bind_result*(stmt: PSTMT, bnd: PBIND): my_bool{.stdcall, dynlib: lib,
importc: "mysql_stmt_bind_result".}
proc stmt_close*(stmt: PSTMT): my_bool{.stdcall, dynlib: lib,
importc: "mysql_stmt_close".}
proc stmt_reset*(stmt: PSTMT): my_bool{.stdcall, dynlib: lib,
importc: "mysql_stmt_reset".}
proc stmt_free_result*(stmt: PSTMT): my_bool{.stdcall, dynlib: lib,
importc: "mysql_stmt_free_result".}
proc stmt_send_long_data*(stmt: PSTMT, param_number: cuint, data: cstring,
len: int): my_bool{.stdcall, dynlib: lib,
importc: "mysql_stmt_send_long_data".}
proc stmt_result_metadata*(stmt: PSTMT): PRES{.stdcall, dynlib: lib,
importc: "mysql_stmt_result_metadata".}
proc stmt_param_metadata*(stmt: PSTMT): PRES{.stdcall, dynlib: lib,
importc: "mysql_stmt_param_metadata".}
proc stmt_errno*(stmt: PSTMT): cuint{.stdcall, dynlib: lib,
importc: "mysql_stmt_errno".}
proc stmt_error*(stmt: PSTMT): cstring{.stdcall, dynlib: lib,
importc: "mysql_stmt_error".}
proc stmt_sqlstate*(stmt: PSTMT): cstring{.stdcall, dynlib: lib,
importc: "mysql_stmt_sqlstate".}
proc stmt_row_seek*(stmt: PSTMT, offset: ROW_OFFSET): ROW_OFFSET{.stdcall,
dynlib: lib, importc: "mysql_stmt_row_seek".}
proc stmt_row_tell*(stmt: PSTMT): ROW_OFFSET{.stdcall, dynlib: lib,
importc: "mysql_stmt_row_tell".}
proc stmt_data_seek*(stmt: PSTMT, offset: my_ulonglong){.stdcall, dynlib: lib,
importc: "mysql_stmt_data_seek".}
proc stmt_num_rows*(stmt: PSTMT): my_ulonglong{.stdcall, dynlib: lib,
importc: "mysql_stmt_num_rows".}
proc stmt_affected_rows*(stmt: PSTMT): my_ulonglong{.stdcall, dynlib: lib,
importc: "mysql_stmt_affected_rows".}
proc stmt_insert_id*(stmt: PSTMT): my_ulonglong{.stdcall, dynlib: lib,
importc: "mysql_stmt_insert_id".}
proc stmt_field_count*(stmt: PSTMT): cuint{.stdcall, dynlib: lib,
importc: "mysql_stmt_field_count".}
proc commit*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_commit".}
proc rollback*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib, importc: "mysql_rollback".}
proc autocommit*(MySQL: PMySQL, auto_mode: my_bool): my_bool{.stdcall, dynlib: lib,
importc: "mysql_autocommit".}
proc more_results*(MySQL: PMySQL): my_bool{.stdcall, dynlib: lib,
importc: "mysql_more_results".}
proc next_result*(MySQL: PMySQL): cint{.stdcall, dynlib: lib, importc: "mysql_next_result".}
proc close*(sock: PMySQL){.stdcall, dynlib: lib, importc: "mysql_close".}
# status return codes
const
NO_DATA* = 100
DATA_TRUNCATED* = 101
proc reload*(x: PMySQL): cint
when defined(USE_OLD_FUNCTIONS):
proc connect*(MySQL: PMySQL, host: cstring, user: cstring, passwd: cstring): PMySQL{.stdcall,
dynlib: lib, importc: "mysql_connect".}
proc create_db*(MySQL: PMySQL, DB: cstring): cint{.stdcall, dynlib: lib,
importc: "mysql_create_db".}
proc drop_db*(MySQL: PMySQL, DB: cstring): cint{.stdcall, dynlib: lib,
importc: "mysql_drop_db".}
proc net_safe_read*(MySQL: PMySQL): cuint{.cdecl, dynlib: lib, importc: "net_safe_read".}
proc IS_PRI_KEY(n: int32): bool =
result = (n and PRI_KEY_FLAG) != 0
proc IS_NOT_NULL(n: int32): bool =
result = (n and NOT_NULL_FLAG) != 0
proc IS_BLOB(n: int32): bool =
result = (n and BLOB_FLAG) != 0
proc IS_NUM_FIELD(f: Pst_mysql_field): bool =
result = (f.flags and NUM_FLAG) != 0
proc IS_NUM(t: Enum_field_types): bool =
result = (t <= FIELD_TYPE_INT24) or (t == FIELD_TYPE_YEAR) or
(t == FIELD_TYPE_NEWDECIMAL)
proc INTERNAL_NUM_FIELD(f: Pst_mysql_field): bool =
result = (f.ftype <= FIELD_TYPE_INT24) and
((f.ftype != FIELD_TYPE_TIMESTAMP) or (f.len == 14) or (f.len == 8)) or
(f.ftype == FIELD_TYPE_YEAR)
proc reload(x: PMySQL): cint =
result = refresh(x, REFRESH_GRANT)
{.pop.}
|