1 /* 2 Copyright(C) 2009-2018 Brazil 3 Copyright(C) 2018-2021 Sutou Kouhei <kou@clear-code.com> 4 5 This library is free software; you can redistribute it and/or 6 modify it under the terms of the GNU Lesser General Public 7 License as published by the Free Software Foundation; either 8 version 2.1 of the License, or (at your option) any later version. 9 10 This library is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with this library; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 18 */ 19 module groonga_d.groonga; 20 21 22 private static import core.stdc.config; 23 private static import core.stdc.stdarg; 24 private static import core.sys.posix.sys.types; 25 26 extern(C): 27 nothrow @nogc: 28 29 //ToDo: temp 30 version (Windows) { 31 alias off_t = core.stdc.config.c_ulong; 32 } else { 33 alias off_t = core.sys.posix.sys.types.off_t; 34 } 35 36 /+ 37 #ifndef GRN_API 38 # if defined(_WIN32) || defined(_WIN64) 39 # define GRN_API __declspec(dllimport) 40 # else 41 # define GRN_API 42 # endif /* defined(_WIN32) || defined(_WIN64) */ 43 #endif /* GRN_API */ 44 +/ 45 46 alias grn_id = uint; 47 /* Deprecated since 9.0.2. Use bool directly. */ 48 deprecated alias grn_bool = bool; 49 50 enum GRN_ID_NIL = 0x00; 51 enum GRN_ID_MAX = 0x3FFFFFFF; 52 53 enum GRN_TRUE = true; 54 enum GRN_FALSE = false; 55 56 enum grn_rc 57 { 58 GRN_SUCCESS = 0, 59 GRN_END_OF_DATA = 1, 60 GRN_UNKNOWN_ERROR = -1, 61 GRN_OPERATION_NOT_PERMITTED = -2, 62 GRN_NO_SUCH_FILE_OR_DIRECTORY = -3, 63 GRN_NO_SUCH_PROCESS = -4, 64 GRN_INTERRUPTED_FUNCTION_CALL = -5, 65 GRN_INPUT_OUTPUT_ERROR = -6, 66 GRN_NO_SUCH_DEVICE_OR_ADDRESS = -7, 67 GRN_ARG_LIST_TOO_LONG = -8, 68 GRN_EXEC_FORMAT_ERROR = -9, 69 GRN_BAD_FILE_DESCRIPTOR = -10, 70 GRN_NO_CHILD_PROCESSES = -11, 71 GRN_RESOURCE_TEMPORARILY_UNAVAILABLE = -12, 72 GRN_NOT_ENOUGH_SPACE = -13, 73 GRN_PERMISSION_DENIED = -14, 74 GRN_BAD_ADDRESS = -15, 75 GRN_RESOURCE_BUSY = -16, 76 GRN_FILE_EXISTS = -17, 77 GRN_IMPROPER_LINK = -18, 78 GRN_NO_SUCH_DEVICE = -19, 79 GRN_NOT_A_DIRECTORY = -20, 80 GRN_IS_A_DIRECTORY = -21, 81 GRN_INVALID_ARGUMENT = -22, 82 GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM = -23, 83 GRN_TOO_MANY_OPEN_FILES = -24, 84 GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION = -25, 85 GRN_FILE_TOO_LARGE = -26, 86 GRN_NO_SPACE_LEFT_ON_DEVICE = -27, 87 GRN_INVALID_SEEK = -28, 88 GRN_READ_ONLY_FILE_SYSTEM = -29, 89 GRN_TOO_MANY_LINKS = -30, 90 GRN_BROKEN_PIPE = -31, 91 GRN_DOMAIN_ERROR = -32, 92 GRN_RESULT_TOO_LARGE = -33, 93 GRN_RESOURCE_DEADLOCK_AVOIDED = -34, 94 GRN_NO_MEMORY_AVAILABLE = -35, 95 GRN_FILENAME_TOO_LONG = -36, 96 GRN_NO_LOCKS_AVAILABLE = -37, 97 GRN_FUNCTION_NOT_IMPLEMENTED = -38, 98 GRN_DIRECTORY_NOT_EMPTY = -39, 99 GRN_ILLEGAL_BYTE_SEQUENCE = -40, 100 GRN_SOCKET_NOT_INITIALIZED = -41, 101 GRN_OPERATION_WOULD_BLOCK = -42, 102 GRN_ADDRESS_IS_NOT_AVAILABLE = -43, 103 GRN_NETWORK_IS_DOWN = -44, 104 GRN_NO_BUFFER = -45, 105 GRN_SOCKET_IS_ALREADY_CONNECTED = -46, 106 GRN_SOCKET_IS_NOT_CONNECTED = -47, 107 GRN_SOCKET_IS_ALREADY_SHUTDOWNED = -48, 108 GRN_OPERATION_TIMEOUT = -49, 109 GRN_CONNECTION_REFUSED = -50, 110 GRN_RANGE_ERROR = -51, 111 GRN_TOKENIZER_ERROR = -52, 112 GRN_FILE_CORRUPT = -53, 113 GRN_INVALID_FORMAT = -54, 114 GRN_OBJECT_CORRUPT = -55, 115 GRN_TOO_MANY_SYMBOLIC_LINKS = -56, 116 GRN_NOT_SOCKET = -57, 117 GRN_OPERATION_NOT_SUPPORTED = -58, 118 GRN_ADDRESS_IS_IN_USE = -59, 119 GRN_ZLIB_ERROR = -60, 120 GRN_LZ4_ERROR = -61, 121 122 /** 123 * Just for backward compatibility. We'll remove it at 5.0.0. 124 */ 125 GRN_LZO_ERROR = GRN_LZ4_ERROR, 126 127 GRN_STACK_OVER_FLOW = -62, 128 GRN_SYNTAX_ERROR = -63, 129 GRN_RETRY_MAX = -64, 130 GRN_INCOMPATIBLE_FILE_FORMAT = -65, 131 GRN_UPDATE_NOT_ALLOWED = -66, 132 GRN_TOO_SMALL_OFFSET = -67, 133 GRN_TOO_LARGE_OFFSET = -68, 134 GRN_TOO_SMALL_LIMIT = -69, 135 GRN_CAS_ERROR = -70, 136 GRN_UNSUPPORTED_COMMAND_VERSION = -71, 137 GRN_NORMALIZER_ERROR = -72, 138 GRN_TOKEN_FILTER_ERROR = -73, 139 GRN_COMMAND_ERROR = -74, 140 GRN_PLUGIN_ERROR = -75, 141 GRN_SCORER_ERROR = -76, 142 GRN_CANCEL = -77, 143 GRN_WINDOW_FUNCTION_ERROR = -78, 144 GRN_ZSTD_ERROR = -79, 145 GRN_CONNECTION_RESET = -80, 146 } 147 148 //Declaration name in C language 149 enum 150 { 151 GRN_SUCCESS = .grn_rc.GRN_SUCCESS, 152 GRN_END_OF_DATA = .grn_rc.GRN_END_OF_DATA, 153 GRN_UNKNOWN_ERROR = .grn_rc.GRN_UNKNOWN_ERROR, 154 GRN_OPERATION_NOT_PERMITTED = .grn_rc.GRN_OPERATION_NOT_PERMITTED, 155 GRN_NO_SUCH_FILE_OR_DIRECTORY = .grn_rc.GRN_NO_SUCH_FILE_OR_DIRECTORY, 156 GRN_NO_SUCH_PROCESS = .grn_rc.GRN_NO_SUCH_PROCESS, 157 GRN_INTERRUPTED_FUNCTION_CALL = .grn_rc.GRN_INTERRUPTED_FUNCTION_CALL, 158 GRN_INPUT_OUTPUT_ERROR = .grn_rc.GRN_INPUT_OUTPUT_ERROR, 159 GRN_NO_SUCH_DEVICE_OR_ADDRESS = .grn_rc.GRN_NO_SUCH_DEVICE_OR_ADDRESS, 160 GRN_ARG_LIST_TOO_LONG = .grn_rc.GRN_ARG_LIST_TOO_LONG, 161 GRN_EXEC_FORMAT_ERROR = .grn_rc.GRN_EXEC_FORMAT_ERROR, 162 GRN_BAD_FILE_DESCRIPTOR = .grn_rc.GRN_BAD_FILE_DESCRIPTOR, 163 GRN_NO_CHILD_PROCESSES = .grn_rc.GRN_NO_CHILD_PROCESSES, 164 GRN_RESOURCE_TEMPORARILY_UNAVAILABLE = .grn_rc.GRN_RESOURCE_TEMPORARILY_UNAVAILABLE, 165 GRN_NOT_ENOUGH_SPACE = .grn_rc.GRN_NOT_ENOUGH_SPACE, 166 GRN_PERMISSION_DENIED = .grn_rc.GRN_PERMISSION_DENIED, 167 GRN_BAD_ADDRESS = .grn_rc.GRN_BAD_ADDRESS, 168 GRN_RESOURCE_BUSY = .grn_rc.GRN_RESOURCE_BUSY, 169 GRN_FILE_EXISTS = .grn_rc.GRN_FILE_EXISTS, 170 GRN_IMPROPER_LINK = .grn_rc.GRN_IMPROPER_LINK, 171 GRN_NO_SUCH_DEVICE = .grn_rc.GRN_NO_SUCH_DEVICE, 172 GRN_NOT_A_DIRECTORY = .grn_rc.GRN_NOT_A_DIRECTORY, 173 GRN_IS_A_DIRECTORY = .grn_rc.GRN_IS_A_DIRECTORY, 174 GRN_INVALID_ARGUMENT = .grn_rc.GRN_INVALID_ARGUMENT, 175 GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM = .grn_rc.GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM, 176 GRN_TOO_MANY_OPEN_FILES = .grn_rc.GRN_TOO_MANY_OPEN_FILES, 177 GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION = .grn_rc.GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION, 178 GRN_FILE_TOO_LARGE = .grn_rc.GRN_FILE_TOO_LARGE, 179 GRN_NO_SPACE_LEFT_ON_DEVICE = .grn_rc.GRN_NO_SPACE_LEFT_ON_DEVICE, 180 GRN_INVALID_SEEK = .grn_rc.GRN_INVALID_SEEK, 181 GRN_READ_ONLY_FILE_SYSTEM = .grn_rc.GRN_READ_ONLY_FILE_SYSTEM, 182 GRN_TOO_MANY_LINKS = .grn_rc.GRN_TOO_MANY_LINKS, 183 GRN_BROKEN_PIPE = .grn_rc.GRN_BROKEN_PIPE, 184 GRN_DOMAIN_ERROR = .grn_rc.GRN_DOMAIN_ERROR, 185 GRN_RESULT_TOO_LARGE = .grn_rc.GRN_RESULT_TOO_LARGE, 186 GRN_RESOURCE_DEADLOCK_AVOIDED = .grn_rc.GRN_RESOURCE_DEADLOCK_AVOIDED, 187 GRN_NO_MEMORY_AVAILABLE = .grn_rc.GRN_NO_MEMORY_AVAILABLE, 188 GRN_FILENAME_TOO_LONG = .grn_rc.GRN_FILENAME_TOO_LONG, 189 GRN_NO_LOCKS_AVAILABLE = .grn_rc.GRN_NO_LOCKS_AVAILABLE, 190 GRN_FUNCTION_NOT_IMPLEMENTED = .grn_rc.GRN_FUNCTION_NOT_IMPLEMENTED, 191 GRN_DIRECTORY_NOT_EMPTY = .grn_rc.GRN_DIRECTORY_NOT_EMPTY, 192 GRN_ILLEGAL_BYTE_SEQUENCE = .grn_rc.GRN_ILLEGAL_BYTE_SEQUENCE, 193 GRN_SOCKET_NOT_INITIALIZED = .grn_rc.GRN_SOCKET_NOT_INITIALIZED, 194 GRN_OPERATION_WOULD_BLOCK = .grn_rc.GRN_OPERATION_WOULD_BLOCK, 195 GRN_ADDRESS_IS_NOT_AVAILABLE = .grn_rc.GRN_ADDRESS_IS_NOT_AVAILABLE, 196 GRN_NETWORK_IS_DOWN = .grn_rc.GRN_NETWORK_IS_DOWN, 197 GRN_NO_BUFFER = .grn_rc.GRN_NO_BUFFER, 198 GRN_SOCKET_IS_ALREADY_CONNECTED = .grn_rc.GRN_SOCKET_IS_ALREADY_CONNECTED, 199 GRN_SOCKET_IS_NOT_CONNECTED = .grn_rc.GRN_SOCKET_IS_NOT_CONNECTED, 200 GRN_SOCKET_IS_ALREADY_SHUTDOWNED = .grn_rc.GRN_SOCKET_IS_ALREADY_SHUTDOWNED, 201 GRN_OPERATION_TIMEOUT = .grn_rc.GRN_OPERATION_TIMEOUT, 202 GRN_CONNECTION_REFUSED = .grn_rc.GRN_CONNECTION_REFUSED, 203 GRN_RANGE_ERROR = .grn_rc.GRN_RANGE_ERROR, 204 GRN_TOKENIZER_ERROR = .grn_rc.GRN_TOKENIZER_ERROR, 205 GRN_FILE_CORRUPT = .grn_rc.GRN_FILE_CORRUPT, 206 GRN_INVALID_FORMAT = .grn_rc.GRN_INVALID_FORMAT, 207 GRN_OBJECT_CORRUPT = .grn_rc.GRN_OBJECT_CORRUPT, 208 GRN_TOO_MANY_SYMBOLIC_LINKS = .grn_rc.GRN_TOO_MANY_SYMBOLIC_LINKS, 209 GRN_NOT_SOCKET = .grn_rc.GRN_NOT_SOCKET, 210 GRN_OPERATION_NOT_SUPPORTED = .grn_rc.GRN_OPERATION_NOT_SUPPORTED, 211 GRN_ADDRESS_IS_IN_USE = .grn_rc.GRN_ADDRESS_IS_IN_USE, 212 GRN_ZLIB_ERROR = .grn_rc.GRN_ZLIB_ERROR, 213 GRN_LZ4_ERROR = .grn_rc.GRN_LZ4_ERROR, 214 GRN_LZO_ERROR = .grn_rc.GRN_LZO_ERROR, 215 GRN_STACK_OVER_FLOW = .grn_rc.GRN_STACK_OVER_FLOW, 216 GRN_SYNTAX_ERROR = .grn_rc.GRN_SYNTAX_ERROR, 217 GRN_RETRY_MAX = .grn_rc.GRN_RETRY_MAX, 218 GRN_INCOMPATIBLE_FILE_FORMAT = .grn_rc.GRN_INCOMPATIBLE_FILE_FORMAT, 219 GRN_UPDATE_NOT_ALLOWED = .grn_rc.GRN_UPDATE_NOT_ALLOWED, 220 GRN_TOO_SMALL_OFFSET = .grn_rc.GRN_TOO_SMALL_OFFSET, 221 GRN_TOO_LARGE_OFFSET = .grn_rc.GRN_TOO_LARGE_OFFSET, 222 GRN_TOO_SMALL_LIMIT = .grn_rc.GRN_TOO_SMALL_LIMIT, 223 GRN_CAS_ERROR = .grn_rc.GRN_CAS_ERROR, 224 GRN_UNSUPPORTED_COMMAND_VERSION = .grn_rc.GRN_UNSUPPORTED_COMMAND_VERSION, 225 GRN_NORMALIZER_ERROR = .grn_rc.GRN_NORMALIZER_ERROR, 226 GRN_TOKEN_FILTER_ERROR = .grn_rc.GRN_TOKEN_FILTER_ERROR, 227 GRN_COMMAND_ERROR = .grn_rc.GRN_COMMAND_ERROR, 228 GRN_PLUGIN_ERROR = .grn_rc.GRN_PLUGIN_ERROR, 229 GRN_SCORER_ERROR = .grn_rc.GRN_SCORER_ERROR, 230 GRN_CANCEL = .grn_rc.GRN_CANCEL, 231 GRN_WINDOW_FUNCTION_ERROR = .grn_rc.GRN_WINDOW_FUNCTION_ERROR, 232 GRN_ZSTD_ERROR = .grn_rc.GRN_ZSTD_ERROR, 233 GRN_CONNECTION_RESET = .grn_rc.GRN_CONNECTION_RESET, 234 } 235 236 //GRN_API 237 .grn_rc grn_init(); 238 239 //GRN_API 240 .grn_rc grn_fin(); 241 242 //GRN_API 243 const (char)* grn_get_global_error_message(); 244 245 enum grn_encoding 246 { 247 GRN_ENC_DEFAULT = 0, 248 GRN_ENC_NONE, 249 GRN_ENC_EUC_JP, 250 GRN_ENC_UTF8, 251 GRN_ENC_SJIS, 252 GRN_ENC_LATIN1, 253 GRN_ENC_KOI8R, 254 } 255 256 //Declaration name in C language 257 enum 258 { 259 GRN_ENC_DEFAULT = .grn_encoding.GRN_ENC_DEFAULT, 260 GRN_ENC_NONE = .grn_encoding.GRN_ENC_NONE, 261 GRN_ENC_EUC_JP = .grn_encoding.GRN_ENC_EUC_JP, 262 GRN_ENC_UTF8 = .grn_encoding.GRN_ENC_UTF8, 263 GRN_ENC_SJIS = .grn_encoding.GRN_ENC_SJIS, 264 GRN_ENC_LATIN1 = .grn_encoding.GRN_ENC_LATIN1, 265 GRN_ENC_KOI8R = .grn_encoding.GRN_ENC_KOI8R, 266 } 267 268 enum grn_command_version 269 { 270 GRN_COMMAND_VERSION_DEFAULT = 0, 271 GRN_COMMAND_VERSION_1, 272 GRN_COMMAND_VERSION_2, 273 GRN_COMMAND_VERSION_3, 274 } 275 276 //Declaration name in C language 277 enum 278 { 279 GRN_COMMAND_VERSION_DEFAULT = .grn_command_version.GRN_COMMAND_VERSION_DEFAULT, 280 GRN_COMMAND_VERSION_1 = .grn_command_version.GRN_COMMAND_VERSION_1, 281 GRN_COMMAND_VERSION_2 = .grn_command_version.GRN_COMMAND_VERSION_2, 282 GRN_COMMAND_VERSION_3 = .grn_command_version.GRN_COMMAND_VERSION_3, 283 } 284 285 enum GRN_COMMAND_VERSION_MIN = .grn_command_version.GRN_COMMAND_VERSION_1; 286 enum GRN_COMMAND_VERSION_STABLE = .grn_command_version.GRN_COMMAND_VERSION_1; 287 enum GRN_COMMAND_VERSION_MAX = .grn_command_version.GRN_COMMAND_VERSION_3; 288 289 enum grn_log_level 290 { 291 GRN_LOG_NONE = 0, 292 GRN_LOG_EMERG, 293 GRN_LOG_ALERT, 294 GRN_LOG_CRIT, 295 GRN_LOG_ERROR, 296 GRN_LOG_WARNING, 297 GRN_LOG_NOTICE, 298 GRN_LOG_INFO, 299 GRN_LOG_DEBUG, 300 GRN_LOG_DUMP, 301 } 302 303 //Declaration name in C language 304 enum 305 { 306 //GRN_LOG_NONE = .grn_log_level.GRN_LOG_NONE, 307 GRN_LOG_EMERG = .grn_log_level.GRN_LOG_EMERG, 308 GRN_LOG_ALERT = .grn_log_level.GRN_LOG_ALERT, 309 GRN_LOG_CRIT = .grn_log_level.GRN_LOG_CRIT, 310 GRN_LOG_ERROR = .grn_log_level.GRN_LOG_ERROR, 311 GRN_LOG_WARNING = .grn_log_level.GRN_LOG_WARNING, 312 GRN_LOG_NOTICE = .grn_log_level.GRN_LOG_NOTICE, 313 GRN_LOG_INFO = .grn_log_level.GRN_LOG_INFO, 314 GRN_LOG_DEBUG = .grn_log_level.GRN_LOG_DEBUG, 315 GRN_LOG_DUMP = .grn_log_level.GRN_LOG_DUMP, 316 } 317 318 //GRN_API 319 const (char)* grn_log_level_to_string(.grn_log_level level); 320 321 //GRN_API 322 .grn_bool grn_log_level_parse(const (char)* string_, .grn_log_level* level); 323 324 /* query log flags */ 325 enum GRN_QUERY_LOG_NONE = 0x00; 326 enum GRN_QUERY_LOG_COMMAND = 0x01 << 0; 327 enum GRN_QUERY_LOG_RESULT_CODE = 0x01 << 1; 328 enum GRN_QUERY_LOG_DESTINATION = 0x01 << 2; 329 enum GRN_QUERY_LOG_CACHE = 0x01 << 3; 330 enum GRN_QUERY_LOG_SIZE = 0x01 << 4; 331 enum GRN_QUERY_LOG_SCORE = 0x01 << 5; 332 enum GRN_QUERY_LOG_ALL = .GRN_QUERY_LOG_COMMAND | .GRN_QUERY_LOG_RESULT_CODE | .GRN_QUERY_LOG_DESTINATION | .GRN_QUERY_LOG_CACHE | .GRN_QUERY_LOG_SIZE | .GRN_QUERY_LOG_SCORE; 333 enum GRN_QUERY_LOG_DEFAULT = .GRN_QUERY_LOG_ALL; 334 335 enum grn_content_type 336 { 337 GRN_CONTENT_NONE = 0, 338 GRN_CONTENT_TSV, 339 GRN_CONTENT_JSON, 340 GRN_CONTENT_XML, 341 GRN_CONTENT_MSGPACK, 342 GRN_CONTENT_GROONGA_COMMAND_LIST, 343 GRN_CONTENT_APACHE_ARROW, 344 } 345 346 //Declaration name in C language 347 enum 348 { 349 GRN_CONTENT_NONE = .grn_content_type.GRN_CONTENT_NONE, 350 GRN_CONTENT_TSV = .grn_content_type.GRN_CONTENT_TSV, 351 GRN_CONTENT_JSON = .grn_content_type.GRN_CONTENT_JSON, 352 GRN_CONTENT_XML = .grn_content_type.GRN_CONTENT_XML, 353 GRN_CONTENT_MSGPACK = .grn_content_type.GRN_CONTENT_MSGPACK, 354 GRN_CONTENT_GROONGA_COMMAND_LIST = .grn_content_type.GRN_CONTENT_GROONGA_COMMAND_LIST, 355 GRN_CONTENT_APACHE_ARROW = .grn_content_type.GRN_CONTENT_APACHE_ARROW, 356 } 357 358 enum GRN_CTX_MSGSIZE = 0x80; 359 enum GRN_CTX_FIN = 0xFF; 360 361 alias grn_close_func = extern (C) void function (.grn_ctx* ctx, void* data); 362 363 union grn_user_data 364 { 365 int int_value; 366 .grn_id id; 367 void* ptr_; 368 369 deprecated 370 alias ptr = ptr_; 371 } 372 373 alias grn_proc_func = extern (C) .grn_obj* function(.grn_ctx* ctx, int nargs, .grn_obj** args, grn_user_data* user_data); 374 375 extern struct _grn_ctx_impl; 376 377 struct _grn_ctx 378 { 379 .grn_rc rc; 380 int flags; 381 .grn_encoding encoding; 382 ubyte ntrace; 383 ubyte errlvl; 384 ubyte stat; 385 uint seqno; 386 uint subno; 387 uint seqno2; 388 uint errline; 389 grn_user_data user_data; 390 .grn_ctx* prev; 391 .grn_ctx* next; 392 const (char)* errfile; 393 const (char)* errfunc; 394 ._grn_ctx_impl* impl; 395 396 //ToDo: Check 397 void*[16] trace; 398 399 char[.GRN_CTX_MSGSIZE] errbuf = '\0'; 400 } 401 402 alias grn_ctx = ._grn_ctx; 403 404 pragma(inline, true) 405 pure nothrow @trusted @nogc @live 406 grn_user_data* GRN_CTX_USER_DATA(return scope .grn_ctx* ctx) 407 408 in 409 { 410 assert(ctx != null); 411 } 412 413 do 414 { 415 return &(ctx.user_data); 416 } 417 418 /* Deprecated since 4.0.3. Don't use it. */ 419 enum GRN_CTX_USE_QL = 0x03; 420 /* Deprecated since 4.0.3. Don't use it. */ 421 enum GRN_CTX_BATCH_MODE = 0x04; 422 enum GRN_CTX_PER_DB = 0x08; 423 424 //GRN_API 425 .grn_rc grn_ctx_init(.grn_ctx* ctx, int flags); 426 427 //GRN_API 428 .grn_rc grn_ctx_fin(.grn_ctx* ctx); 429 430 //GRN_API 431 .grn_ctx* grn_ctx_open(int flags); 432 433 //GRN_API 434 .grn_rc grn_ctx_close(.grn_ctx* ctx); 435 436 //GRN_API 437 .grn_rc grn_ctx_set_finalizer(.grn_ctx* ctx, grn_proc_func* func); 438 439 //GRN_API 440 .grn_rc grn_ctx_push_temporary_open_space(.grn_ctx* ctx); 441 442 //GRN_API 443 .grn_rc grn_ctx_pop_temporary_open_space(.grn_ctx* ctx); 444 445 //GRN_API 446 .grn_rc grn_ctx_merge_temporary_open_space(.grn_ctx* ctx); 447 448 //GRN_API 449 .grn_encoding grn_get_default_encoding(); 450 451 //GRN_API 452 .grn_rc grn_set_default_encoding(.grn_encoding encoding); 453 454 pragma(inline, true) 455 pure nothrow @trusted @nogc @live 456 .grn_encoding GRN_CTX_GET_ENCODING(scope const .grn_ctx* ctx) 457 458 in 459 { 460 assert(ctx != null); 461 } 462 463 do 464 { 465 return ctx.encoding; 466 } 467 468 pragma(inline, true) 469 void GRN_CTX_SET_ENCODING(scope .grn_ctx* ctx, .grn_encoding enc) 470 471 in 472 { 473 assert(ctx != null); 474 } 475 476 do 477 { 478 ctx.encoding = (enc == .grn_encoding.GRN_ENC_DEFAULT) ? (.grn_get_default_encoding()) : (enc); 479 } 480 481 //GRN_API 482 const (char)* grn_get_version(); 483 484 //GRN_API 485 uint grn_get_version_major(); 486 487 //GRN_API 488 uint grn_get_version_minor(); 489 490 //GRN_API 491 uint grn_get_version_micro(); 492 493 //GRN_API 494 const (char)* grn_get_package(); 495 496 //GRN_API 497 const (char)* grn_get_package_label(); 498 499 //GRN_API 500 .grn_command_version grn_get_default_command_version(); 501 502 //GRN_API 503 .grn_rc grn_set_default_command_version(.grn_command_version input_version); 504 505 //GRN_API 506 .grn_command_version grn_ctx_get_command_version(.grn_ctx* ctx); 507 508 //GRN_API 509 .grn_rc grn_ctx_set_command_version(.grn_ctx* ctx, .grn_command_version input_version); 510 511 //GRN_API 512 long grn_ctx_get_match_escalation_threshold(.grn_ctx* ctx); 513 514 //GRN_API 515 .grn_rc grn_ctx_set_match_escalation_threshold(.grn_ctx* ctx, long threshold); 516 517 //GRN_API 518 .grn_bool grn_ctx_get_force_match_escalation(.grn_ctx* ctx); 519 520 //GRN_API 521 .grn_rc grn_ctx_set_force_match_escalation(.grn_ctx* ctx, .grn_bool force); 522 523 //GRN_API 524 long grn_get_default_match_escalation_threshold(); 525 526 //GRN_API 527 .grn_rc grn_set_default_match_escalation_threshold(long threshold); 528 529 //GRN_API 530 grn_rc grn_ctx_set_variable(.grn_ctx* ctx, const (char)* name, int name_size, void* data, .grn_close_func close_func); 531 532 //GRN_API 533 void* grn_ctx_get_variable(.grn_ctx* ctx, const (char)* name, int name_size); 534 535 //GRN_API 536 grn_rc grn_unset_variable(const (char)* name, int name_size); 537 538 //GRN_API 539 int grn_get_lock_timeout(); 540 541 //GRN_API 542 .grn_rc grn_set_lock_timeout(int timeout); 543 544 /* .grn_encoding */ 545 546 //GRN_API 547 const (char)* grn_encoding_to_string(.grn_encoding encoding); 548 549 //GRN_API 550 .grn_encoding grn_encoding_parse(const (char)* name); 551 552 /* obj */ 553 554 alias grn_obj_flags = ushort; 555 alias grn_table_flags = uint; 556 alias grn_column_flags = uint; 557 558 /* flags for grn_obj_flags and grn_table_flags */ 559 560 enum GRN_OBJ_FLAGS_MASK = 0xFFFF; 561 562 enum GRN_OBJ_TABLE_TYPE_MASK = 0x07; 563 enum GRN_OBJ_TABLE_HASH_KEY = 0x00; 564 enum GRN_OBJ_TABLE_PAT_KEY = 0x01; 565 enum GRN_OBJ_TABLE_DAT_KEY = 0x02; 566 enum GRN_OBJ_TABLE_NO_KEY = 0x03; 567 568 enum GRN_OBJ_KEY_MASK = 0x07 << 3; 569 enum GRN_OBJ_KEY_UINT = 0x00 << 3; 570 enum GRN_OBJ_KEY_INT = 0x01 << 3; 571 enum GRN_OBJ_KEY_FLOAT = 0x02 << 3; 572 enum GRN_OBJ_KEY_GEO_POINT = 0x03 << 3; 573 574 enum GRN_OBJ_KEY_WITH_SIS = 0x01 << 6; 575 enum GRN_OBJ_KEY_NORMALIZE = 0x01 << 7; 576 577 /* flags for grn_obj_flags and grn_column_flags */ 578 579 enum GRN_OBJ_COLUMN_TYPE_MASK = 0x07; 580 enum GRN_OBJ_COLUMN_SCALAR = 0x00; 581 enum GRN_OBJ_COLUMN_VECTOR = 0x01; 582 enum GRN_OBJ_COLUMN_INDEX = 0x02; 583 584 enum GRN_OBJ_COMPRESS_MASK = 0x07 << 4; 585 enum GRN_OBJ_COMPRESS_NONE = 0x00 << 4; 586 enum GRN_OBJ_COMPRESS_ZLIB = 0x01 << 4; 587 enum GRN_OBJ_COMPRESS_LZ4 = 0x02 << 4; 588 /* Just for backward compatibility. We'll remove it at 5.0.0. */ 589 enum GRN_OBJ_COMPRESS_LZO = .GRN_OBJ_COMPRESS_LZ4; 590 enum GRN_OBJ_COMPRESS_ZSTD = 0x03 << 4; 591 592 enum GRN_OBJ_WITH_SECTION = 0x01 << 7; 593 enum GRN_OBJ_WITH_WEIGHT = 0x01 << 8; 594 enum GRN_OBJ_WITH_POSITION = 0x01 << 9; 595 enum GRN_OBJ_RING_BUFFER = 0x01 << 10; 596 597 enum GRN_OBJ_UNIT_MASK = 0x0F << 8; 598 enum GRN_OBJ_UNIT_DOCUMENT_NONE = 0x00 << 8; 599 enum GRN_OBJ_UNIT_DOCUMENT_SECTION = 0x01 << 8; 600 enum GRN_OBJ_UNIT_DOCUMENT_POSITION = 0x02 << 8; 601 enum GRN_OBJ_UNIT_SECTION_NONE = 0x03 << 8; 602 enum GRN_OBJ_UNIT_SECTION_POSITION = 0x04 << 8; 603 enum GRN_OBJ_UNIT_POSITION_NONE = 0x05 << 8; 604 enum GRN_OBJ_UNIT_USERDEF_DOCUMENT = 0x06 << 8; 605 enum GRN_OBJ_UNIT_USERDEF_SECTION = 0x07 << 8; 606 enum GRN_OBJ_UNIT_USERDEF_POSITION = 0x08 << 8; 607 608 /* Don't use (0x01<<12) because it's used internally. */ 609 610 enum GRN_OBJ_NO_SUBREC = 0x00 << 13; 611 enum GRN_OBJ_WITH_SUBREC = 0x01 << 13; 612 613 enum GRN_OBJ_KEY_VAR_SIZE = 0x01 << 14; 614 615 enum GRN_OBJ_TEMPORARY = 0x00 << 15; 616 enum GRN_OBJ_PERSISTENT = 0x01 << 15; 617 618 /* flags only for grn_table_flags */ 619 620 enum GRN_OBJ_KEY_LARGE = 0x01 << 16; 621 622 /* flags only for grn_column_flags */ 623 624 enum GRN_OBJ_INDEX_SMALL = 0x01 << 16; 625 enum GRN_OBJ_INDEX_MEDIUM = 0x01 << 17; 626 enum GRN_OBJ_INDEX_LARGE = 0x01 << 18; 627 enum GRN_OBJ_WEIGHT_FLOAT32 = 0x01 << 19; 628 629 /* flags only for grn_table_flags and grn_column_flags */ 630 631 /* GRN_COLUMN_INDEX only uses this for now */ 632 enum GRN_OBJ_VISIBLE = cast(uint)(0x00 << 31); 633 enum GRN_OBJ_INVISIBLE = cast(uint)(0x01 << 31); 634 635 /* obj types */ 636 637 enum GRN_VOID = 0x00; 638 enum GRN_BULK = 0x02; 639 enum GRN_PTR = 0x03; 640 641 /* vector of fixed size data especially grn_id */ 642 enum GRN_UVECTOR = 0x04; 643 644 /* vector of .grn_obj* */ 645 enum GRN_PVECTOR = 0x05; 646 647 /* vector of arbitrary data */ 648 enum GRN_VECTOR = 0x06; 649 650 enum GRN_MSG = 0x07; 651 enum GRN_QUERY = 0x08; 652 enum GRN_ACCESSOR = 0x09; 653 enum GRN_SNIP = 0x0B; 654 enum GRN_PATSNIP = 0x0C; 655 enum GRN_STRING = 0x0D; 656 enum GRN_HIGHLIGHTER = 0x0E; 657 enum GRN_CURSOR_TABLE_HASH_KEY = 0x10; 658 enum GRN_CURSOR_TABLE_PAT_KEY = 0x11; 659 enum GRN_CURSOR_TABLE_DAT_KEY = 0x12; 660 enum GRN_CURSOR_TABLE_NO_KEY = 0x13; 661 enum GRN_CURSOR_COLUMN_INDEX = 0x18; 662 enum GRN_CURSOR_COLUMN_GEO_INDEX = 0x1A; 663 enum GRN_CURSOR_CONFIG = 0x1F; 664 enum GRN_TYPE = 0x20; 665 enum GRN_PROC = 0x21; 666 enum GRN_EXPR = 0x22; 667 enum GRN_TABLE_HASH_KEY = 0x30; 668 enum GRN_TABLE_PAT_KEY = 0x31; 669 enum GRN_TABLE_DAT_KEY = 0x32; 670 enum GRN_TABLE_NO_KEY = 0x33; 671 enum GRN_DB = 0x37; 672 enum GRN_COLUMN_FIX_SIZE = 0x40; 673 enum GRN_COLUMN_VAR_SIZE = 0x41; 674 enum GRN_COLUMN_INDEX = 0x48; 675 676 struct _grn_section 677 { 678 uint offset; 679 uint length; 680 float weight = 0; 681 .grn_id domain; 682 } 683 684 alias grn_section = ._grn_section; 685 686 struct _grn_obj_header 687 { 688 ubyte type; 689 ubyte impl_flags; 690 .grn_obj_flags flags; 691 .grn_id domain; 692 } 693 694 alias grn_obj_header = ._grn_obj_header; 695 696 struct _grn_obj 697 { 698 .grn_obj_header header; 699 700 union u_ 701 { 702 struct b_ 703 { 704 char* head; 705 char* curr; 706 char* tail; 707 } 708 709 b_ b; 710 711 struct v_ 712 { 713 .grn_obj* body_; 714 .grn_section* sections; 715 uint n_sections; 716 } 717 718 v_ v; 719 } 720 721 u_ u; 722 } 723 724 alias grn_obj = ._grn_obj; 725 726 enum GRN_OBJ_REFER = 0x01 << 0; 727 enum GRN_OBJ_OUTPLACE = 0x01 << 1; 728 enum GRN_OBJ_OWN = 0x01 << 5; 729 730 pragma(inline, true) 731 pure nothrow @trusted @nogc @live 732 void GRN_OBJ_INIT(scope .grn_obj* obj, ubyte obj_type, ubyte obj_flags, .grn_id obj_domain) 733 734 in 735 { 736 assert(obj != null); 737 } 738 739 do 740 { 741 obj.header.type = obj_type; 742 obj.header.impl_flags = obj_flags; 743 obj.header.flags = 0; 744 obj.header.domain = obj_domain; 745 obj.u.b.head = null; 746 obj.u.b.curr = null; 747 obj.u.b.tail = null; 748 } 749 750 alias GRN_OBJ_FIN = grn_obj_close; 751 752 //GRN_API 753 .grn_rc grn_ctx_use(.grn_ctx* ctx, .grn_obj* db); 754 755 //GRN_API 756 .grn_obj* grn_ctx_db(.grn_ctx* ctx); 757 758 //GRN_API 759 .grn_obj* grn_ctx_get(.grn_ctx* ctx, const (char)* name, int name_size); 760 761 //GRN_API 762 .grn_rc grn_ctx_get_all_tables(.grn_ctx* ctx, .grn_obj* tables_buffer); 763 764 //GRN_API 765 .grn_rc grn_ctx_get_all_types(.grn_ctx* ctx, .grn_obj* types_buffer); 766 767 //GRN_API 768 .grn_rc grn_ctx_get_all_tokenizers(.grn_ctx* ctx, .grn_obj* tokenizers_buffer); 769 770 //GRN_API 771 .grn_rc grn_ctx_get_all_normalizers(.grn_ctx* ctx, .grn_obj* normalizers_buffer); 772 773 //GRN_API 774 .grn_rc grn_ctx_get_all_token_filters(.grn_ctx* ctx, .grn_obj* token_filters_buffer); 775 776 enum grn_builtin_type 777 { 778 GRN_DB_VOID = 0, 779 GRN_DB_DB, 780 GRN_DB_OBJECT, 781 GRN_DB_BOOL, 782 GRN_DB_INT8, 783 GRN_DB_UINT8, 784 GRN_DB_INT16, 785 GRN_DB_UINT16, 786 GRN_DB_INT32, 787 GRN_DB_UINT32, 788 GRN_DB_INT64, 789 GRN_DB_UINT64, 790 GRN_DB_FLOAT, 791 GRN_DB_TIME, 792 GRN_DB_SHORT_TEXT, 793 GRN_DB_TEXT, 794 GRN_DB_LONG_TEXT, 795 GRN_DB_TOKYO_GEO_POINT, 796 GRN_DB_WGS84_GEO_POINT, 797 GRN_DB_FLOAT32, 798 } 799 800 //Declaration name in C language 801 enum 802 { 803 GRN_DB_VOID = .grn_builtin_type.GRN_DB_VOID, 804 GRN_DB_DB = .grn_builtin_type.GRN_DB_DB, 805 GRN_DB_OBJECT = .grn_builtin_type.GRN_DB_OBJECT, 806 GRN_DB_BOOL = .grn_builtin_type.GRN_DB_BOOL, 807 GRN_DB_INT8 = .grn_builtin_type.GRN_DB_INT8, 808 GRN_DB_UINT8 = .grn_builtin_type.GRN_DB_UINT8, 809 GRN_DB_INT16 = .grn_builtin_type.GRN_DB_INT16, 810 GRN_DB_UINT16 = .grn_builtin_type.GRN_DB_UINT16, 811 GRN_DB_INT32 = .grn_builtin_type.GRN_DB_INT32, 812 GRN_DB_UINT32 = .grn_builtin_type.GRN_DB_UINT32, 813 GRN_DB_INT64 = .grn_builtin_type.GRN_DB_INT64, 814 GRN_DB_UINT64 = .grn_builtin_type.GRN_DB_UINT64, 815 GRN_DB_FLOAT = .grn_builtin_type.GRN_DB_FLOAT, 816 GRN_DB_TIME = .grn_builtin_type.GRN_DB_TIME, 817 GRN_DB_SHORT_TEXT = .grn_builtin_type.GRN_DB_SHORT_TEXT, 818 GRN_DB_TEXT = .grn_builtin_type.GRN_DB_TEXT, 819 GRN_DB_LONG_TEXT = .grn_builtin_type.GRN_DB_LONG_TEXT, 820 GRN_DB_TOKYO_GEO_POINT = .grn_builtin_type.GRN_DB_TOKYO_GEO_POINT, 821 GRN_DB_WGS84_GEO_POINT = .grn_builtin_type.GRN_DB_WGS84_GEO_POINT, 822 GRN_DB_FLOAT32 = .grn_builtin_type.GRN_DB_FLOAT32, 823 } 824 825 enum grn_builtin_tokenizer 826 { 827 GRN_DB_MECAB = 64, 828 GRN_DB_DELIMIT, 829 GRN_DB_UNIGRAM, 830 GRN_DB_BIGRAM, 831 GRN_DB_TRIGRAM, 832 } 833 834 //Declaration name in C language 835 enum 836 { 837 GRN_DB_MECAB = .grn_builtin_tokenizer.GRN_DB_MECAB, 838 GRN_DB_DELIMIT = .grn_builtin_tokenizer.GRN_DB_DELIMIT, 839 GRN_DB_UNIGRAM = .grn_builtin_tokenizer.GRN_DB_UNIGRAM, 840 GRN_DB_BIGRAM = .grn_builtin_tokenizer.GRN_DB_BIGRAM, 841 GRN_DB_TRIGRAM = .grn_builtin_tokenizer.GRN_DB_TRIGRAM, 842 } 843 844 //GRN_API 845 .grn_obj* grn_ctx_at(.grn_ctx* ctx, .grn_id id); 846 847 //GRN_API 848 .grn_bool grn_ctx_is_opened(.grn_ctx* ctx, .grn_id id); 849 850 //GRN_API 851 .grn_rc grn_plugin_register(.grn_ctx* ctx, const (char)* name); 852 853 //GRN_API 854 .grn_rc grn_plugin_unregister(.grn_ctx* ctx, const (char)* name); 855 856 //GRN_API 857 .grn_rc grn_plugin_register_by_path(.grn_ctx* ctx, const (char)* path); 858 859 //GRN_API 860 .grn_rc grn_plugin_unregister_by_path(.grn_ctx* ctx, const (char)* path); 861 862 //GRN_API 863 const (char)* grn_plugin_get_system_plugins_dir(); 864 865 //GRN_API 866 const (char)* grn_plugin_get_suffix(); 867 868 //GRN_API 869 const (char)* grn_plugin_get_ruby_suffix(); 870 871 //GRN_API 872 .grn_rc grn_plugin_get_names(.grn_ctx* ctx, .grn_obj* names); 873 874 struct grn_expr_var 875 { 876 const (char)* name; 877 uint name_size; 878 .grn_obj value; 879 } 880 881 .grn_rc function (.grn_ctx* ctx) grn_plugin_func; 882 883 alias grn_table_cursor = .grn_obj; 884 885 enum grn_operator 886 { 887 GRN_OP_PUSH = 0, 888 GRN_OP_POP, 889 GRN_OP_NOP, 890 GRN_OP_CALL, 891 GRN_OP_INTERN, 892 GRN_OP_GET_REF, 893 GRN_OP_GET_VALUE, 894 GRN_OP_AND, 895 GRN_OP_AND_NOT, 896 897 /** 898 * Deprecated. Just for backward compatibility. 899 */ 900 GRN_OP_BUT = GRN_OP_AND_NOT, 901 902 GRN_OP_OR, 903 GRN_OP_ASSIGN, 904 GRN_OP_STAR_ASSIGN, 905 GRN_OP_SLASH_ASSIGN, 906 GRN_OP_MOD_ASSIGN, 907 GRN_OP_PLUS_ASSIGN, 908 GRN_OP_MINUS_ASSIGN, 909 GRN_OP_SHIFTL_ASSIGN, 910 GRN_OP_SHIFTR_ASSIGN, 911 GRN_OP_SHIFTRR_ASSIGN, 912 GRN_OP_AND_ASSIGN, 913 GRN_OP_XOR_ASSIGN, 914 GRN_OP_OR_ASSIGN, 915 GRN_OP_JUMP, 916 GRN_OP_CJUMP, 917 GRN_OP_COMMA, 918 GRN_OP_BITWISE_OR, 919 GRN_OP_BITWISE_XOR, 920 GRN_OP_BITWISE_AND, 921 GRN_OP_BITWISE_NOT, 922 GRN_OP_EQUAL, 923 GRN_OP_NOT_EQUAL, 924 GRN_OP_LESS, 925 GRN_OP_GREATER, 926 GRN_OP_LESS_EQUAL, 927 GRN_OP_GREATER_EQUAL, 928 GRN_OP_IN, 929 GRN_OP_MATCH, 930 GRN_OP_NEAR, 931 GRN_OP_NEAR2, 932 GRN_OP_SIMILAR, 933 GRN_OP_TERM_EXTRACT, 934 GRN_OP_SHIFTL, 935 GRN_OP_SHIFTR, 936 GRN_OP_SHIFTRR, 937 GRN_OP_PLUS, 938 GRN_OP_MINUS, 939 GRN_OP_STAR, 940 GRN_OP_SLASH, 941 GRN_OP_MOD, 942 GRN_OP_DELETE, 943 GRN_OP_INCR, 944 GRN_OP_DECR, 945 GRN_OP_INCR_POST, 946 GRN_OP_DECR_POST, 947 GRN_OP_NOT, 948 GRN_OP_ADJUST, 949 GRN_OP_EXACT, 950 GRN_OP_LCP, 951 GRN_OP_PARTIAL, 952 GRN_OP_UNSPLIT, 953 GRN_OP_PREFIX, 954 GRN_OP_SUFFIX, 955 GRN_OP_GEO_DISTANCE1, 956 GRN_OP_GEO_DISTANCE2, 957 GRN_OP_GEO_DISTANCE3, 958 GRN_OP_GEO_DISTANCE4, 959 GRN_OP_GEO_WITHINP5, 960 GRN_OP_GEO_WITHINP6, 961 GRN_OP_GEO_WITHINP8, 962 GRN_OP_OBJ_SEARCH, 963 GRN_OP_EXPR_GET_VAR, 964 GRN_OP_TABLE_CREATE, 965 GRN_OP_TABLE_SELECT, 966 GRN_OP_TABLE_SORT, 967 GRN_OP_TABLE_GROUP, 968 GRN_OP_JSON_PUT, 969 GRN_OP_GET_MEMBER, 970 GRN_OP_REGEXP, 971 GRN_OP_FUZZY, 972 GRN_OP_QUORUM, 973 GRN_OP_NEAR_PHRASE, 974 GRN_OP_ORDERED_NEAR_PHRASE, 975 } 976 977 //Declaration name in C language 978 enum 979 { 980 GRN_OP_PUSH = .grn_operator.GRN_OP_PUSH, 981 GRN_OP_POP = .grn_operator.GRN_OP_POP, 982 GRN_OP_NOP = .grn_operator.GRN_OP_NOP, 983 GRN_OP_CALL = .grn_operator.GRN_OP_CALL, 984 GRN_OP_INTERN = .grn_operator.GRN_OP_INTERN, 985 GRN_OP_GET_REF = .grn_operator.GRN_OP_GET_REF, 986 GRN_OP_GET_VALUE = .grn_operator.GRN_OP_GET_VALUE, 987 GRN_OP_AND = .grn_operator.GRN_OP_AND, 988 GRN_OP_AND_NOT = .grn_operator.GRN_OP_AND_NOT, 989 GRN_OP_BUT = .grn_operator.GRN_OP_BUT, 990 GRN_OP_OR = .grn_operator.GRN_OP_OR, 991 GRN_OP_ASSIGN = .grn_operator.GRN_OP_ASSIGN, 992 GRN_OP_STAR_ASSIGN = .grn_operator.GRN_OP_STAR_ASSIGN, 993 GRN_OP_SLASH_ASSIGN = .grn_operator.GRN_OP_SLASH_ASSIGN, 994 GRN_OP_MOD_ASSIGN = .grn_operator.GRN_OP_MOD_ASSIGN, 995 GRN_OP_PLUS_ASSIGN = .grn_operator.GRN_OP_PLUS_ASSIGN, 996 GRN_OP_MINUS_ASSIGN = .grn_operator.GRN_OP_MINUS_ASSIGN, 997 GRN_OP_SHIFTL_ASSIGN = .grn_operator.GRN_OP_SHIFTL_ASSIGN, 998 GRN_OP_SHIFTR_ASSIGN = .grn_operator.GRN_OP_SHIFTR_ASSIGN, 999 GRN_OP_SHIFTRR_ASSIGN = .grn_operator.GRN_OP_SHIFTRR_ASSIGN, 1000 GRN_OP_AND_ASSIGN = .grn_operator.GRN_OP_AND_ASSIGN, 1001 GRN_OP_XOR_ASSIGN = .grn_operator.GRN_OP_XOR_ASSIGN, 1002 GRN_OP_OR_ASSIGN = .grn_operator.GRN_OP_OR_ASSIGN, 1003 GRN_OP_JUMP = .grn_operator.GRN_OP_JUMP, 1004 GRN_OP_CJUMP = .grn_operator.GRN_OP_CJUMP, 1005 GRN_OP_COMMA = .grn_operator.GRN_OP_COMMA, 1006 GRN_OP_BITWISE_OR = .grn_operator.GRN_OP_BITWISE_OR, 1007 GRN_OP_BITWISE_XOR = .grn_operator.GRN_OP_BITWISE_XOR, 1008 GRN_OP_BITWISE_AND = .grn_operator.GRN_OP_BITWISE_AND, 1009 GRN_OP_BITWISE_NOT = .grn_operator.GRN_OP_BITWISE_NOT, 1010 GRN_OP_EQUAL = .grn_operator.GRN_OP_EQUAL, 1011 GRN_OP_NOT_EQUAL = .grn_operator.GRN_OP_NOT_EQUAL, 1012 GRN_OP_LESS = .grn_operator.GRN_OP_LESS, 1013 GRN_OP_GREATER = .grn_operator.GRN_OP_GREATER, 1014 GRN_OP_LESS_EQUAL = .grn_operator.GRN_OP_LESS_EQUAL, 1015 GRN_OP_GREATER_EQUAL = .grn_operator.GRN_OP_GREATER_EQUAL, 1016 GRN_OP_IN = .grn_operator.GRN_OP_IN, 1017 GRN_OP_MATCH = .grn_operator.GRN_OP_MATCH, 1018 GRN_OP_NEAR = .grn_operator.GRN_OP_NEAR, 1019 GRN_OP_NEAR2 = .grn_operator.GRN_OP_NEAR2, 1020 GRN_OP_SIMILAR = .grn_operator.GRN_OP_SIMILAR, 1021 GRN_OP_TERM_EXTRACT = .grn_operator.GRN_OP_TERM_EXTRACT, 1022 GRN_OP_SHIFTL = .grn_operator.GRN_OP_SHIFTL, 1023 GRN_OP_SHIFTR = .grn_operator.GRN_OP_SHIFTR, 1024 GRN_OP_SHIFTRR = .grn_operator.GRN_OP_SHIFTRR, 1025 GRN_OP_PLUS = .grn_operator.GRN_OP_PLUS, 1026 GRN_OP_MINUS = .grn_operator.GRN_OP_MINUS, 1027 GRN_OP_STAR = .grn_operator.GRN_OP_STAR, 1028 GRN_OP_SLASH = .grn_operator.GRN_OP_SLASH, 1029 GRN_OP_MOD = .grn_operator.GRN_OP_MOD, 1030 GRN_OP_DELETE = .grn_operator.GRN_OP_DELETE, 1031 GRN_OP_INCR = .grn_operator.GRN_OP_INCR, 1032 GRN_OP_DECR = .grn_operator.GRN_OP_DECR, 1033 GRN_OP_INCR_POST = .grn_operator.GRN_OP_INCR_POST, 1034 GRN_OP_DECR_POST = .grn_operator.GRN_OP_DECR_POST, 1035 GRN_OP_NOT = .grn_operator.GRN_OP_NOT, 1036 GRN_OP_ADJUST = .grn_operator.GRN_OP_ADJUST, 1037 GRN_OP_EXACT = .grn_operator.GRN_OP_EXACT, 1038 GRN_OP_LCP = .grn_operator.GRN_OP_LCP, 1039 GRN_OP_PARTIAL = .grn_operator.GRN_OP_PARTIAL, 1040 GRN_OP_UNSPLIT = .grn_operator.GRN_OP_UNSPLIT, 1041 GRN_OP_PREFIX = .grn_operator.GRN_OP_PREFIX, 1042 GRN_OP_SUFFIX = .grn_operator.GRN_OP_SUFFIX, 1043 GRN_OP_GEO_DISTANCE1 = .grn_operator.GRN_OP_GEO_DISTANCE1, 1044 GRN_OP_GEO_DISTANCE2 = .grn_operator.GRN_OP_GEO_DISTANCE2, 1045 GRN_OP_GEO_DISTANCE3 = .grn_operator.GRN_OP_GEO_DISTANCE3, 1046 GRN_OP_GEO_DISTANCE4 = .grn_operator.GRN_OP_GEO_DISTANCE4, 1047 GRN_OP_GEO_WITHINP5 = .grn_operator.GRN_OP_GEO_WITHINP5, 1048 GRN_OP_GEO_WITHINP6 = .grn_operator.GRN_OP_GEO_WITHINP6, 1049 GRN_OP_GEO_WITHINP8 = .grn_operator.GRN_OP_GEO_WITHINP8, 1050 GRN_OP_OBJ_SEARCH = .grn_operator.GRN_OP_OBJ_SEARCH, 1051 GRN_OP_EXPR_GET_VAR = .grn_operator.GRN_OP_EXPR_GET_VAR, 1052 GRN_OP_TABLE_CREATE = .grn_operator.GRN_OP_TABLE_CREATE, 1053 GRN_OP_TABLE_SELECT = .grn_operator.GRN_OP_TABLE_SELECT, 1054 GRN_OP_TABLE_SORT = .grn_operator.GRN_OP_TABLE_SORT, 1055 GRN_OP_TABLE_GROUP = .grn_operator.GRN_OP_TABLE_GROUP, 1056 GRN_OP_JSON_PUT = .grn_operator.GRN_OP_JSON_PUT, 1057 GRN_OP_GET_MEMBER = .grn_operator.GRN_OP_GET_MEMBER, 1058 GRN_OP_REGEXP = .grn_operator.GRN_OP_REGEXP, 1059 GRN_OP_FUZZY = .grn_operator.GRN_OP_FUZZY, 1060 GRN_OP_QUORUM = .grn_operator.GRN_OP_QUORUM, 1061 GRN_OP_NEAR_PHRASE = .grn_operator.GRN_OP_NEAR_PHRASE, 1062 GRN_OP_ORDERED_NEAR_PHRASE = .grn_operator.GRN_OP_ORDERED_NEAR_PHRASE, 1063 } 1064 1065 //GRN_API 1066 .grn_obj* grn_obj_column(.grn_ctx* ctx, .grn_obj* table, const (char)* name, uint name_size); 1067 1068 /*------------------------------------------------------------- 1069 * API for db, table and/or column 1070 */ 1071 1072 enum grn_info_type 1073 { 1074 GRN_INFO_ENCODING = 0, 1075 GRN_INFO_SOURCE, 1076 GRN_INFO_DEFAULT_TOKENIZER, 1077 GRN_INFO_ELEMENT_SIZE, 1078 GRN_INFO_CURR_MAX, 1079 GRN_INFO_MAX_ELEMENT_SIZE, 1080 GRN_INFO_SEG_SIZE, 1081 GRN_INFO_CHUNK_SIZE, 1082 GRN_INFO_MAX_SECTION, 1083 GRN_INFO_HOOK_LOCAL_DATA, 1084 GRN_INFO_ELEMENT_A, 1085 GRN_INFO_ELEMENT_CHUNK, 1086 GRN_INFO_ELEMENT_CHUNK_SIZE, 1087 GRN_INFO_ELEMENT_BUFFER_FREE, 1088 GRN_INFO_ELEMENT_NTERMS, 1089 GRN_INFO_ELEMENT_NTERMS_VOID, 1090 GRN_INFO_ELEMENT_SIZE_IN_CHUNK, 1091 GRN_INFO_ELEMENT_POS_IN_CHUNK, 1092 GRN_INFO_ELEMENT_SIZE_IN_BUFFER, 1093 GRN_INFO_ELEMENT_POS_IN_BUFFER, 1094 GRN_INFO_ELEMENT_ESTIMATE_SIZE, 1095 GRN_INFO_NGRAM_UNIT_SIZE, 1096 /* 1097 GRN_INFO_VERSION, 1098 GRN_INFO_CONFIGURE_OPTIONS, 1099 GRN_INFO_CONFIG_PATH, 1100 */ 1101 GRN_INFO_PARTIAL_MATCH_THRESHOLD, 1102 GRN_INFO_II_SPLIT_THRESHOLD, 1103 GRN_INFO_SUPPORT_ZLIB, 1104 GRN_INFO_SUPPORT_LZ4, 1105 /* Just for backward compatibility. We'll remove it at 5.0.0. */ 1106 GRN_INFO_SUPPORT_LZO = GRN_INFO_SUPPORT_LZ4, 1107 GRN_INFO_NORMALIZER, 1108 GRN_INFO_TOKEN_FILTERS, 1109 GRN_INFO_SUPPORT_ZSTD, 1110 1111 GRN_INFO_SUPPORT_APACHE_ARROW, 1112 GRN_INFO_NORMALIZERS, 1113 } 1114 1115 //Declaration name in C language 1116 enum 1117 { 1118 GRN_INFO_ENCODING = .grn_info_type.GRN_INFO_ENCODING, 1119 GRN_INFO_SOURCE = .grn_info_type.GRN_INFO_SOURCE, 1120 GRN_INFO_DEFAULT_TOKENIZER = .grn_info_type.GRN_INFO_DEFAULT_TOKENIZER, 1121 GRN_INFO_ELEMENT_SIZE = .grn_info_type.GRN_INFO_ELEMENT_SIZE, 1122 GRN_INFO_CURR_MAX = .grn_info_type.GRN_INFO_CURR_MAX, 1123 GRN_INFO_MAX_ELEMENT_SIZE = .grn_info_type.GRN_INFO_MAX_ELEMENT_SIZE, 1124 GRN_INFO_SEG_SIZE = .grn_info_type.GRN_INFO_SEG_SIZE, 1125 GRN_INFO_CHUNK_SIZE = .grn_info_type.GRN_INFO_CHUNK_SIZE, 1126 GRN_INFO_MAX_SECTION = .grn_info_type.GRN_INFO_MAX_SECTION, 1127 GRN_INFO_HOOK_LOCAL_DATA = .grn_info_type.GRN_INFO_HOOK_LOCAL_DATA, 1128 GRN_INFO_ELEMENT_A = .grn_info_type.GRN_INFO_ELEMENT_A, 1129 GRN_INFO_ELEMENT_CHUNK = .grn_info_type.GRN_INFO_ELEMENT_CHUNK, 1130 GRN_INFO_ELEMENT_CHUNK_SIZE = .grn_info_type.GRN_INFO_ELEMENT_CHUNK_SIZE, 1131 GRN_INFO_ELEMENT_BUFFER_FREE = .grn_info_type.GRN_INFO_ELEMENT_BUFFER_FREE, 1132 GRN_INFO_ELEMENT_NTERMS = .grn_info_type.GRN_INFO_ELEMENT_NTERMS, 1133 GRN_INFO_ELEMENT_NTERMS_VOID = .grn_info_type.GRN_INFO_ELEMENT_NTERMS_VOID, 1134 GRN_INFO_ELEMENT_SIZE_IN_CHUNK = .grn_info_type.GRN_INFO_ELEMENT_SIZE_IN_CHUNK, 1135 GRN_INFO_ELEMENT_POS_IN_CHUNK = .grn_info_type.GRN_INFO_ELEMENT_POS_IN_CHUNK, 1136 GRN_INFO_ELEMENT_SIZE_IN_BUFFER = .grn_info_type.GRN_INFO_ELEMENT_SIZE_IN_BUFFER, 1137 GRN_INFO_ELEMENT_POS_IN_BUFFER = .grn_info_type.GRN_INFO_ELEMENT_POS_IN_BUFFER, 1138 GRN_INFO_ELEMENT_ESTIMATE_SIZE = .grn_info_type.GRN_INFO_ELEMENT_ESTIMATE_SIZE, 1139 GRN_INFO_NGRAM_UNIT_SIZE = .grn_info_type.GRN_INFO_NGRAM_UNIT_SIZE, 1140 /* 1141 GRN_INFO_VERSION = .grn_info_type.GRN_INFO_VERSION, 1142 GRN_INFO_CONFIGURE_OPTIONS = .grn_info_type.GRN_INFO_CONFIGURE_OPTIONS, 1143 GRN_INFO_CONFIG_PATH = .grn_info_type.GRN_INFO_CONFIG_PATH, 1144 */ 1145 GRN_INFO_PARTIAL_MATCH_THRESHOLD = .grn_info_type.GRN_INFO_PARTIAL_MATCH_THRESHOLD, 1146 GRN_INFO_II_SPLIT_THRESHOLD = .grn_info_type.GRN_INFO_II_SPLIT_THRESHOLD, 1147 GRN_INFO_SUPPORT_ZLIB = .grn_info_type.GRN_INFO_SUPPORT_ZLIB, 1148 GRN_INFO_SUPPORT_LZ4 = .grn_info_type.GRN_INFO_SUPPORT_LZ4, 1149 GRN_INFO_SUPPORT_LZO = .grn_info_type.GRN_INFO_SUPPORT_LZO, 1150 GRN_INFO_NORMALIZER = .grn_info_type.GRN_INFO_NORMALIZER, 1151 GRN_INFO_TOKEN_FILTERS = .grn_info_type.GRN_INFO_TOKEN_FILTERS, 1152 GRN_INFO_SUPPORT_ZSTD = .grn_info_type.GRN_INFO_SUPPORT_ZSTD, 1153 1154 GRN_INFO_SUPPORT_APACHE_ARROW = .grn_info_type.GRN_INFO_SUPPORT_APACHE_ARROW, 1155 } 1156 1157 /* Just for backward compatibility. */ 1158 package alias GRN_INFO_SUPPORT_ARROW = .grn_info_type.GRN_INFO_SUPPORT_APACHE_ARROW; 1159 1160 //GRN_API 1161 .grn_obj* grn_obj_get_info(.grn_ctx* ctx, .grn_obj* obj, .grn_info_type type, .grn_obj* valuebuf); 1162 1163 //GRN_API 1164 .grn_rc grn_obj_set_info(.grn_ctx* ctx, .grn_obj* obj, .grn_info_type type, .grn_obj* value); 1165 1166 //GRN_API 1167 .grn_obj* grn_obj_get_element_info(.grn_ctx* ctx, .grn_obj* obj, .grn_id id, .grn_info_type type, .grn_obj* value); 1168 1169 //GRN_API 1170 .grn_rc grn_obj_set_element_info(.grn_ctx* ctx, .grn_obj* obj, .grn_id id, .grn_info_type type, .grn_obj* value); 1171 1172 //GRN_API 1173 .grn_obj* grn_obj_get_value(.grn_ctx* ctx, .grn_obj* obj, .grn_id id, .grn_obj* value); 1174 1175 //GRN_API 1176 int grn_obj_get_values(.grn_ctx* ctx, .grn_obj* obj, .grn_id offset, void** values); 1177 1178 1179 //ToDo: temp 1180 alias internal_block_func = extern (C) nothrow @nogc void function(); 1181 1182 //ToDo: check 1183 /+ 1184 pragma(inline, true) 1185 nothrow @nogc @disable 1186 void GRN_COLUMN_EACH(.grn_ctx* ctx, .grn_obj* column, uint id, void** value, internal_block_func block) 1187 1188 do 1189 { 1190 int _n; 1191 .grn_id id = 1; 1192 1193 while ((_n = .grn_obj_get_values(ctx, column, id, value)) > 0) { 1194 for (; _n; _n--, id++, value++) { 1195 block(); 1196 } 1197 } 1198 } 1199 +/ 1200 1201 enum GRN_OBJ_SET_MASK = 0x07; 1202 enum GRN_OBJ_SET = 0x01; 1203 enum GRN_OBJ_INCR = 0x02; 1204 enum GRN_OBJ_DECR = 0x03; 1205 enum GRN_OBJ_APPEND = 0x04; 1206 enum GRN_OBJ_PREPEND = 0x05; 1207 enum GRN_OBJ_GET = 0x01 << 4; 1208 enum GRN_OBJ_COMPARE = 0x01 << 5; 1209 enum GRN_OBJ_LOCK = 0x01 << 6; 1210 enum GRN_OBJ_UNLOCK = 0x01 << 7; 1211 1212 //GRN_API 1213 .grn_rc grn_obj_set_value(.grn_ctx* ctx, .grn_obj* obj, .grn_id id, .grn_obj* value, int flags); 1214 1215 //GRN_API 1216 .grn_rc grn_obj_remove(.grn_ctx* ctx, .grn_obj* obj); 1217 1218 //GRN_API 1219 .grn_rc grn_obj_remove_dependent(.grn_ctx* ctx, .grn_obj* obj); 1220 1221 //GRN_API 1222 .grn_rc grn_obj_remove_force(.grn_ctx* ctx, const (char)* name, int name_size); 1223 1224 //GRN_API 1225 .grn_rc grn_obj_rename(.grn_ctx* ctx, .grn_obj* obj, const (char)* name, uint name_size); 1226 1227 //GRN_API 1228 .grn_rc grn_table_rename(.grn_ctx* ctx, .grn_obj* table, const (char)* name, uint name_size); 1229 1230 //GRN_API 1231 .grn_rc grn_column_rename(.grn_ctx* ctx, .grn_obj* column, const (char)* name, uint name_size); 1232 1233 //GRN_API 1234 .grn_rc grn_obj_close(.grn_ctx* ctx, .grn_obj* obj); 1235 1236 //GRN_API 1237 .grn_rc grn_obj_reinit(.grn_ctx* ctx, .grn_obj* obj, .grn_id domain, ubyte flags); 1238 /* On non reference count mode (default): 1239 * This closes the following objects immediately: 1240 * 1241 * * Acceessor 1242 * * Bulk 1243 * * DB 1244 * * Temporary column 1245 * * Temporary table 1246 * 1247 * This does nothing for other objects such as persisted tables and 1248 * columns. 1249 * 1250 * On reference count mode (GRN_ENABLE_REFERENCE_COUNT=yes): 1251 * This closes the following objects immediately: 1252 * 1253 * * Bulk 1254 * * DB 1255 * 1256 * This decreases the reference count of the following objects: 1257 * 1258 * * Acceessor 1259 * * Column (both persisted and temporary) 1260 * * Table (both persisted and temporary) 1261 * 1262 * If the decreased reference count is zero, the object is closed. 1263 */ 1264 //GRN_API 1265 void grn_obj_unlink(.grn_ctx* ctx, .grn_obj* obj); 1266 1267 //GRN_API 1268 .grn_rc grn_obj_refer(.grn_ctx* ctx, .grn_obj* obj); 1269 1270 //GRN_API 1271 .grn_rc grn_obj_refer_recursive(.grn_ctx* ctx, .grn_obj* obj); 1272 1273 //GRN_API 1274 .grn_rc grn_obj_refer_recursive_dependent(.grn_ctx* ctx, .grn_obj* obj); 1275 /* This calls grn_obj_unlink() only on reference count mode 1276 * (GRN_ENABLE_REFERENCE_COUNT=yes) */ 1277 //GRN_API 1278 void grn_obj_unref(.grn_ctx* ctx, .grn_obj* obj); 1279 1280 //GRN_API 1281 void grn_obj_unref_recursive(.grn_ctx* ctx, .grn_obj* obj); 1282 1283 //GRN_API 1284 void grn_obj_unref_recursive_dependent(.grn_ctx* ctx, .grn_obj* obj); 1285 1286 //GRN_API 1287 grn_user_data* grn_obj_user_data(.grn_ctx* ctx, .grn_obj* obj); 1288 1289 //GRN_API 1290 .grn_rc grn_obj_set_finalizer(.grn_ctx* ctx, .grn_obj* obj, grn_proc_func* func); 1291 1292 //GRN_API 1293 const (char)* grn_obj_path(.grn_ctx* ctx, .grn_obj* obj); 1294 1295 //GRN_API 1296 int grn_obj_name(.grn_ctx* ctx, .grn_obj* obj, char* namebuf, int buf_size); 1297 1298 //GRN_API 1299 int grn_column_name(.grn_ctx* ctx, .grn_obj* obj, char* namebuf, int buf_size); 1300 1301 //GRN_API 1302 .grn_id grn_obj_get_range(.grn_ctx* ctx, .grn_obj* obj); 1303 1304 pragma(inline, true) 1305 pure nothrow @trusted @nogc @live 1306 .grn_id GRN_OBJ_GET_DOMAIN(scope const .grn_obj* obj) 1307 1308 in 1309 { 1310 assert(obj != null); 1311 } 1312 1313 do 1314 { 1315 return (obj.header.type == .GRN_TABLE_NO_KEY) ? (.GRN_ID_NIL) : (obj.header.domain); 1316 } 1317 1318 //GRN_API 1319 int grn_obj_expire(.grn_ctx* ctx, .grn_obj* obj, int threshold); 1320 1321 //GRN_API 1322 int grn_obj_check(.grn_ctx* ctx, .grn_obj* obj); 1323 1324 //GRN_API 1325 .grn_rc grn_obj_lock(.grn_ctx* ctx, .grn_obj* obj, .grn_id id, int timeout); 1326 1327 //GRN_API 1328 .grn_rc grn_obj_unlock(.grn_ctx* ctx, .grn_obj* obj, .grn_id id); 1329 1330 //GRN_API 1331 .grn_rc grn_obj_clear_lock(.grn_ctx* ctx, .grn_obj* obj); 1332 1333 //GRN_API 1334 uint grn_obj_is_locked(.grn_ctx* ctx, .grn_obj* obj); 1335 1336 //GRN_API 1337 .grn_rc grn_obj_flush(.grn_ctx* ctx, .grn_obj* obj); 1338 1339 //GRN_API 1340 .grn_rc grn_obj_flush_recursive(.grn_ctx* ctx, .grn_obj* obj); 1341 1342 //GRN_API 1343 .grn_rc grn_obj_flush_recursive_dependent(.grn_ctx* ctx, .grn_obj* obj); 1344 1345 //GRN_API 1346 .grn_rc grn_obj_flush_only_opened(.grn_ctx* ctx, .grn_obj* obj); 1347 1348 //GRN_API 1349 int grn_obj_defrag(.grn_ctx* ctx, .grn_obj* obj, int threshold); 1350 1351 //GRN_API 1352 .grn_obj* grn_obj_db(.grn_ctx* ctx, .grn_obj* obj); 1353 1354 //GRN_API 1355 .grn_id grn_obj_id(.grn_ctx* ctx, .grn_obj* obj); 1356 1357 /* Flags for grn_fuzzy_search_optarg.flags. */ 1358 enum GRN_TABLE_FUZZY_SEARCH_WITH_TRANSPOSITION = 0x01; 1359 1360 struct _grn_fuzzy_search_optarg 1361 { 1362 uint max_distance; 1363 uint max_expansion; 1364 uint prefix_match_size; 1365 int flags; 1366 } 1367 1368 alias grn_fuzzy_search_optarg = ._grn_fuzzy_search_optarg; 1369 1370 enum GRN_MATCH_INFO_GET_MIN_RECORD_ID = 0x01; 1371 enum GRN_MATCH_INFO_ONLY_SKIP_TOKEN = 0x02; 1372 1373 struct _grn_match_info 1374 { 1375 int flags; 1376 .grn_id min; 1377 } 1378 1379 alias grn_match_info = ._grn_match_info; 1380 1381 struct _grn_search_optarg 1382 { 1383 .grn_operator mode; 1384 int similarity_threshold; 1385 int max_interval; 1386 int* weight_vector; 1387 int vector_size; 1388 .grn_obj* proc; 1389 int max_size; 1390 .grn_obj* scorer; 1391 .grn_obj* scorer_args_expr; 1392 uint scorer_args_expr_offset; 1393 .grn_fuzzy_search_optarg fuzzy; 1394 .grn_match_info match_info; 1395 int quorum_threshold; 1396 int additional_last_interval; 1397 float* weight_vector_float; 1398 float weight_float = 0; 1399 .grn_obj* query_options; 1400 } 1401 1402 alias grn_search_optarg = ._grn_search_optarg; 1403 1404 //GRN_API 1405 .grn_rc grn_obj_search(.grn_ctx* ctx, .grn_obj* obj, .grn_obj* query, .grn_obj* res, .grn_operator op, .grn_search_optarg* optarg); 1406 1407 //GRN_API 1408 .grn_rc grn_proc_set_is_stable(.grn_ctx* ctx, .grn_obj* proc, .grn_bool is_stable); 1409 1410 //GRN_API 1411 .grn_bool grn_proc_is_stable(.grn_ctx* ctx, .grn_obj* proc); 1412 1413 /*------------------------------------------------------------- 1414 * API for hook 1415 */ 1416 1417 //GRN_API 1418 int grn_proc_call_next(.grn_ctx* ctx, .grn_obj* exec_info, .grn_obj* in_, .grn_obj* out_); 1419 1420 //GRN_API 1421 void* grn_proc_get_ctx_local_data(.grn_ctx* ctx, .grn_obj* exec_info); 1422 1423 //GRN_API 1424 void* grn_proc_get_hook_local_data(.grn_ctx* ctx, .grn_obj* exec_info); 1425 1426 enum grn_hook_entry 1427 { 1428 GRN_HOOK_SET = 0, 1429 GRN_HOOK_GET, 1430 GRN_HOOK_INSERT, 1431 GRN_HOOK_DELETE, 1432 GRN_HOOK_SELECT, 1433 } 1434 1435 //Declaration name in C language 1436 enum 1437 { 1438 GRN_HOOK_SET = .grn_hook_entry.GRN_HOOK_SET, 1439 GRN_HOOK_GET = .grn_hook_entry.GRN_HOOK_GET, 1440 GRN_HOOK_INSERT = .grn_hook_entry.GRN_HOOK_INSERT, 1441 GRN_HOOK_DELETE = .grn_hook_entry.GRN_HOOK_DELETE, 1442 GRN_HOOK_SELECT = .grn_hook_entry.GRN_HOOK_SELECT, 1443 } 1444 1445 //GRN_API 1446 .grn_rc grn_obj_add_hook(.grn_ctx* ctx, .grn_obj* obj, .grn_hook_entry entry, int offset, .grn_obj* proc, .grn_obj* data); 1447 1448 //GRN_API 1449 int grn_obj_get_nhooks(.grn_ctx* ctx, .grn_obj* obj, .grn_hook_entry entry); 1450 1451 //GRN_API 1452 .grn_obj* grn_obj_get_hook(.grn_ctx* ctx, .grn_obj* obj, .grn_hook_entry entry, int offset, .grn_obj* data); 1453 1454 //GRN_API 1455 .grn_rc grn_obj_delete_hook(.grn_ctx* ctx, .grn_obj* obj, .grn_hook_entry entry, int offset); 1456 1457 //GRN_API 1458 .grn_obj* grn_obj_open(.grn_ctx* ctx, ubyte type, .grn_obj_flags flags, .grn_id domain); 1459 1460 /* Deprecated since 5.0.1. Use grn_column_find_index_data() instead. */ 1461 1462 //GRN_API 1463 int grn_column_index(.grn_ctx* ctx, .grn_obj* column, .grn_operator op, .grn_obj** indexbuf, int buf_size, int* section); 1464 1465 /* @since 5.0.1. */ 1466 struct _grn_index_datum 1467 { 1468 .grn_obj* index; 1469 uint section; 1470 } 1471 1472 alias grn_index_datum = ._grn_index_datum; 1473 1474 /* @since 5.0.1. */ 1475 1476 //GRN_API 1477 uint grn_column_find_index_data(.grn_ctx* ctx, .grn_obj* column, .grn_operator op, .grn_index_datum* index_data, uint n_index_data); 1478 /* @since 5.1.2. */ 1479 1480 //GRN_API 1481 uint grn_column_get_all_index_data(.grn_ctx* ctx, .grn_obj* column, .grn_index_datum* index_data, uint n_index_data); 1482 1483 /* @since 9.1.2. */ 1484 //GRN_API 1485 .grn_rc grn_column_get_all_index_columns(.grn_ctx* ctx, .grn_obj* column, .grn_obj* index_columns); 1486 1487 //GRN_API 1488 .grn_rc grn_obj_delete_by_id(.grn_ctx* ctx, .grn_obj* db, .grn_id id, .grn_bool removep); 1489 1490 //GRN_API 1491 .grn_rc grn_obj_path_by_id(.grn_ctx* ctx, .grn_obj* db, .grn_id id, char* buffer); 1492 1493 /* query & snippet */ 1494 1495 static if (!__traits(compiles, .GRN_QUERY_AND)) { 1496 enum GRN_QUERY_AND = '+'; 1497 } 1498 1499 static if (!__traits(compiles, .GRN_QUERY_AND_NOT)) { 1500 static if (__traits(compiles, .GRN_QUERY_BUT)) { 1501 /* Deprecated. Just for backward compatibility. */ 1502 enum GRN_QUERY_AND_NOT = .GRN_QUERY_BUT; 1503 } else { 1504 enum GRN_QUERY_AND_NOT = '-'; 1505 } 1506 } 1507 1508 static if (!__traits(compiles, .GRN_QUERY_ADJ_INC)) { 1509 enum GRN_QUERY_ADJ_INC = '>'; 1510 } 1511 1512 static if (!__traits(compiles, .GRN_QUERY_ADJ_DEC)) { 1513 enum GRN_QUERY_ADJ_DEC = '<'; 1514 } 1515 1516 static if (!__traits(compiles, .GRN_QUERY_ADJ_NEG)) { 1517 enum GRN_QUERY_ADJ_NEG = '~'; 1518 } 1519 1520 static if (!__traits(compiles, .GRN_QUERY_PREFIX)) { 1521 enum GRN_QUERY_PREFIX = '*'; 1522 } 1523 1524 static if (!__traits(compiles, .GRN_QUERY_PARENL)) { 1525 enum GRN_QUERY_PARENL = '('; 1526 } 1527 1528 static if (!__traits(compiles, .GRN_QUERY_PARENR)) { 1529 enum GRN_QUERY_PARENR = ')'; 1530 } 1531 1532 static if (!__traits(compiles, .GRN_QUERY_QUOTEL)) { 1533 enum GRN_QUERY_QUOTEL = '"'; 1534 } 1535 1536 static if (!__traits(compiles, .GRN_QUERY_QUOTER)) { 1537 enum GRN_QUERY_QUOTER = '"'; 1538 } 1539 1540 static if (!__traits(compiles, .GRN_QUERY_ESCAPE)) { 1541 enum GRN_QUERY_ESCAPE = '\\'; 1542 } 1543 1544 static if (!__traits(compiles, .GRN_QUERY_COLUMN)) { 1545 enum GRN_QUERY_COLUMN = ':'; 1546 } 1547 1548 struct _grn_snip_mapping 1549 { 1550 void* dummy; 1551 } 1552 1553 alias grn_snip_mapping = ._grn_snip_mapping; 1554 1555 enum GRN_SNIP_NORMALIZE = 0x01 << 0; 1556 enum GRN_SNIP_COPY_TAG = 0x01 << 1; 1557 enum GRN_SNIP_SKIP_LEADING_SPACES = 0x01 << 2; 1558 1559 /* 1560 //ToDo: 1561 #define GRN_SNIP_MAPPING_HTML_ESCAPE ((.grn_snip_mapping *)-1) 1562 */ 1563 1564 //GRN_API 1565 .grn_obj* grn_snip_open(.grn_ctx* ctx, int flags, uint width, uint max_results, const (char)* defaultopentag, uint defaultopentag_len, const (char)* defaultclosetag, uint defaultclosetag_len, .grn_snip_mapping* mapping); 1566 1567 //GRN_API 1568 .grn_rc grn_snip_add_cond(.grn_ctx* ctx, .grn_obj* snip, const (char)* keyword, uint keyword_len, const (char)* opentag, uint opentag_len, const (char)* closetag, uint closetag_len); 1569 1570 //GRN_API 1571 .grn_rc grn_snip_set_normalizer(.grn_ctx* ctx, .grn_obj* snip, .grn_obj* normalizer); 1572 1573 //GRN_API 1574 .grn_obj* grn_snip_get_normalizer(.grn_ctx* ctx, .grn_obj* snip); 1575 1576 //GRN_API 1577 .grn_rc grn_snip_exec(.grn_ctx* ctx, .grn_obj* snip, const (char)* string_, uint string_len, uint* nresults, uint* max_tagged_len); 1578 1579 //GRN_API 1580 .grn_rc grn_snip_get_result(.grn_ctx* ctx, .grn_obj* snip, const uint index, char* result, uint* result_len); 1581 1582 /* log */ 1583 1584 enum GRN_LOG_NONE = 0x00 << 0; 1585 enum GRN_LOG_TIME = 0x01 << 0; 1586 enum GRN_LOG_TITLE = 0x01 << 1; 1587 enum GRN_LOG_MESSAGE = 0x01 << 2; 1588 enum GRN_LOG_LOCATION = 0x01 << 3; 1589 enum GRN_LOG_PID = 0x01 << 4; 1590 enum GRN_LOG_PROCESS_ID = .GRN_LOG_PID; 1591 enum GRN_LOG_THREAD_ID = 0x01 << 5; 1592 enum GRN_LOG_ALL = .GRN_LOG_TIME | .GRN_LOG_TITLE | .GRN_LOG_MESSAGE | .GRN_LOG_LOCATION | .GRN_LOG_PROCESS_ID | .GRN_LOG_THREAD_ID; 1593 enum GRN_LOG_DEFAULT = .GRN_LOG_TIME | .GRN_LOG_MESSAGE; 1594 1595 /* Deprecated since 2.1.2. Use .grn_logger instead. */ 1596 struct _grn_logger_info 1597 { 1598 extern (C): 1599 .grn_log_level max_level; 1600 int flags; 1601 void function (int, const (char)*, const (char)*, const (char)*, const (char)*, void*) func; 1602 void* func_arg; 1603 } 1604 1605 /* Deprecated since 2.1.2. Use .grn_logger instead. */ 1606 alias grn_logger_info = ._grn_logger_info; 1607 1608 /* Deprecated since 2.1.2. Use grn_logger_set() instead. */ 1609 1610 //GRN_API 1611 .grn_rc grn_logger_info_set(.grn_ctx* ctx, const (.grn_logger_info)* info); 1612 1613 struct _grn_logger 1614 { 1615 extern (C): 1616 .grn_log_level max_level; 1617 int flags; 1618 void* user_data; 1619 void function (.grn_ctx* ctx, .grn_log_level level, const (char)* timestamp, const (char)* title, const (char)* message, const (char)* location, void* user_data) log; 1620 void function (.grn_ctx* ctx, void* user_data) reopen; 1621 void function (.grn_ctx* ctx, void* user_data) fin; 1622 } 1623 1624 alias grn_logger = ._grn_logger; 1625 1626 //GRN_API 1627 .grn_bool grn_log_flags_parse(const (char)* string_, int string_size, int* flags); 1628 1629 //GRN_API 1630 .grn_rc grn_logger_set(.grn_ctx* ctx, const (.grn_logger)* logger); 1631 1632 //GRN_API 1633 void grn_logger_set_max_level(.grn_ctx* ctx, .grn_log_level max_level); 1634 1635 //GRN_API 1636 .grn_log_level grn_logger_get_max_level(.grn_ctx* ctx); 1637 1638 /+ 1639 #ifdef __GNUC__ 1640 # define GRN_ATTRIBUTE_PRINTF(fmt_pos) __attribute__ ((format(printf, fmt_pos, fmt_pos + 1))) 1641 #else 1642 # define GRN_ATTRIBUTE_PRINTF(fmt_pos) 1643 #endif /* __GNUC__ */ 1644 1645 #if defined(__clang__) 1646 # if __has_attribute(__alloc_size__) 1647 # define HAVE_ALLOC_SIZE_ATTRIBUTE 1648 # endif /* __has_attribute(__alloc_size__) */ 1649 #elif defined(__GNUC__) && ((__GNUC__ >= 5) || (__GNUC__ > 4 && __GNUC_MINOR__ >= 3)) 1650 # define HAVE_ALLOC_SIZE_ATTRIBUTE 1651 #endif /* __clang__ */ 1652 1653 #ifdef HAVE_ALLOC_SIZE_ATTRIBUTE 1654 # define GRN_ATTRIBUTE_ALLOC_SIZE(size) __attribute__ ((alloc_size(size))) 1655 # define GRN_ATTRIBUTE_ALLOC_SIZE_N(n, size) __attribute__ ((alloc_size(n, size))) 1656 #else 1657 # define GRN_ATTRIBUTE_ALLOC_SIZE(size) 1658 # define GRN_ATTRIBUTE_ALLOC_SIZE_N(n, size) 1659 #endif /* HAVE_ALLOC_SIZE_ATTRIBUTE */ 1660 1661 //GRN_API 1662 void grn_logger_put(.grn_ctx* ctx, .grn_log_level level, const (char)* file, int line, const (char)* func, const (char)* fmt, ...) GRN_ATTRIBUTE_PRINTF(6); 1663 +/ 1664 1665 //GRN_API 1666 void grn_logger_putv(.grn_ctx* ctx, .grn_log_level level, const (char)* file, int line, const (char)* func, const (char)* fmt, core.stdc.stdarg.va_list ap); 1667 1668 //GRN_API 1669 void grn_logger_reopen(.grn_ctx* ctx); 1670 1671 //GRN_API 1672 .grn_bool grn_logger_pass(.grn_ctx* ctx, .grn_log_level level); 1673 1674 //GRN_API 1675 .grn_bool grn_logger_is_default_logger(.grn_ctx* ctx); 1676 1677 static if (!__traits(compiles, GRN_LOG_DEFAULT_LEVEL)) { 1678 enum GRN_LOG_DEFAULT_LEVEL = .grn_log_level.GRN_LOG_NOTICE; 1679 } 1680 1681 //GRN_API 1682 void grn_default_logger_set_max_level(.grn_log_level level); 1683 1684 //GRN_API 1685 .grn_log_level grn_default_logger_get_max_level(); 1686 1687 //GRN_API 1688 void grn_default_logger_set_flags(int flags); 1689 1690 //GRN_API 1691 int grn_default_logger_get_flags(); 1692 1693 //GRN_API 1694 void grn_default_logger_set_path(const (char)* path); 1695 1696 //GRN_API 1697 const (char)* grn_default_logger_get_path(); 1698 1699 //GRN_API 1700 void grn_default_logger_set_rotate_threshold_size(.off_t threshold); 1701 1702 //GRN_API 1703 .off_t grn_default_logger_get_rotate_threshold_size(); 1704 1705 /* 1706 #define GRN_LOG(ctx, level, ...) 1707 if (grn_logger_pass(ctx, level)) { 1708 grn_logger_put(ctx, (level), __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__); 1709 } 1710 */ 1711 1712 struct _grn_query_logger 1713 { 1714 extern (C): 1715 uint flags; 1716 void* user_data; 1717 void function(.grn_ctx* ctx, uint flag, const (char)* timestamp, const (char)* info, const (char)* message, void* user_data) log; 1718 void function(.grn_ctx* ctx, void* user_data) reopen; 1719 void function(.grn_ctx* ctx, void* user_data) fin; 1720 } 1721 1722 alias grn_query_logger = ._grn_query_logger; 1723 1724 //GRN_API 1725 .grn_bool grn_query_log_flags_parse(const (char)* string_, int string_size, uint* flags); 1726 1727 //GRN_API 1728 .grn_rc grn_query_logger_set(.grn_ctx* ctx, const (.grn_query_logger)* logger); 1729 1730 //GRN_API 1731 void grn_query_logger_set_flags(.grn_ctx* ctx, uint flags); 1732 1733 //GRN_API 1734 void grn_query_logger_add_flags(.grn_ctx* ctx, uint flags); 1735 1736 //GRN_API 1737 void grn_query_logger_remove_flags(.grn_ctx* ctx, uint flags); 1738 1739 //GRN_API 1740 uint grn_query_logger_get_flags(.grn_ctx* ctx); 1741 1742 /+ 1743 //ToDo: 1744 //GRN_API 1745 void grn_query_logger_put(.grn_ctx* ctx, uint flag, const (char)* mark, const (char)* format, ...) GRN_ATTRIBUTE_PRINTF(4); 1746 +/ 1747 1748 //GRN_API 1749 void grn_query_logger_reopen(.grn_ctx* ctx); 1750 1751 //GRN_API 1752 .grn_bool grn_query_logger_pass(.grn_ctx* ctx, uint flag); 1753 1754 //GRN_API 1755 void grn_default_query_logger_set_flags(uint flags); 1756 1757 //GRN_API 1758 uint grn_default_query_logger_get_flags(); 1759 1760 //GRN_API 1761 void grn_default_query_logger_set_path(const (char)* path); 1762 1763 //GRN_API 1764 const (char)* grn_default_query_logger_get_path(); 1765 1766 //GRN_API 1767 void grn_default_query_logger_set_rotate_threshold_size(.off_t threshold); 1768 1769 //GRN_API 1770 .off_t grn_default_query_logger_get_rotate_threshold_size(); 1771 1772 /* 1773 //ToDo: 1774 #define GRN_QUERY_LOG(ctx, flag, mark, format, ...) 1775 if (grn_query_logger_pass(ctx, flag)) { 1776 grn_query_logger_put(ctx, (flag), (mark), format, __VA_ARGS__); 1777 } 1778 */ 1779 1780 /* grn_bulk */ 1781 1782 enum GRN_BULK_BUFSIZE = .grn_obj.sizeof - .grn_obj_header.sizeof; 1783 /* This assumes that .GRN_BULK_BUFSIZE is less than 32 (= 0x20). */ 1784 enum GRN_BULK_BUFSIZE_MAX = 0x1F; 1785 1786 pragma(inline, true) 1787 pure nothrow @trusted @nogc @live 1788 FLAGS GRN_BULK_SIZE_IN_FLAGS(FLAGS)(FLAGS flags) 1789 1790 do 1791 { 1792 return flags & .GRN_BULK_BUFSIZE_MAX; 1793 } 1794 1795 pragma(inline, true) 1796 pure nothrow @trusted @nogc @live 1797 ubyte GRN_BULK_OUTP(scope const .grn_obj* bulk) 1798 1799 in 1800 { 1801 assert(bulk != null); 1802 } 1803 1804 do 1805 { 1806 return bulk.header.impl_flags & .GRN_OBJ_OUTPLACE; 1807 } 1808 1809 pragma(inline, true) 1810 pure nothrow @trusted @nogc @live 1811 void GRN_BULK_REWIND(scope .grn_obj* bulk) 1812 1813 in 1814 { 1815 assert(bulk != null); 1816 } 1817 1818 do 1819 { 1820 if (bulk.header.type == .GRN_VECTOR) { 1821 .grn_obj* _body = bulk.u.v.body_; 1822 1823 if (_body != null) { 1824 if (.GRN_BULK_OUTP(_body)) { 1825 _body.u.b.curr = _body.u.b.head; 1826 } else { 1827 _body.header.flags &= ~.GRN_BULK_BUFSIZE_MAX; 1828 } 1829 } 1830 1831 bulk.u.v.n_sections = 0; 1832 } else { 1833 if (.GRN_BULK_OUTP(bulk)) { 1834 bulk.u.b.curr = bulk.u.b.head; 1835 } else { 1836 bulk.header.flags &= ~.GRN_BULK_BUFSIZE_MAX; 1837 } 1838 } 1839 } 1840 1841 pragma(inline, true) 1842 pure nothrow @trusted @nogc @live 1843 void GRN_BULK_SET_CURR(scope .grn_obj* buf, char* p) 1844 1845 in 1846 { 1847 assert(buf != null); 1848 } 1849 1850 do 1851 { 1852 if (.GRN_BULK_OUTP(buf)) { 1853 buf.u.b.curr = p; 1854 } else { 1855 buf.header.flags = cast(.grn_obj_flags)(p -GRN_BULK_HEAD(buf)); 1856 } 1857 } 1858 1859 pragma(inline, true) 1860 pure nothrow @trusted @nogc @live 1861 void GRN_BULK_INCR_LEN(scope .grn_obj* bulk, size_t len) 1862 1863 in 1864 { 1865 assert(bulk != null); 1866 } 1867 1868 do 1869 { 1870 if (.GRN_BULK_OUTP(bulk)) { 1871 bulk.u.b.curr += len; 1872 } else { 1873 bulk.header.flags += cast(.grn_obj_flags)(len); 1874 } 1875 } 1876 1877 pragma(inline, true) 1878 pure nothrow @trusted @nogc @live 1879 char* GRN_BULK_WSIZE(return scope .grn_obj* bulk) 1880 1881 in 1882 { 1883 assert(bulk != null); 1884 } 1885 1886 do 1887 { 1888 return (.GRN_BULK_OUTP(bulk)) ? (cast(char*)(bulk.u.b.tail - bulk.u.b.head)) : (cast(char*)(.GRN_BULK_BUFSIZE)); 1889 } 1890 1891 pragma(inline, true) 1892 pure nothrow @trusted @nogc @live 1893 char* GRN_BULK_REST(return scope .grn_obj* bulk) 1894 1895 in 1896 { 1897 assert(bulk != null); 1898 } 1899 1900 do 1901 { 1902 return (.GRN_BULK_OUTP(bulk)) ? (cast(char*)(bulk.u.b.tail - bulk.u.b.curr)) : (cast(char*)(.GRN_BULK_BUFSIZE - .GRN_BULK_SIZE_IN_FLAGS(bulk.header.flags))); 1903 } 1904 1905 pragma(inline, true) 1906 pure nothrow @trusted @nogc @live 1907 char* GRN_BULK_VSIZE(return scope .grn_obj* bulk) 1908 1909 in 1910 { 1911 assert(bulk != null); 1912 } 1913 1914 do 1915 { 1916 return (.GRN_BULK_OUTP(bulk)) ? (cast(char*)(bulk.u.b.curr - bulk.u.b.head)) : (cast(char*)(.GRN_BULK_SIZE_IN_FLAGS(bulk.header.flags))); 1917 } 1918 1919 pragma(inline, true) 1920 pure nothrow @trusted @nogc @live 1921 char* GRN_BULK_EMPTYP(return scope .grn_obj* bulk) 1922 1923 in 1924 { 1925 assert(bulk != null); 1926 } 1927 1928 do 1929 { 1930 return (.GRN_BULK_OUTP(bulk)) ? (cast(char*)(bulk.u.b.curr == bulk.u.b.head)) : (cast(char*)(!(.GRN_BULK_SIZE_IN_FLAGS(bulk.header.flags)))); 1931 } 1932 1933 pragma(inline, true) 1934 pure nothrow @trusted @nogc @live 1935 char* GRN_BULK_HEAD(return scope .grn_obj* bulk) 1936 1937 in 1938 { 1939 assert(bulk != null); 1940 } 1941 1942 do 1943 { 1944 return (.GRN_BULK_OUTP(bulk)) ? (bulk.u.b.head) : (cast(char*)(&(bulk.u.b.head))); 1945 } 1946 1947 pragma(inline, true) 1948 pure nothrow @trusted @nogc @live 1949 char* GRN_BULK_CURR(return scope .grn_obj* bulk) 1950 1951 in 1952 { 1953 assert(bulk != null); 1954 } 1955 1956 do 1957 { 1958 return (.GRN_BULK_OUTP(bulk)) ? (bulk.u.b.curr) : (cast(char*)(&(bulk.u.b.head)) + .GRN_BULK_SIZE_IN_FLAGS(bulk.header.flags)); 1959 } 1960 1961 pragma(inline, true) 1962 pure nothrow @trusted @nogc @live 1963 char* GRN_BULK_TAIL(return scope .grn_obj* bulk) 1964 1965 in 1966 { 1967 assert(bulk != null); 1968 } 1969 1970 do 1971 { 1972 return (.GRN_BULK_OUTP(bulk)) ? (bulk.u.b.tail) : (cast(char*)(&(bulk[1]))); 1973 } 1974 1975 //GRN_API 1976 .grn_rc grn_bulk_reinit(.grn_ctx* ctx, .grn_obj* bulk, size_t size); 1977 1978 //GRN_API 1979 .grn_rc grn_bulk_resize(.grn_ctx* ctx, .grn_obj* bulk, size_t newsize); 1980 1981 //GRN_API 1982 .grn_rc grn_bulk_write(.grn_ctx* ctx, .grn_obj* bulk, const (char)* str, size_t len); 1983 1984 //GRN_API 1985 .grn_rc grn_bulk_write_from(.grn_ctx* ctx, .grn_obj* bulk, const (char)* str, size_t from, size_t len); 1986 1987 //GRN_API 1988 .grn_rc grn_bulk_reserve(.grn_ctx* ctx, .grn_obj* bulk, size_t len); 1989 1990 //GRN_API 1991 .grn_rc grn_bulk_space(.grn_ctx* ctx, .grn_obj* bulk, size_t len); 1992 1993 //GRN_API 1994 .grn_rc grn_bulk_truncate(.grn_ctx* ctx, .grn_obj* bulk, size_t len); 1995 1996 //GRN_API 1997 char* grn_bulk_detach(.grn_ctx* ctx, .grn_obj* bulk); 1998 1999 //GRN_API 2000 .grn_rc grn_bulk_fin(.grn_ctx* ctx, .grn_obj* bulk); 2001 2002 /* grn_text */ 2003 2004 //GRN_API 2005 .grn_rc grn_text_itoa(.grn_ctx* ctx, .grn_obj* bulk, int i); 2006 2007 //GRN_API 2008 .grn_rc grn_text_itoa_padded(.grn_ctx* ctx, .grn_obj* bulk, int i, char ch, size_t len); 2009 2010 //GRN_API 2011 .grn_rc grn_text_lltoa(.grn_ctx* ctx, .grn_obj* bulk, long i); 2012 2013 //GRN_API 2014 .grn_rc grn_text_f32toa(.grn_ctx* ctx, .grn_obj* bulk, float f); 2015 2016 //GRN_API 2017 .grn_rc grn_text_ftoa(.grn_ctx* ctx, .grn_obj* bulk, double d); 2018 2019 //GRN_API 2020 .grn_rc grn_text_itoh(.grn_ctx* ctx, .grn_obj* bulk, uint i, size_t len); 2021 2022 //GRN_API 2023 .grn_rc grn_text_itob(.grn_ctx* ctx, .grn_obj* bulk, .grn_id id); 2024 2025 //GRN_API 2026 .grn_rc grn_text_lltob32h(.grn_ctx* ctx, .grn_obj* bulk, long i); 2027 2028 //GRN_API 2029 .grn_rc grn_text_benc(.grn_ctx* ctx, .grn_obj* bulk, uint v); 2030 2031 //GRN_API 2032 .grn_rc grn_text_esc(.grn_ctx* ctx, .grn_obj* bulk, const (char)* s, size_t len); 2033 2034 //GRN_API 2035 .grn_rc grn_text_urlenc(.grn_ctx* ctx, .grn_obj* buf, const (char)* str, size_t len); 2036 2037 //GRN_API 2038 const (char)* grn_text_urldec(.grn_ctx* ctx, .grn_obj* buf, const (char)* s, const (char)* e, char d); 2039 2040 //GRN_API 2041 .grn_rc grn_text_escape_xml(.grn_ctx* ctx, .grn_obj* buf, const (char)* s, size_t len); 2042 2043 //GRN_API 2044 .grn_rc grn_text_time2rfc1123(.grn_ctx* ctx, .grn_obj* bulk, int sec); 2045 2046 /+ 2047 //ToDo: 2048 //GRN_API 2049 .grn_rc grn_text_printf(.grn_ctx* ctx, .grn_obj* bulk, const (char)* format, ...) GRN_ATTRIBUTE_PRINTF(3); 2050 +/ 2051 2052 //GRN_API 2053 .grn_rc grn_text_printfv(.grn_ctx* ctx, .grn_obj* bulk, const (char)* format, core.stdc.stdarg.va_list args); 2054 /* Deprecated since 10.0.3. Use grn_text_printfv() instead. */ 2055 //GRN_API 2056 .grn_rc grn_text_vprintf(.grn_ctx* ctx, .grn_obj* bulk, const (char)* format, core.stdc.stdarg.va_list args); 2057 2058 alias grn_recv_handler_func = extern (C) void function(.grn_ctx* ctx, int flags, void* user_data); 2059 2060 //GRN_API 2061 void grn_ctx_recv_handler_set(.grn_ctx*, .grn_recv_handler_func func, void* user_data); 2062 2063 2064 /* various values exchanged via .grn_obj */ 2065 2066 enum GRN_OBJ_DO_SHALLOW_COPY = .GRN_OBJ_REFER|.GRN_OBJ_OUTPLACE; 2067 enum GRN_OBJ_VECTOR = 0x01 << 7; 2068 2069 /+ 2070 #define GRN_OBJ_DO_SHALLOW_COPY (GRN_OBJ_REFER|GRN_OBJ_OUTPLACE) 2071 #define GRN_OBJ_VECTOR (0x01<<7) 2072 2073 #define GRN_OBJ_MUTABLE(obj) ((obj) && (obj)->header.type <= GRN_VECTOR) 2074 2075 #define GRN_VALUE_FIX_SIZE_INIT(obj,flags,domain)\ 2076 GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_UVECTOR : GRN_BULK,\ 2077 ((flags) & GRN_OBJ_DO_SHALLOW_COPY), (domain)) 2078 #define GRN_VALUE_VAR_SIZE_INIT(obj,flags,domain)\ 2079 GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_VECTOR : GRN_BULK,\ 2080 ((flags) & GRN_OBJ_DO_SHALLOW_COPY), (domain)) 2081 2082 #define GRN_VOID_INIT(obj) GRN_OBJ_INIT((obj), GRN_VOID, 0, GRN_DB_VOID) 2083 #define GRN_TEXT_INIT(obj,flags) \ 2084 GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_TEXT) 2085 #define GRN_SHORT_TEXT_INIT(obj,flags) \ 2086 GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_SHORT_TEXT) 2087 #define GRN_LONG_TEXT_INIT(obj,flags) \ 2088 GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_LONG_TEXT) 2089 #define GRN_TEXT_SET_REF(obj,str,len) do {\ 2090 (obj)->u.b.head = (char *)(str);\ 2091 (obj)->u.b.curr = (char *)(str) + (len);\ 2092 } while (0) 2093 #define GRN_TEXT_SET(ctx,obj,str,len) do {\ 2094 if ((obj)->header.impl_flags & GRN_OBJ_REFER) {\ 2095 GRN_TEXT_SET_REF((obj), (str), (len));\ 2096 } else {\ 2097 grn_bulk_write_from((ctx), (obj), (const char *)(str), 0, (unsigned int)(len));\ 2098 }\ 2099 } while (0) 2100 #define GRN_TEXT_PUT(ctx,obj,str,len) \ 2101 grn_bulk_write((ctx), (obj), (const char *)(str), (unsigned int)(len)) 2102 #define GRN_TEXT_PUTC(ctx,obj,c) do {\ 2103 char _c = (c); grn_bulk_write((ctx), (obj), &_c, 1);\ 2104 } while (0) 2105 2106 #define GRN_TEXT_PUTS(ctx,obj,str) GRN_TEXT_PUT((ctx), (obj), (str), strlen(str)) 2107 #define GRN_TEXT_SETS(ctx,obj,str) GRN_TEXT_SET((ctx), (obj), (str), strlen(str)) 2108 #define GRN_TEXT_VALUE(obj) GRN_BULK_HEAD(obj) 2109 #define GRN_TEXT_LEN(obj) GRN_BULK_VSIZE(obj) 2110 2111 #define GRN_TEXT_EQUAL_CSTRING(bulk, string_)\ 2112 (GRN_TEXT_LEN(bulk) == strlen(string_) &&\ 2113 memcmp(GRN_TEXT_VALUE(bulk), string_, GRN_TEXT_LEN(bulk)) == 0) 2114 2115 #define GRN_BOOL_INIT(obj,flags) \ 2116 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_BOOL) 2117 #define GRN_INT8_INIT(obj,flags) \ 2118 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT8) 2119 #define GRN_UINT8_INIT(obj,flags) \ 2120 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT8) 2121 #define GRN_INT16_INIT(obj,flags) \ 2122 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT16) 2123 #define GRN_UINT16_INIT(obj,flags) \ 2124 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT16) 2125 #define GRN_INT32_INIT(obj,flags) \ 2126 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT32) 2127 #define GRN_UINT32_INIT(obj,flags) \ 2128 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT32) 2129 #define GRN_INT64_INIT(obj,flags) \ 2130 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT64) 2131 #define GRN_UINT64_INIT(obj,flags) \ 2132 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT64) 2133 #define GRN_FLOAT32_INIT(obj, flags) \ 2134 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT32) 2135 #define GRN_FLOAT_INIT(obj,flags) \ 2136 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT) 2137 #define GRN_TIME_INIT(obj,flags) \ 2138 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TIME) 2139 #define GRN_RECORD_INIT GRN_VALUE_FIX_SIZE_INIT 2140 #define GRN_PTR_INIT(obj,flags,domain)\ 2141 GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_PVECTOR : GRN_PTR,\ 2142 ((flags) & (GRN_OBJ_DO_SHALLOW_COPY | GRN_OBJ_OWN)),\ 2143 (domain)) 2144 #define GRN_TOKYO_GEO_POINT_INIT(obj,flags) \ 2145 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TOKYO_GEO_POINT) 2146 #define GRN_WGS84_GEO_POINT_INIT(obj,flags) \ 2147 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_WGS84_GEO_POINT) 2148 2149 #define GRN_BOOL_SET(ctx,obj,val) do {\ 2150 bool _val = (bool)(val);\ 2151 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(bool));\ 2152 } while (0) 2153 #define GRN_INT8_SET(ctx,obj,val) do {\ 2154 int8_t _val = (int8_t)(val);\ 2155 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int8_t));\ 2156 } while (0) 2157 #define GRN_UINT8_SET(ctx,obj,val) do {\ 2158 uint8_t _val = (uint8_t)(val);\ 2159 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint8_t));\ 2160 } while (0) 2161 #define GRN_INT16_SET(ctx,obj,val) do {\ 2162 int16_t _val = (int16_t)(val);\ 2163 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int16_t));\ 2164 } while (0) 2165 #define GRN_UINT16_SET(ctx,obj,val) do {\ 2166 uint16_t _val = (uint16_t)(val);\ 2167 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint16_t));\ 2168 } while (0) 2169 #define GRN_INT32_SET(ctx,obj,val) do {\ 2170 int32_t _val = (int32_t)(val);\ 2171 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int32_t));\ 2172 } while (0) 2173 #define GRN_UINT32_SET(ctx,obj,val) do {\ 2174 uint32_t _val = (uint32_t)(val);\ 2175 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint32_t));\ 2176 } while (0) 2177 #define GRN_INT64_SET(ctx,obj,val) do {\ 2178 int64_t _val = (int64_t)(val);\ 2179 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int64_t));\ 2180 } while (0) 2181 #define GRN_UINT64_SET(ctx,obj,val) do {\ 2182 uint64_t _val = (uint64_t)(val);\ 2183 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint64_t));\ 2184 } while (0) 2185 #define GRN_FLOAT32_SET(ctx, obj, val) \ 2186 do { \ 2187 float _val = (float) (val); \ 2188 grn_bulk_write_from((ctx), (obj), (char*) &_val, 0, sizeof(float)); \ 2189 } while (0) 2190 #define GRN_FLOAT_SET(ctx,obj,val) do {\ 2191 double _val = (double)(val);\ 2192 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(double));\ 2193 } while (0) 2194 #define GRN_TIME_SET GRN_INT64_SET 2195 #define GRN_RECORD_SET(ctx,obj,val) do {\ 2196 grn_id _val = (grn_id)(val);\ 2197 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_id));\ 2198 } while (0) 2199 #define GRN_PTR_SET(ctx,obj,val) do {\ 2200 grn_obj *_val = (grn_obj *)(val);\ 2201 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_obj *));\ 2202 } while (0) 2203 2204 #define GRN_GEO_DEGREE2MSEC(degree)\ 2205 ((int32_t)((degree) * 3600 * 1000 + ((degree) > 0 ? 0.5 : -0.5))) 2206 #define GRN_GEO_MSEC2DEGREE(msec)\ 2207 ((((int32_t)(msec)) / 3600.0) * 0.001) 2208 2209 #define GRN_GEO_POINT_SET(ctx,obj,_latitude,_longitude) do {\ 2210 grn_geo_point _val;\ 2211 _val.latitude = (int)(_latitude);\ 2212 _val.longitude = (int)(_longitude);\ 2213 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_geo_point));\ 2214 } while (0) 2215 2216 #define GRN_BOOL_SET_AT(ctx,obj,offset,val) do {\ 2217 bool _val = (bool)(val);\ 2218 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2219 (offset), sizeof(bool));\ 2220 } while (0) 2221 #define GRN_INT8_SET_AT(ctx,obj,offset,val) do {\ 2222 int8_t _val = (int8_t)(val);\ 2223 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2224 (offset) * sizeof(int8_t), sizeof(int8_t));\ 2225 } while (0) 2226 #define GRN_UINT8_SET_AT(ctx,obj,offset,val) do { \ 2227 uint8_t _val = (uint8_t)(val);\ 2228 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2229 (offset) * sizeof(uint8_t), sizeof(uint8_t));\ 2230 } while (0) 2231 #define GRN_INT16_SET_AT(ctx,obj,offset,val) do {\ 2232 int16_t _val = (int16_t)(val);\ 2233 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2234 (offset) * sizeof(int16_t), sizeof(int16_t));\ 2235 } while (0) 2236 #define GRN_UINT16_SET_AT(ctx,obj,offset,val) do { \ 2237 uint16_t _val = (uint16_t)(val);\ 2238 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2239 (offset) * sizeof(uint16_t), sizeof(uint16_t));\ 2240 } while (0) 2241 #define GRN_INT32_SET_AT(ctx,obj,offset,val) do {\ 2242 int32_t _val = (int32_t)(val);\ 2243 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2244 (offset) * sizeof(int32_t), sizeof(int32_t));\ 2245 } while (0) 2246 #define GRN_UINT32_SET_AT(ctx,obj,offset,val) do { \ 2247 uint32_t _val = (uint32_t)(val);\ 2248 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2249 (offset) * sizeof(uint32_t), sizeof(uint32_t));\ 2250 } while (0) 2251 #define GRN_INT64_SET_AT(ctx,obj,offset,val) do {\ 2252 int64_t _val = (int64_t)(val);\ 2253 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2254 (offset) * sizeof(int64_t), sizeof(int64_t));\ 2255 } while (0) 2256 #define GRN_UINT64_SET_AT(ctx,obj,offset,val) do {\ 2257 uint64_t _val = (uint64_t)(val);\ 2258 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2259 (offset) * sizeof(uint64_t),\ 2260 sizeof(uint64_t));\ 2261 } while (0) 2262 #define GRN_FLOAT32_SET_AT(ctx, obj, offset, val) \ 2263 do { \ 2264 float _val = (float) (val); \ 2265 grn_bulk_write_from((ctx), (obj), (char*) &_val, (offset) * sizeof(float), sizeof(float)); \ 2266 } while (0) 2267 #define GRN_FLOAT_SET_AT(ctx,obj,offset,val) do {\ 2268 double _val = (double)(val);\ 2269 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2270 (offset) * sizeof(double), sizeof(double));\ 2271 } while (0) 2272 #define GRN_TIME_SET_AT GRN_INT64_SET_AT 2273 #define GRN_RECORD_SET_AT(ctx,obj,offset,val) do {\ 2274 grn_id _val = (grn_id)(val);\ 2275 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2276 (offset) * sizeof(grn_id), sizeof(grn_id));\ 2277 } while (0) 2278 #define GRN_PTR_SET_AT(ctx,obj,offset,val) do {\ 2279 grn_obj *_val = (grn_obj *)(val);\ 2280 grn_bulk_write_from((ctx), (obj), (char *)&_val,\ 2281 (offset) * sizeof(grn_obj *), sizeof(grn_obj *));\ 2282 } while (0) 2283 2284 #define GRN_BOOL_VALUE(obj) (*((bool *)GRN_BULK_HEAD(obj))) 2285 #define GRN_INT8_VALUE(obj) (*((int8_t *)GRN_BULK_HEAD(obj))) 2286 #define GRN_UINT8_VALUE(obj) (*((uint8_t *)GRN_BULK_HEAD(obj))) 2287 #define GRN_INT16_VALUE(obj) (*((int16_t *)GRN_BULK_HEAD(obj))) 2288 #define GRN_UINT16_VALUE(obj) (*((uint16_t *)GRN_BULK_HEAD(obj))) 2289 #define GRN_INT32_VALUE(obj) (*((int32_t *)GRN_BULK_HEAD(obj))) 2290 #define GRN_UINT32_VALUE(obj) (*((uint32_t *)GRN_BULK_HEAD(obj))) 2291 #define GRN_INT64_VALUE(obj) (*((int64_t *)GRN_BULK_HEAD(obj))) 2292 #define GRN_UINT64_VALUE(obj) (*((uint64_t *)GRN_BULK_HEAD(obj))) 2293 #define GRN_FLOAT32_VALUE(obj) (*((float*) GRN_BULK_HEAD(obj))) 2294 #define GRN_FLOAT_VALUE(obj) (*((double *)GRN_BULK_HEAD(obj))) 2295 #define GRN_TIME_VALUE GRN_INT64_VALUE 2296 #define GRN_RECORD_VALUE(obj) (*((grn_id *)GRN_BULK_HEAD(obj))) 2297 #define GRN_PTR_VALUE(obj) (*((grn_obj **)GRN_BULK_HEAD(obj))) 2298 #define GRN_GEO_POINT_VALUE(obj,_latitude,_longitude) do {\ 2299 grn_geo_point *_val = (grn_geo_point *)GRN_BULK_HEAD(obj);\ 2300 _latitude = _val->latitude;\ 2301 _longitude = _val->longitude;\ 2302 } while (0) 2303 2304 #define GRN_BOOL_VALUE_AT(obj,offset) (((bool *)GRN_BULK_HEAD(obj))[offset]) 2305 #define GRN_INT8_VALUE_AT(obj,offset) (((int8_t *)GRN_BULK_HEAD(obj))[offset]) 2306 #define GRN_UINT8_VALUE_AT(obj,offset) (((uint8_t *)GRN_BULK_HEAD(obj))[offset]) 2307 #define GRN_INT16_VALUE_AT(obj,offset) (((int16_t *)GRN_BULK_HEAD(obj))[offset]) 2308 #define GRN_UINT16_VALUE_AT(obj,offset) (((uint16_t *)GRN_BULK_HEAD(obj))[offset]) 2309 #define GRN_INT32_VALUE_AT(obj,offset) (((int32_t *)GRN_BULK_HEAD(obj))[offset]) 2310 #define GRN_UINT32_VALUE_AT(obj,offset) (((uint32_t *)GRN_BULK_HEAD(obj))[offset]) 2311 #define GRN_INT64_VALUE_AT(obj,offset) (((int64_t *)GRN_BULK_HEAD(obj))[offset]) 2312 #define GRN_UINT64_VALUE_AT(obj,offset) (((uint64_t *)GRN_BULK_HEAD(obj))[offset]) 2313 #define GRN_FLOAT32_VALUE_AT(obj, offset) (((float*) GRN_BULK_HEAD(obj))[offset]) 2314 #define GRN_FLOAT_VALUE_AT(obj,offset) (((double *)GRN_BULK_HEAD(obj))[offset]) 2315 #define GRN_TIME_VALUE_AT GRN_INT64_VALUE_AT 2316 #define GRN_RECORD_VALUE_AT(obj,offset) (((grn_id *)GRN_BULK_HEAD(obj))[offset]) 2317 #define GRN_PTR_VALUE_AT(obj,offset) (((grn_obj **)GRN_BULK_HEAD(obj))[offset]) 2318 2319 #define GRN_BOOL_PUT(ctx,obj,val) do {\ 2320 bool _val = (bool)(val);\ 2321 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(bool));\ 2322 } while (0) 2323 #define GRN_INT8_PUT(ctx,obj,val) do {\ 2324 int8_t _val = (int8_t)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int8_t));\ 2325 } while (0) 2326 #define GRN_UINT8_PUT(ctx,obj,val) do {\ 2327 uint8_t _val = (uint8_t)(val);\ 2328 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint8_t));\ 2329 } while (0) 2330 #define GRN_INT16_PUT(ctx,obj,val) do {\ 2331 int16_t _val = (int16_t)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int16_t));\ 2332 } while (0) 2333 #define GRN_UINT16_PUT(ctx,obj,val) do {\ 2334 uint16_t _val = (uint16_t)(val);\ 2335 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint16_t));\ 2336 } while (0) 2337 #define GRN_INT32_PUT(ctx,obj,val) do {\ 2338 int32_t _val = (int32_t)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int32_t));\ 2339 } while (0) 2340 #define GRN_UINT32_PUT(ctx,obj,val) do {\ 2341 uint32_t _val = (uint32_t)(val);\ 2342 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned int));\ 2343 } while (0) 2344 #define GRN_INT64_PUT(ctx,obj,val) do {\ 2345 int64_t _val = (int64_t)(val);\ 2346 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int64_t));\ 2347 } while (0) 2348 #define GRN_UINT64_PUT(ctx,obj,val) do {\ 2349 uint64_t _val = (uint64_t)(val);\ 2350 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint64_t));\ 2351 } while (0) 2352 #define GRN_FLOAT32_PUT(ctx, obj, val) \ 2353 do { \ 2354 float _val = (float) (val); \ 2355 grn_bulk_write((ctx), (obj), (char*) &_val, sizeof(float)); \ 2356 } while (0) 2357 #define GRN_FLOAT_PUT(ctx,obj,val) do {\ 2358 double _val = (double)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(double));\ 2359 } while (0) 2360 #define GRN_TIME_PUT GRN_INT64_PUT 2361 #define GRN_RECORD_PUT(ctx,obj,val) do {\ 2362 grn_id _val = (grn_id)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_id));\ 2363 } while (0) 2364 #define GRN_PTR_PUT(ctx,obj,val) do {\ 2365 grn_obj *_val = (grn_obj *)(val);\ 2366 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_obj *));\ 2367 } while (0) 2368 2369 #define GRN_BULK_POP(obj, value, type, default) do {\ 2370 if (GRN_BULK_VSIZE(obj) >= sizeof(type)) {\ 2371 GRN_BULK_INCR_LEN((obj), -(sizeof(type)));\ 2372 value = *(type *)(GRN_BULK_CURR(obj));\ 2373 } else {\ 2374 value = default;\ 2375 }\ 2376 } while (0) 2377 #define GRN_BOOL_POP(obj, value) GRN_BULK_POP(obj, value, bool, 0) 2378 #define GRN_INT8_POP(obj, value) GRN_BULK_POP(obj, value, int8_t, 0) 2379 #define GRN_UINT8_POP(obj, value) GRN_BULK_POP(obj, value, uint8_t, 0) 2380 #define GRN_INT16_POP(obj, value) GRN_BULK_POP(obj, value, int16_t, 0) 2381 #define GRN_UINT16_POP(obj, value) GRN_BULK_POP(obj, value, uint16_t, 0) 2382 #define GRN_INT32_POP(obj, value) GRN_BULK_POP(obj, value, int32_t, 0) 2383 #define GRN_UINT32_POP(obj, value) GRN_BULK_POP(obj, value, uint32_t, 0) 2384 #define GRN_INT64_POP(obj, value) GRN_BULK_POP(obj, value, int64_t, 0) 2385 #define GRN_UINT64_POP(obj, value) GRN_BULK_POP(obj, value, uint64_t, 0) 2386 #define GRN_FLOAT32_POP(obj, value) GRN_BULK_POP(obj, value, float, 0.0) 2387 #define GRN_FLOAT_POP(obj, value) GRN_BULK_POP(obj, value, double, 0.0) 2388 #define GRN_TIME_POP GRN_INT64_POP 2389 #define GRN_RECORD_POP(obj, value) GRN_BULK_POP(obj, value, grn_id, GRN_ID_NIL) 2390 #define GRN_PTR_POP(obj, value) GRN_BULK_POP(obj, value, grn_obj *, NULL) 2391 2392 #define GRN_BULK_VECTOR_SIZE(obj, type) (GRN_BULK_VSIZE(obj) / sizeof(type)) 2393 #define GRN_BOOL_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, bool) 2394 #define GRN_INT8_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int8_t) 2395 #define GRN_UINT8_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint8_t) 2396 #define GRN_INT16_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int16_t) 2397 #define GRN_UINT16_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint16_t) 2398 #define GRN_INT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int32_t) 2399 #define GRN_UINT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint32_t) 2400 #define GRN_INT64_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int64_t) 2401 #define GRN_UINT64_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint64_t) 2402 #define GRN_FLOAT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, float) 2403 #define GRN_FLOAT_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, double) 2404 #define GRN_TIME_VECTOR_SIZE GRN_INT64_VECTOR_SIZE 2405 #define GRN_RECORD_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, grn_id) 2406 #define GRN_PTR_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, grn_obj *) 2407 +/ 2408 2409 //GRN_API 2410 .grn_rc grn_ctx_push(.grn_ctx* ctx, .grn_obj* obj); 2411 2412 //GRN_API 2413 .grn_obj* grn_ctx_pop(.grn_ctx* ctx); 2414 2415 //GRN_API 2416 int grn_obj_columns(.grn_ctx* ctx, .grn_obj* table, const (char)* str, uint str_size, .grn_obj* res); 2417 2418 //GRN_API 2419 .grn_rc grn_load(.grn_ctx* ctx, .grn_content_type input_type, const (char)* table, uint table_len, const (char)* columns, uint columns_len, const (char)* values, uint values_len, const (char)* ifexists, uint ifexists_len, const (char)* each, uint each_len); 2420 2421 enum GRN_CTX_MORE = 0x01 << 0; 2422 enum GRN_CTX_TAIL = 0x01 << 1; 2423 enum GRN_CTX_HEAD = 0x01 << 2; 2424 enum GRN_CTX_QUIET = 0x01 << 3; 2425 enum GRN_CTX_QUIT = 0x01 << 4; 2426 2427 //GRN_API 2428 .grn_rc grn_ctx_connect(.grn_ctx* ctx, const (char)* host, int port, int flags); 2429 2430 //GRN_API 2431 uint grn_ctx_send(.grn_ctx* ctx, const (char)* str, uint str_len, int flags); 2432 2433 //GRN_API 2434 uint grn_ctx_recv(.grn_ctx* ctx, char** str, uint* str_len, int* flags); 2435 2436 struct _grn_ctx_info 2437 { 2438 int fd; 2439 uint com_status; 2440 .grn_obj* outbuf; 2441 ubyte stat; 2442 } 2443 2444 alias grn_ctx_info = ._grn_ctx_info; 2445 2446 //GRN_API 2447 .grn_rc grn_ctx_info_get(.grn_ctx* ctx, .grn_ctx_info* info); 2448 2449 //GRN_API 2450 .grn_rc grn_set_segv_handler(); 2451 2452 //GRN_API 2453 .grn_rc grn_set_int_handler(); 2454 2455 //GRN_API 2456 .grn_rc grn_set_term_handler(); 2457 2458 struct _grn_table_delete_optarg 2459 { 2460 extern (C): 2461 int flags; 2462 int function(.grn_ctx* ctx, .grn_obj*, .grn_id, void*) func; 2463 void* func_arg; 2464 } 2465 2466 alias grn_table_delete_optarg = ._grn_table_delete_optarg; 2467 2468 struct _grn_table_scan_hit 2469 { 2470 .grn_id id; 2471 uint offset; 2472 uint length; 2473 } 2474 2475 struct grn_timeval 2476 { 2477 long tv_sec; 2478 int tv_nsec; 2479 }