├── .gitignore ├── CREDITS ├── EXPERIMENTAL ├── README.md ├── config.m4 ├── config.w32 ├── php_rocksdb.c ├── php_rocksdb.h ├── rocksdb.c ├── rocksdb.php ├── rocksdb_backup_engine.c ├── rocksdb_backup_engine_info.c ├── rocksdb_cache.c ├── rocksdb_ce.h ├── rocksdb_compaction_filter.c ├── rocksdb_comparator.c ├── rocksdb_exception.c ├── rocksdb_fe.h ├── rocksdb_iterator.c ├── rocksdb_merge_operator.c ├── rocksdb_snapshot.c ├── rocksdb_write_batch.c └── tests ├── 001.phpt ├── 002-basic.phpt ├── 003-open.phpt ├── 004-open.phpt ├── 005-open-cf.phpt ├── 006-open-cf.phpt ├── 007-destroy.phpt ├── 008-iterator.phpt ├── 009-write-batch.phpt ├── 010-snapshot.phpt ├── 011-backup-engine.phpt └── 012-backup-engine-info.phpt /.gitignore: -------------------------------------------------------------------------------- 1 | .deps 2 | *.lo 3 | *.la 4 | .libs 5 | acinclude.m4 6 | aclocal.m4 7 | autom4te.cache 8 | build 9 | config.guess 10 | config.h 11 | config.h.in 12 | config.log 13 | config.nice 14 | config.status 15 | config.sub 16 | configure 17 | configure.in 18 | include 19 | install-sh 20 | libtool 21 | ltmain.sh 22 | Makefile 23 | Makefile.fragments 24 | Makefile.global 25 | Makefile.objects 26 | missing 27 | mkinstalldirs 28 | modules 29 | run-tests.php 30 | tests/*.diff 31 | tests/*.out 32 | tests/*.php 33 | tests/*.exp 34 | tests/*.log 35 | tests/*.sh 36 | php_rocksdb.o 37 | rocksdb.o 38 | rocksdb_backup_engine.o 39 | rocksdb_backup_engine_info.o 40 | rocksdb_cache.o 41 | rocksdb_compaction_filter.o 42 | rocksdb_comparator.o 43 | rocksdb_exception.o 44 | rocksdb_iterator.o 45 | rocksdb_merge_operator.o 46 | rocksdb_snapshot.o 47 | rocksdb_write_batch.o 48 | -------------------------------------------------------------------------------- /CREDITS: -------------------------------------------------------------------------------- 1 | rocksdb -------------------------------------------------------------------------------- /EXPERIMENTAL: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/phpize7/php-rocksdb/c9d2afc75e26b1c7ed47417d06dabbd157ccb9d6/EXPERIMENTAL -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # PHP-RocksDb: RocksDb implementation for PHP 2 | 3 | The RocksDB library provides a persistent key value store. Keys and values are arbitrary byte arrays. The keys are ordered within the key value store according to a user-specified comparator function. 4 | 5 | ## Installation 6 | 7 | Upgrade your gcc to version at least 4.8 to get C++11 support. 8 | Install gflags. First, try: sudo apt-get install libgflags-dev If this doesn't work and you're using Ubuntu, here's a nice tutorial: (http://askubuntu.com/questions/312173/installing-gflags-12-04) 9 | Install snappy. This is usually as easy as: sudo apt-get install libsnappy-dev. 10 | Install zlib. Try: sudo apt-get install zlib1g-dev. 11 | Install bzip2: sudo apt-get install libbz2-dev. 12 | Install zstandard: sudo apt-get install libzstd-dev. 13 | 14 | $ git@github.com:facebook/rocksdb.git 15 | $ make static_lib 16 | 17 | $ git clone https://github.com/phpize7/php-rocksdb.git 18 | $ cd php-rocksdb 19 | $ phpize 20 | $ ./configure 21 | $ make 22 | $ make install 23 | 24 | # Usage 25 | See tests 26 | -------------------------------------------------------------------------------- /config.m4: -------------------------------------------------------------------------------- 1 | dnl 2 | dnl $Id$ 3 | dnl 4 | 5 | PHP_ARG_ENABLE(rocksdb, whether to enable RocksDb support, 6 | [ --disable-rocksdb Disable RocksDb support], yes) 7 | 8 | if test "$PHP_ROCKSDB" != "no"; then 9 | AC_DEFINE([HAVE_ROCKSDB],1 ,[whether to enable RocksDb support]) 10 | AC_HEADER_STDC 11 | 12 | PHP_ADD_LIBRARY_WITH_PATH("rocksdb", "/usr/local/lib", ROCKSDB_SHARED_LIBADD) 13 | PHP_SUBST(ROCKSDB_SHARED_LIBADD) 14 | 15 | PHP_NEW_EXTENSION(rocksdb, 16 | php_rocksdb.c \ 17 | rocksdb.c \ 18 | rocksdb_backup_engine_info.c \ 19 | rocksdb_cache.c \ 20 | rocksdb_backup_engine.c \ 21 | rocksdb_iterator.c \ 22 | rocksdb_snapshot.c \ 23 | rocksdb_write_batch.c \ 24 | rocksdb_compaction_filter.c \ 25 | rocksdb_comparator.c \ 26 | rocksdb_merge_operator.c \ 27 | rocksdb_exception.c, 28 | $ext_shared,, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1) 29 | 30 | PHP_INSTALL_HEADERS([ext/rocksdb], [php_rocksdb.h]) 31 | PHP_ADD_MAKEFILE_FRAGMENT() 32 | fi 33 | -------------------------------------------------------------------------------- /config.w32: -------------------------------------------------------------------------------- 1 | // $Id$ 2 | // vim:ft=javascript 3 | 4 | // If your extension references something external, use ARG_WITH 5 | // ARG_WITH("rocksdb", "for rocksdb support", "no"); 6 | 7 | // Otherwise, use ARG_ENABLE 8 | // ARG_ENABLE("rocksdb", "enable rocksdb support", "no"); 9 | 10 | if (PHP_ROCKSDB != "no") { 11 | EXTENSION("rocksdb", "rocksdb.c", PHP_EXTNAME_SHARED, "/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1"); 12 | } 13 | 14 | -------------------------------------------------------------------------------- /php_rocksdb.c: -------------------------------------------------------------------------------- 1 | /* 2 | +----------------------------------------------------------------------+ 3 | | PHP Version 7 | 4 | +----------------------------------------------------------------------+ 5 | | Copyright (c) 1997-2015 The PHP Group | 6 | +----------------------------------------------------------------------+ 7 | | This source file is subject to version 3.01 of the PHP license, | 8 | | that is bundled with this package in the file LICENSE, and is | 9 | | available through the world-wide-web at the following url: | 10 | | http://www.php.net/license/3_01.txt | 11 | | If you did not receive a copy of the PHP license and are unable to | 12 | | obtain it through the world-wide-web, please send a note to | 13 | | license@php.net so we can mail you a copy immediately. | 14 | +----------------------------------------------------------------------+ 15 | | Author: | 16 | +----------------------------------------------------------------------+ 17 | */ 18 | 19 | /* $Id$ */ 20 | 21 | #ifdef HAVE_CONFIG_H 22 | #include "config.h" 23 | #endif 24 | 25 | #include "php.h" 26 | #include "php_ini.h" 27 | #include "ext/standard/info.h" 28 | #include "ext/spl/spl_iterators.h" 29 | #include "ext/spl/spl_exceptions.h" 30 | #include "rocksdb/c.h" 31 | #include "Zend/zend_types.h" 32 | #include "zend_exceptions.h" 33 | #include "stdbool.h" 34 | #include "php_rocksdb.h" 35 | 36 | ZEND_DECLARE_MODULE_GLOBALS(rocksdb); 37 | 38 | static zend_object_handlers rocksdb_default_handlers; 39 | static zend_object_handlers rocksdb_iterator_handlers; 40 | static zend_object_handlers rocksdb_backup_engine_info_handlers; 41 | 42 | static zend_object* php_rocksdb_object_new(zend_class_entry *ce) 43 | { 44 | php_rocksdb_db_object *obj; 45 | 46 | obj = emalloc(sizeof(*obj)); 47 | memset(obj, 0, sizeof(*obj)); 48 | 49 | zend_object_std_init(&obj->zo, ce); 50 | obj->zo.handlers = &rocksdb_default_handlers; 51 | 52 | return &obj->zo; 53 | } 54 | 55 | static zend_object* php_rocksdb_iterator_object_new(zend_class_entry *ce) 56 | { 57 | php_rocksdb_iterator_object *obj; 58 | 59 | obj = emalloc(sizeof(*obj)); 60 | memset(obj, 0, sizeof(*obj)); 61 | 62 | zend_object_std_init(&obj->zo, ce); 63 | obj->zo.handlers = &rocksdb_iterator_handlers; 64 | 65 | return &obj->zo; 66 | } 67 | 68 | static zend_object* php_rocksdb_backup_engine_info_object_new(zend_class_entry *ce) 69 | { 70 | php_rocksdb_backup_engine_info_object *obj; 71 | 72 | obj = emalloc(sizeof(*obj)); 73 | memset(obj, 0, sizeof(*obj)); 74 | 75 | zend_object_std_init(&obj->zo, ce); 76 | obj->zo.handlers = &rocksdb_backup_engine_info_handlers; 77 | 78 | return &obj->zo; 79 | } 80 | 81 | 82 | static void rocksdb_free_storage(zend_object *obj) 83 | { 84 | php_rocksdb_db_object *object = (php_rocksdb_db_object*) obj; 85 | 86 | if (object->db) { 87 | rocksdb_close(object->db); 88 | } 89 | //efree(object->name); 90 | efree(object->handles); 91 | } 92 | 93 | static void php_rocksdb_register_classes() 94 | { 95 | zend_class_entry ce, 96 | ce_backup_info, 97 | ce_compaction_filter, 98 | ce_iterator, 99 | ce_comparator, 100 | ce_merge_operator, 101 | ce_snapshot, 102 | ce_write_batch, 103 | ce_backup_engine, 104 | ce_exception; 105 | 106 | memcpy(&rocksdb_default_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); 107 | rocksdb_default_handlers.offset = XtOffsetOf(php_rocksdb_db_object, zo); 108 | rocksdb_default_handlers.free_obj = rocksdb_free_storage; 109 | INIT_CLASS_ENTRY(ce, ZEND_NS_NAME("RocksDb", "RocksDb"), rocksdb_class_methods); 110 | ce.create_object = php_rocksdb_object_new; 111 | rocksdb_ce = zend_register_internal_class(&ce); 112 | 113 | INIT_CLASS_ENTRY(ce_backup_engine, ZEND_NS_NAME("RocksDb", "BackupEngine"), rocksdb_backup_engine_class_methods); 114 | rocksdb_backup_engine_ce = zend_register_internal_class(&ce_backup_engine); 115 | 116 | memcpy(&rocksdb_backup_engine_info_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); 117 | rocksdb_backup_engine_info_handlers.offset = XtOffsetOf(php_rocksdb_backup_engine_info_object, zo); 118 | //rocksdb_beckup_engine_info_handlers.free_obj = rocksdb_free_storage; 119 | INIT_CLASS_ENTRY(ce_backup_info, ZEND_NS_NAME("RocksDb", "BackupEngineInfo"), rocksdb_backup_engine_info_class_methods); 120 | ce_backup_info.create_object = php_rocksdb_backup_engine_info_object_new; 121 | rocksdb_backup_engine_info_ce = zend_register_internal_class(&ce_backup_info); 122 | 123 | INIT_CLASS_ENTRY(ce_snapshot, ZEND_NS_NAME("RocksDb", "Snapshot"), rocksdb_snapshot_class_methods); 124 | rocksdb_snapshot_ce = zend_register_internal_class(&ce_snapshot); 125 | 126 | INIT_CLASS_ENTRY(ce_write_batch, ZEND_NS_NAME("RocksDb", "WriteBatch"), rocksdb_write_batch_class_methods); 127 | rocksdb_write_batch_ce = zend_register_internal_class(&ce_write_batch); 128 | 129 | memcpy(&rocksdb_iterator_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); 130 | rocksdb_iterator_handlers.offset = XtOffsetOf(php_rocksdb_iterator_object, zo); 131 | //rocksdb_iterator_handlers.free_obj = rocksdb_iterator_free_storage; 132 | INIT_CLASS_ENTRY(ce_iterator, ZEND_NS_NAME("RocksDb", "Iterator"), rocksdb_iterator_class_methods); 133 | ce_iterator.create_object = php_rocksdb_iterator_object_new; 134 | rocksdb_iterator_ce = zend_register_internal_class(&ce_iterator); 135 | 136 | zend_class_implements(rocksdb_iterator_ce, 1, spl_ce_SeekableIterator); 137 | INIT_CLASS_ENTRY(ce_exception, ZEND_NS_NAME("RocksDb", "Exception"), NULL); 138 | rocksdb_exception_ce = zend_register_internal_class_ex(&ce_exception, spl_ce_RuntimeException); 139 | 140 | // Interfaces 141 | INIT_CLASS_ENTRY(ce_compaction_filter, ZEND_NS_NAME("RocksDb", "CompactionFilter"), rocksdb_compaction_filter_interface_methods); 142 | rocksdb_compaction_filter_ce = zend_register_internal_interface(&ce_compaction_filter); 143 | INIT_CLASS_ENTRY(ce_comparator, ZEND_NS_NAME("RocksDb", "Comparator"), rocksdb_comparator_interface_methods); 144 | rocksdb_comparator_ce = zend_register_internal_interface(&ce_comparator); 145 | INIT_CLASS_ENTRY(ce_merge_operator, ZEND_NS_NAME("RocksDb", "MergeOperator"), rocksdb_merge_operator_interface_methods); 146 | rocksdb_merge_operator_ce = zend_register_internal_interface(&ce_merge_operator); 147 | 148 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_TOLERATE_CORRUPTED_TAIL_RECORDS_RECOVERY", ROCKSDB_TOLERATE_CORRUPTED_TAIL_RECORDS_RECOVERY); 149 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_ABSOLUTE_CONSISTENCY_RECOVERY", ROCKSDB_ABSOLUTE_CONSISTENCY_RECOVERY); 150 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_POINT_IN_TIME_RECOVERY", ROCKSDB_POINT_IN_TIME_RECOVERY); 151 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_SKIP_ANY_CORRUPTED_RECORDS_RECOVERY", ROCKSDB_SKIP_ANY_CORRUPTED_RECORDS_RECOVERY); 152 | 153 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_NO_COMPRESSION", ROCKSDB_NO_COMPRESSION); 154 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_SNAPPY_COMPRESSION", ROCKSDB_SNAPPY_COMPRESSION); 155 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_ZLIB_COMPRESSION", ROCKSDB_ZLIB_COMPRESSION); 156 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_BZ2_COMPRESSION", ROCKSDB_BZ2_COMPRESSION); 157 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_LZ4_COMPRESSION", ROCKSDB_LZ4_COMPRESSION); 158 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_LZ4HC_COMPRESSION", ROCKSDB_LZ4HC_COMPRESSION); 159 | 160 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_LEVEL_COMPATION", ROCKSDB_LEVEL_COMPATION); 161 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_UNIVERSAL_COMPACTION", ROCKSDB_UNIVERSAL_COMPACTION); 162 | PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(rocksdb_ce, "ROCKSDB_FIFO_COMPACTION", ROCKSDB_FIFO_COMPACTION); 163 | } 164 | 165 | /* {{{ PHP_MINIT_FUNCTION 166 | */ 167 | PHP_MINIT_FUNCTION(rocksdb) 168 | { 169 | 170 | //REGISTER_INI_ENTRIES(); 171 | php_rocksdb_register_classes(); 172 | 173 | return SUCCESS; 174 | } 175 | /* }}} */ 176 | 177 | /* {{{ PHP_GINIT_FUNCTION 178 | */ 179 | PHP_GINIT_FUNCTION(rocksdb) 180 | { 181 | rocksdb_globals->create_if_missing = 0; 182 | rocksdb_globals->max_open_files = 0; 183 | rocksdb_globals->write_buffer_size = 0; 184 | rocksdb_globals->max_write_buffer_number = 0; 185 | rocksdb_globals->target_file_size_base = 0; 186 | } 187 | /* }}} */ 188 | 189 | /* {{{ PHP_MSHUTDOWN_FUNCTION 190 | */ 191 | PHP_MSHUTDOWN_FUNCTION(rocksdb) 192 | { 193 | UNREGISTER_INI_ENTRIES(); 194 | 195 | return SUCCESS; 196 | } 197 | /* }}} */ 198 | 199 | 200 | /* {{{ PHP_MINFO_FUNCTION 201 | */ 202 | PHP_MINFO_FUNCTION(rocksdb) 203 | { 204 | php_info_print_table_start(); 205 | php_info_print_table_header(2, "rocksdb support", "enabled"); 206 | php_info_print_table_end(); 207 | 208 | DISPLAY_INI_ENTRIES(); 209 | } 210 | /* }}} */ 211 | 212 | zend_module_entry rocksdb_module_entry = { /* {{{ */ 213 | STANDARD_MODULE_HEADER_EX, 214 | NULL, 215 | NULL, 216 | "rocksdb", 217 | NULL, 218 | PHP_MINIT(rocksdb), 219 | PHP_MSHUTDOWN(rocksdb), 220 | NULL, 221 | NULL, 222 | PHP_MINFO(rocksdb), 223 | PHP_ROCKSDB_VERSION, 224 | PHP_MODULE_GLOBALS(rocksdb), 225 | PHP_GINIT(rocksdb), 226 | NULL, 227 | NULL, 228 | STANDARD_MODULE_PROPERTIES_EX 229 | }; 230 | /* }}} */ 231 | 232 | #ifdef COMPILE_DL_ROCKSDB 233 | #ifdef ZTS 234 | ZEND_TSRMLS_CACHE_DEFINE(); 235 | #endif 236 | ZEND_GET_MODULE(rocksdb) 237 | #endif 238 | 239 | /* 240 | * Local variables: 241 | * tab-width: 4 242 | * c-basic-offset: 4 243 | * End: 244 | * vim600: noet sw=4 ts=4 fdm=marker 245 | * vim<600: noet sw=4 ts=4 246 | */ 247 | -------------------------------------------------------------------------------- /php_rocksdb.h: -------------------------------------------------------------------------------- 1 | /* 2 | +----------------------------------------------------------------------+ 3 | | PHP Version 7 | 4 | +----------------------------------------------------------------------+ 5 | | Copyright (c) 1997-2015 The PHP Group | 6 | +----------------------------------------------------------------------+ 7 | | This source file is subject to version 3.01 of the PHP license, | 8 | | that is bundled with this package in the file LICENSE, and is | 9 | | available through the world-wide-web at the following url: | 10 | | http://www.php.net/license/3_01.txt | 11 | | If you did not receive a copy of the PHP license and are unable to | 12 | | obtain it through the world-wide-web, please send a note to | 13 | | license@php.net so we can mail you a copy immediately. | 14 | +----------------------------------------------------------------------+ 15 | | Author: | 16 | +----------------------------------------------------------------------+ 17 | */ 18 | 19 | /* $Id$ */ 20 | 21 | #ifndef PHP_ROCKSDB_H 22 | #define PHP_ROCKSDB_H 23 | 24 | extern zend_module_entry rocksdb_module_entry; 25 | 26 | #define phpext_rocksdb_ptr &rocksdb_module_entry 27 | 28 | #define PHP_ROCKSDB_VERSION "0.1.0" /* Replace with version number for your extension */ 29 | 30 | #ifdef PHP_WIN32 31 | # define PHP_ROCKSDB_API __declspec(dllexport) 32 | #elif defined(__GNUC__) && __GNUC__ >= 4 33 | # define PHP_ROCKSDB_API __attribute__ ((visibility("default"))) 34 | #else 35 | # define PHP_ROCKSDB_API 36 | #endif 37 | 38 | #ifdef ZTS 39 | #include "TSRM.h" 40 | #endif 41 | 42 | #ifndef STORAGE_ROCKSDB_INCLUDE_C_H_ 43 | #include "rocksdb/c.h" 44 | #endif 45 | 46 | #include "rocksdb_ce.h" 47 | #include "rocksdb_fe.h" 48 | 49 | #define ROCKSDB_TOLERATE_CORRUPTED_TAIL_RECORDS_RECOVERY 0 50 | #define ROCKSDB_ABSOLUTE_CONSISTENCY_RECOVERY 1 51 | #define ROCKSDB_POINT_IN_TIME_RECOVERY 2 52 | #define ROCKSDB_SKIP_ANY_CORRUPTED_RECORDS_RECOVERY 3 53 | 54 | #define ROCKSDB_NO_COMPRESSION 0 55 | #define ROCKSDB_SNAPPY_COMPRESSION 1 56 | #define ROCKSDB_ZLIB_COMPRESSION 2 57 | #define ROCKSDB_BZ2_COMPRESSION 3 58 | #define ROCKSDB_LZ4_COMPRESSION 4 59 | #define ROCKSDB_LZ4HC_COMPRESSION 5 60 | 61 | #define ROCKSDB_LEVEL_COMPATION 0 62 | #define ROCKSDB_UNIVERSAL_COMPACTION 1 63 | #define ROCKSDB_FIFO_COMPACTION 2 64 | 65 | /* Structure for RocksDb Database object. */ 66 | typedef struct _php_rocksdb_db_object { 67 | int initialised; 68 | char *name; 69 | 70 | int num_handles; 71 | char *handle_names[128]; 72 | 73 | rocksdb_t *db; 74 | rocksdb_column_family_handle_t *handles[128]; 75 | 76 | zend_bool exception; 77 | zend_object zo; 78 | } php_rocksdb_db_object; 79 | 80 | typedef struct _php_rocksdb_write_batch_object { 81 | rocksdb_writebatch_t *batch; 82 | zend_object zo; 83 | } php_rocksdb_write_batch_object; 84 | 85 | typedef struct _php_rocksdb_iterator_object { 86 | zval *db; 87 | rocksdb_iterator_t *iterator; 88 | zend_object zo; 89 | } php_rocksdb_iterator_object; 90 | 91 | typedef struct _php_rocksdb_snapshot_object { 92 | zval *db; 93 | rocksdb_snapshot_t *snapshot; 94 | zend_object zo; 95 | } php_rocksdb_snapshot_object; 96 | 97 | typedef struct _php_rocksdb_backup_engine_object { 98 | rocksdb_backup_engine_t *be; 99 | zend_object zo; 100 | } php_rocksdb_backup_engine_object; 101 | 102 | typedef struct _php_rocksdb_backup_engine_info_object { 103 | const rocksdb_backup_engine_info_t *info; 104 | zend_object zo; 105 | } php_rocksdb_backup_engine_info_object; 106 | 107 | typedef struct _php_rocksdb_merge_operator_object { 108 | rocksdb_mergeoperator_t *op; 109 | zend_function *fptr_full_merge; 110 | zend_function *fptr_partial_merge; 111 | zend_object zo; 112 | } php_rocksdb_merge_operator_object; 113 | 114 | #define PHP_ROCKSDB_REGISTER_CLASS_CONSTANT(class_entry, const_name, value) \ 115 | zend_declare_class_constant_long(class_entry, const_name, sizeof(const_name)-1, (zend_long)value); 116 | 117 | static inline php_rocksdb_db_object *php_rocksdb_from_obj(zend_object *obj) { 118 | return (php_rocksdb_db_object*)((char*)(obj) - XtOffsetOf(php_rocksdb_db_object, zo)); 119 | } 120 | 121 | static inline php_rocksdb_write_batch_object *php_rocksdb_write_batch_from_obj(zend_object *obj) { 122 | return (php_rocksdb_write_batch_object*)((char*)(obj) - XtOffsetOf(php_rocksdb_write_batch_object, zo)); 123 | } 124 | 125 | static inline php_rocksdb_iterator_object *php_rocksdb_iterator_from_obj(zend_object *obj) { 126 | return (php_rocksdb_iterator_object*)((char*)(obj) - XtOffsetOf(php_rocksdb_iterator_object, zo)); 127 | } 128 | 129 | static inline php_rocksdb_snapshot_object *php_rocksdb_snapshot_from_obj(zend_object *obj) { 130 | return (php_rocksdb_snapshot_object*)((char*)(obj) - XtOffsetOf(php_rocksdb_snapshot_object, zo)); 131 | } 132 | 133 | static inline php_rocksdb_backup_engine_object *php_rocksdb_backup_engine_from_obj(zend_object *obj) { 134 | return (php_rocksdb_backup_engine_object*)((char*)(obj) - XtOffsetOf(php_rocksdb_backup_engine_object, zo)); 135 | } 136 | 137 | static inline php_rocksdb_backup_engine_info_object *php_rocksdb_backup_engine_info_from_obj(zend_object *obj) { 138 | return (php_rocksdb_backup_engine_info_object*)((char*)(obj) - XtOffsetOf(php_rocksdb_backup_engine_info_object, zo)); 139 | } 140 | 141 | static inline php_rocksdb_merge_operator_object *php_rocksdb_merge_operator_info_from_obj(zend_object *obj) { 142 | return (php_rocksdb_merge_operator_object*)((char*)(obj) - XtOffsetOf(php_rocksdb_merge_operator_object, zo)); 143 | } 144 | 145 | #define Z_ROCKSDB_DB_P(zv) php_rocksdb_from_obj(Z_OBJ_P((zv))) 146 | #define Z_ROCKSDB_WRITE_BATCH_P(zv) php_rocksdb_write_batch_from_obj(Z_OBJ_P((zv))) 147 | #define Z_ROCKSDB_ITERATOR_P(zv) php_rocksdb_iterator_from_obj(Z_OBJ_P((zv))) 148 | #define Z_ROCKSDB_SNAPSHOT_P(zv) php_rocksdb_snapshot_from_obj(Z_OBJ_P((zv))) 149 | #define Z_ROCKSDB_BACKUP_ENGINE_P(zv) php_rocksdb_backup_engine_from_obj(Z_OBJ_P((zv))) 150 | #define Z_ROCKSDB_BACKUP_ENGINE_INFO_P(zv) php_rocksdb_backup_engine_info_from_obj(Z_OBJ_P((zv))) 151 | #define Z_ROCKSDB_MERGE_OPERATOR_P(zv) php_rocksdb_merge_operator_info_from_obj(Z_OBJ_P((zv))) 152 | 153 | #define ROCKSDB_CHECK_FOR_ERRORS(err) \ 154 | if ((err) != NULL) { \ 155 | zend_throw_exception(rocksdb_exception_ce, err, 0 TSRMLS_CC); \ 156 | free(err); \ 157 | return; \ 158 | } 159 | 160 | static inline rocksdb_flushoptions_t* php_rocksdb_get_flush_options(zval *options_zv) 161 | { 162 | HashTable *ht; 163 | zval *val; 164 | 165 | rocksdb_flushoptions_t *options = rocksdb_flushoptions_create(); 166 | 167 | if (options_zv == NULL) { 168 | return options; 169 | } 170 | 171 | ht = Z_ARRVAL_P(options_zv); 172 | 173 | if (NULL != (val = zend_hash_str_find(ht, "wait", sizeof("wait")-1))) { 174 | rocksdb_flushoptions_set_wait(options, zend_is_true(val)); 175 | } 176 | 177 | return options; 178 | } 179 | 180 | static inline rocksdb_restore_options_t* php_rocksdb_get_restore_options(zval *options_zv) 181 | { 182 | HashTable *ht; 183 | zval *val; 184 | 185 | rocksdb_restore_options_t *options = rocksdb_restore_options_create(); 186 | 187 | if (options_zv == NULL) { 188 | return options; 189 | } 190 | 191 | ht = Z_ARRVAL_P(options_zv); 192 | 193 | if (NULL != (val = zend_hash_str_find(ht, "keep_log_files", sizeof("keep_log_files")-1))) { 194 | rocksdb_restore_options_set_keep_log_files(options, 1); 195 | } 196 | 197 | return options; 198 | } 199 | 200 | static inline rocksdb_writeoptions_t* php_rocksdb_get_write_options(zval *options_zv) 201 | { 202 | HashTable *ht; 203 | zval *val; 204 | 205 | rocksdb_writeoptions_t *options = rocksdb_writeoptions_create(); 206 | 207 | if (options_zv == NULL) { 208 | return options; 209 | } 210 | 211 | ht = Z_ARRVAL_P(options_zv); 212 | 213 | if (NULL != (val = zend_hash_str_find(ht, "sync", sizeof("sync")-1))) { 214 | rocksdb_writeoptions_set_sync(options, (unsigned char) zend_is_true(val)); 215 | } 216 | 217 | if (NULL != (val = zend_hash_str_find(ht, "disable_wal", sizeof("disable_wal")-1))) { 218 | rocksdb_writeoptions_set_sync(options, i_zend_is_true(val)); 219 | } 220 | 221 | return options; 222 | } 223 | 224 | static inline rocksdb_readoptions_t* php_rocksdb_get_read_options(zval *options_zv) 225 | { 226 | HashTable *ht; 227 | zval *val; 228 | 229 | rocksdb_readoptions_t *options = rocksdb_readoptions_create(); 230 | 231 | if (options_zv == NULL) { 232 | return options; 233 | } 234 | 235 | ht = Z_ARRVAL_P(options_zv); 236 | 237 | if (NULL != (val = zend_hash_str_find(ht, "verify_checksums", sizeof("verify_checksums")-1))) { 238 | rocksdb_readoptions_set_verify_checksums(options, (unsigned char) zend_is_true(val)); 239 | } 240 | 241 | if (NULL != (val = zend_hash_str_find(ht, "fill_cache", sizeof("fill_cache")-1))) { 242 | rocksdb_readoptions_set_fill_cache(options, (unsigned char) zend_is_true(val)); 243 | } 244 | 245 | 246 | if (NULL != (val = zend_hash_str_find(ht, "tailing", sizeof("tailing")-1))) { 247 | rocksdb_readoptions_set_tailing(options, (unsigned char) zend_is_true(val)); 248 | } 249 | 250 | if (NULL != (val = zend_hash_str_find(ht, "pin_data", sizeof("pin_data")-1))) { 251 | rocksdb_readoptions_set_pin_data(options, (unsigned char) zend_is_true(val)); 252 | } 253 | 254 | if (NULL != (val = zend_hash_str_find(ht, "order_seek", sizeof("order_seek")-1))) { 255 | rocksdb_readoptions_set_total_order_seek(options, (unsigned char) zend_is_true(val)); 256 | } 257 | 258 | if (NULL != (val = zend_hash_str_find(ht, "snapshot", sizeof("snapshot")-1))) { 259 | php_rocksdb_snapshot_object *obj = Z_ROCKSDB_SNAPSHOT_P(val); 260 | rocksdb_readoptions_set_snapshot(options, obj->snapshot); 261 | } 262 | 263 | return options; 264 | } 265 | 266 | /* }}} */ 267 | 268 | /* 269 | static inline void mergeoperator_destructor(void* v) { 270 | zval *callable = (zval *) v; 271 | zval_ptr_dtor(callable); 272 | } 273 | 274 | static inline char* mergeoperator_full_merge( 275 | void* v, 276 | const char* key, 277 | size_t key_length, 278 | const char* existing_value, 279 | size_t existing_value_length, 280 | const char* const* operands_list, 281 | const size_t* operands_list_length, 282 | int num_operands, 283 | unsigned char* success, 284 | size_t* new_value_length) { 285 | 286 | char *value = NULL; 287 | value = "Justinas"; 288 | zval fname, result, params[2]; 289 | 290 | zval *val = (zval *) v; 291 | 292 | ZVAL_STRINGL(&fname, "fullMerge", sizeof("fullMerge") - 1); 293 | ZVAL_STRINGL(¶ms[0], key, key_length); 294 | ZVAL_STRINGL(¶ms[1], existing_value, existing_value_length); 295 | 296 | 297 | if (call_user_function(NULL, val, &fname , &result, 3, params TSRMLS_CC) == SUCCESS) { 298 | } 299 | 300 | *new_value_length = sizeof(value); 301 | *success = 1; 302 | 303 | return value; 304 | } 305 | 306 | static inline char* mergeoperator_partial_merge( 307 | void* v, 308 | const char* key, 309 | size_t key_length, 310 | const char* const* operands_list, 311 | const size_t* operands_list_length, 312 | int num_operands, 313 | unsigned char* success, 314 | size_t* new_value_length) { 315 | 316 | char *c = "A"; 317 | 318 | return c; 319 | } 320 | 321 | static inline void mergeoperator_delete_value( 322 | void* v, 323 | const char* value, 324 | size_t value_length) { 325 | 326 | } 327 | 328 | static inline const char* mergeoperator_name() { 329 | const char* c = "MergeOperator2"; 330 | 331 | return c; 332 | } 333 | */ 334 | 335 | static inline rocksdb_options_t* php_rocksdb_get_open_options(zval *options_zv) 336 | { 337 | HashTable *ht; 338 | zval *val; 339 | 340 | rocksdb_options_t *options = rocksdb_options_create(); 341 | 342 | if (options_zv == NULL) { 343 | return options; 344 | } 345 | 346 | ht = Z_ARRVAL_P(options_zv); 347 | 348 | if (NULL != (val = zend_hash_str_find(ht, 349 | "create_if_missing", sizeof("create_if_missing")-1))) { 350 | rocksdb_options_set_create_if_missing(options, zend_is_true(val)); 351 | } 352 | if (NULL != (val = zend_hash_str_find(ht, 353 | "error_if_exists", sizeof("error_if_exists")-1))) { 354 | rocksdb_options_set_error_if_exists(options, zend_is_true(val)); 355 | } 356 | if (NULL != (val = zend_hash_str_find(ht, 357 | "paranoid_checks", sizeof("paranoid_checks")-1))) { 358 | rocksdb_options_set_error_if_exists(options, zend_is_true(val)); 359 | } 360 | if (NULL != (val = zend_hash_str_find(ht, 361 | "write_buffer_size", sizeof("write_buffer_size")-1))) { 362 | convert_to_long(val); 363 | rocksdb_options_set_write_buffer_size(options, Z_LVAL_P(val)); 364 | } 365 | if (NULL != (val = zend_hash_str_find(ht, 366 | "max_open_files", sizeof("max_open_files")-1))) { 367 | convert_to_long(val); 368 | rocksdb_options_set_max_open_files(options, Z_LVAL_P(val)); 369 | } 370 | if (NULL != (val = zend_hash_str_find(ht, 371 | "compression", sizeof("compression")-1))) { 372 | convert_to_long(val); 373 | if (Z_LVAL_P(val) != rocksdb_no_compression && Z_LVAL_P(val) != rocksdb_snappy_compression) { 374 | php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid compression type"); 375 | } else { 376 | rocksdb_options_set_compression(options, Z_LVAL_P(val)); 377 | } 378 | } 379 | /* 380 | if (NULL != (val = zend_hash_str_find(ht, 381 | "set_merge_operator", sizeof("set_merge_operator")-1))) { 382 | 383 | php_rocksdb_merge_operator_object *merge_operator; 384 | 385 | merge_operator = Z_ROCKSDB_MERGE_OPERATOR_P(val TSRMLS_CC); 386 | 387 | merge_operator->fptr_full_merge = zend_hash_str_find_ptr(&merge_operator->zo.ce->function_table, "fullMerge", sizeof("fullMerge") - 1); 388 | merge_operator->fptr_partial_merge = zend_hash_str_find_ptr(&merge_operator->zo.ce->function_table, "partialMerge", sizeof("partialMerge") - 1); 389 | 390 | merge_operator->op = rocksdb_mergeoperator_create(val, mergeoperator_destructor, mergeoperator_full_merge, mergeoperator_partial_merge, mergeoperator_delete_value, mergeoperator_name); 391 | 392 | rocksdb_options_set_merge_operator(options, merge_operator->op); 393 | } 394 | */ 395 | return options; 396 | } 397 | 398 | ZEND_BEGIN_MODULE_GLOBALS(rocksdb) 399 | zend_bool create_if_missing; 400 | zend_long max_open_files; 401 | zend_long write_buffer_size; 402 | zend_long max_write_buffer_number; 403 | zend_long target_file_size_base; 404 | ZEND_END_MODULE_GLOBALS(rocksdb) 405 | 406 | #define ROCKSDB_G(v) ZEND_MODULE_GLOBALS_ACCESSOR(rocksdb, v) 407 | 408 | #if defined(ZTS) && defined(COMPILE_DL_ROCKSDB) 409 | ZEND_TSRMLS_CACHE_EXTERN(); 410 | #endif 411 | 412 | #endif /* PHP_ROCKSDB_H */ 413 | 414 | 415 | /* 416 | * Local variables: 417 | * tab-width: 4 418 | * c-basic-offset: 4 419 | * End: 420 | * vim600: noet sw=4 ts=4 fdm=marker 421 | * vim<600: noet sw=4 ts=4 422 | */ 423 | -------------------------------------------------------------------------------- /rocksdb.c: -------------------------------------------------------------------------------- 1 | /* 2 | * rocksdb.c 3 | * 4 | */ 5 | #ifdef HAVE_CONFIG_H 6 | #include "config.h" 7 | #endif 8 | 9 | #include "php.h" 10 | #include "zend_exceptions.h" 11 | #include "Zend/zend_hash.h" 12 | #include "Zend/zend_types.h" 13 | #include "Zend/zend_interfaces.h" 14 | 15 | #include "php_rocksdb.h" 16 | 17 | zend_class_entry *rocksdb_ce; 18 | 19 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class__construct_arginfo, 0, 0, 1) 20 | ZEND_ARG_INFO(0, name) 21 | ZEND_ARG_INFO(0, options) 22 | ZEND_ARG_INFO(0, read_options) 23 | ZEND_ARG_INFO(0, write_options) 24 | ZEND_ARG_INFO(0, cf_names) 25 | ZEND_ARG_INFO(0, cf_options) 26 | ZEND_END_ARG_INFO() 27 | 28 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_list_column_families_arginfo, 0, 0, 3) 29 | ZEND_ARG_INFO(0, name) 30 | ZEND_ARG_INFO(0, options) 31 | ZEND_ARG_INFO(0, lencf) 32 | ZEND_END_ARG_INFO() 33 | 34 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_create_column_family_arginfo, 0, 0, 2) 35 | ZEND_ARG_INFO(0, column_family_name) 36 | ZEND_ARG_INFO(0, column_family_options) 37 | ZEND_END_ARG_INFO() 38 | 39 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_drop_column_family_arginfo, 0, 0, 1) 40 | ZEND_ARG_INFO(0, handle) 41 | ZEND_END_ARG_INFO() 42 | 43 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_put_arginfo, 0, 0, 3) 44 | ZEND_ARG_INFO(0, key) 45 | ZEND_ARG_INFO(0, value) 46 | ZEND_ARG_INFO(0, options) 47 | ZEND_END_ARG_INFO() 48 | 49 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_put_cf_arginfo, 0, 0, 3) 50 | ZEND_ARG_INFO(0, key) 51 | ZEND_ARG_INFO(0, value) 52 | ZEND_ARG_INFO(0, column_family) 53 | ZEND_END_ARG_INFO() 54 | 55 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_delete_arginfo, 0, 0, 1) 56 | ZEND_ARG_INFO(0, key) 57 | ZEND_END_ARG_INFO() 58 | 59 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_delete_cf_arginfo, 0, 0, 2) 60 | ZEND_ARG_INFO(0, key) 61 | ZEND_ARG_INFO(0, column_family) 62 | ZEND_END_ARG_INFO() 63 | 64 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_merge_arginfo, 0, 0, 2) 65 | ZEND_ARG_INFO(0, key) 66 | ZEND_ARG_INFO(0, value) 67 | ZEND_END_ARG_INFO() 68 | 69 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_write_arginfo, 0, 0, 1) 70 | ZEND_ARG_INFO(0, batch) 71 | ZEND_END_ARG_INFO() 72 | 73 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_get_arginfo, 0, 0, 2) 74 | ZEND_ARG_INFO(0, key) 75 | ZEND_END_ARG_INFO() 76 | 77 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_get_cf_arginfo, 0, 0, 3) 78 | ZEND_ARG_INFO(0, key) 79 | ZEND_ARG_INFO(0, column_family) 80 | ZEND_END_ARG_INFO() 81 | 82 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_get_property_arginfo, 0, 0, 1) 83 | ZEND_ARG_INFO(0, name) 84 | ZEND_END_ARG_INFO() 85 | 86 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_get_property_cf_arginfo, 0, 0, 2) 87 | ZEND_ARG_INFO(0, name) 88 | ZEND_ARG_INFO(0, column_family) 89 | ZEND_END_ARG_INFO() 90 | 91 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_flush_arginfo, 0, 0, 1) 92 | ZEND_ARG_INFO(0, options) 93 | ZEND_END_ARG_INFO() 94 | 95 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_delete_file_arginfo, 0, 0, 1) 96 | ZEND_ARG_INFO(0, name) 97 | ZEND_END_ARG_INFO() 98 | 99 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_enable_file_deletions_arginfo, 0, 0, 1) 100 | ZEND_ARG_INFO(0, force) 101 | ZEND_END_ARG_INFO() 102 | 103 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class_repair_arginfo, 0, 0, 1) 104 | ZEND_ARG_INFO(0, name) 105 | ZEND_END_ARG_INFO() 106 | 107 | const zend_function_entry rocksdb_class_methods[] = { 108 | PHP_ME(rocksdb, __construct, rocksdb_class__construct_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) 109 | PHP_ME(rocksdb, listColumnFamilies, rocksdb_class_list_column_families_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC) 110 | PHP_ME(rocksdb, createColumnFamily, rocksdb_class_create_column_family_arginfo, ZEND_ACC_PUBLIC) 111 | PHP_ME(rocksdb, dropColumnFamily, rocksdb_class_drop_column_family_arginfo, ZEND_ACC_PUBLIC) 112 | PHP_ME(rocksdb, put, rocksdb_class_put_arginfo, ZEND_ACC_PUBLIC) 113 | PHP_ME(rocksdb, putCf, rocksdb_class_put_cf_arginfo, ZEND_ACC_PUBLIC) 114 | PHP_ME(rocksdb, delete, rocksdb_class_delete_arginfo, ZEND_ACC_PUBLIC) 115 | PHP_ME(rocksdb, deleteCf, rocksdb_class_delete_cf_arginfo, ZEND_ACC_PUBLIC) 116 | PHP_ME(rocksdb, merge, rocksdb_class_merge_arginfo, ZEND_ACC_PUBLIC) 117 | PHP_ME(rocksdb, write, rocksdb_class_write_arginfo, ZEND_ACC_PUBLIC) 118 | PHP_ME(rocksdb, get, rocksdb_class_get_arginfo, ZEND_ACC_PUBLIC) 119 | PHP_ME(rocksdb, getCf, rocksdb_class_get_cf_arginfo, ZEND_ACC_PUBLIC) 120 | PHP_ME(rocksdb, getIterator, NULL, ZEND_ACC_PUBLIC) // rocksdb_create_iterator 121 | PHP_ME(rocksdb, createSnapshot, NULL, ZEND_ACC_PUBLIC) 122 | PHP_ME(rocksdb, getProperty, rocksdb_class_get_property_arginfo, ZEND_ACC_PUBLIC) 123 | PHP_ME(rocksdb, getPropertyCf, rocksdb_class_get_property_cf_arginfo, ZEND_ACC_PUBLIC) 124 | PHP_ME(rocksdb, flush, rocksdb_class_flush_arginfo, ZEND_ACC_PUBLIC) 125 | PHP_ME(rocksdb, deleteFile, rocksdb_class_delete_file_arginfo, ZEND_ACC_PUBLIC) 126 | PHP_ME(rocksdb, disableFileDeletions, NULL, ZEND_ACC_PUBLIC) 127 | PHP_ME(rocksdb, enableFileDeletions, rocksdb_class_enable_file_deletions_arginfo, ZEND_ACC_PUBLIC) 128 | PHP_ME(rocksdb, destroy, NULL, ZEND_ACC_PUBLIC) 129 | PHP_ME(rocksdb, repair, rocksdb_class_repair_arginfo, ZEND_ACC_PUBLIC) 130 | PHP_ME(rocksdb, close, NULL, ZEND_ACC_PUBLIC) 131 | PHP_FE_END 132 | }; 133 | 134 | PHP_METHOD(rocksdb, __construct) { 135 | char *name, *err = NULL; 136 | size_t name_len; 137 | 138 | zval *options_zv = NULL, 139 | *readoptions_zv = NULL, 140 | *writeoptions_zv = NULL, 141 | *cfnames_zv = NULL, 142 | *cfoptions_zv = NULL, 143 | *ro = NULL, 144 | *entry; 145 | 146 | zval *object = getThis(); 147 | php_rocksdb_db_object *db_obj; 148 | HashTable *htoptions, *htcfnames; 149 | zend_ulong index; 150 | 151 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|aaaaa", 152 | &name, &name_len, &options_zv, &readoptions_zv, &writeoptions_zv, &cfnames_zv, &cfoptions_zv) == FAILURE) { 153 | return; 154 | } 155 | 156 | db_obj = Z_ROCKSDB_DB_P(object); 157 | 158 | if (db_obj->initialised == 1) { 159 | zend_throw_exception(rocksdb_exception_ce, "Already initialised DB Object", 0); 160 | } 161 | 162 | rocksdb_options_t *options = php_rocksdb_get_open_options(options_zv); 163 | 164 | htoptions = Z_ARRVAL_P(options_zv); 165 | ro = zend_hash_str_find(htoptions, "read_only", sizeof("read_only")-1); 166 | 167 | if (cfnames_zv != NULL) { 168 | htcfnames = Z_ARRVAL_P(cfnames_zv); 169 | if (htcfnames->nNumOfElements > 0) { 170 | const char *cfnames[htcfnames->nNumOfElements]; 171 | const rocksdb_options_t *cfopts[htcfnames->nNumOfElements]; 172 | 173 | ZEND_HASH_FOREACH_NUM_KEY_VAL(htcfnames, index, entry) { 174 | if (Z_TYPE_P(entry) != IS_STRING) { 175 | zend_error(E_ERROR, "Expected string for frame " ZEND_ULONG_FMT, index); 176 | break; 177 | } 178 | cfnames[index] = (char *) Z_STRVAL(*entry); 179 | cfopts[index] = (rocksdb_options_t *) options; 180 | 181 | db_obj->handle_names[index] = (char *) cfnames[index]; 182 | } ZEND_HASH_FOREACH_END(); 183 | 184 | if (NULL != ro && zend_is_true(ro)) { 185 | db_obj->db = rocksdb_open_for_read_only_column_families( 186 | options, (const char*) name, htcfnames->nNumOfElements, (const char **) cfnames, (const rocksdb_options_t **) cfopts, db_obj->handles, 0, &err); 187 | } else { 188 | db_obj->db = rocksdb_open_column_families( 189 | options, (const char*) name, htcfnames->nNumOfElements, (const char **) cfnames, (const rocksdb_options_t **) cfopts, db_obj->handles, &err); 190 | } 191 | db_obj->num_handles = htcfnames->nNumOfElements; 192 | } else { 193 | if (NULL != ro && zend_is_true(ro)) { 194 | db_obj->db = rocksdb_open_for_read_only(options, (const char*) name, 0, &err); 195 | } else { 196 | db_obj->db = rocksdb_open(options, (const char*) name, &err); 197 | } 198 | db_obj->num_handles = 0; 199 | } 200 | } else { 201 | if (NULL != ro && zend_is_true(ro)) { 202 | db_obj->db = rocksdb_open_for_read_only(options, (const char*) name, 0, &err); 203 | } else { 204 | db_obj->db = rocksdb_open(options, (const char*) name, &err); 205 | } 206 | } 207 | 208 | rocksdb_options_destroy(options); 209 | 210 | ROCKSDB_CHECK_FOR_ERRORS(err); 211 | 212 | db_obj->name = name; 213 | db_obj->initialised = 1; 214 | } 215 | PHP_METHOD(rocksdb, listColumnFamilies) { 216 | char *err, *cf = NULL; 217 | const char *name; 218 | char **column_families; 219 | size_t lencf, name_len; 220 | zval val; 221 | zval *options_zv = NULL; 222 | 223 | rocksdb_options_t *options; 224 | 225 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", 226 | &name, &name_len, &options_zv) == FAILURE) { 227 | return; 228 | } 229 | 230 | options = php_rocksdb_get_open_options(options_zv); 231 | column_families = rocksdb_list_column_families(options, name, &lencf, &err); 232 | rocksdb_options_destroy(options); 233 | 234 | ROCKSDB_CHECK_FOR_ERRORS(err); 235 | 236 | HashTable *ht; 237 | ALLOC_HASHTABLE(ht); 238 | zend_hash_init(ht, 0, NULL, ZVAL_PTR_DTOR, 0); 239 | 240 | cf = *column_families; 241 | for (int i = 0; i < lencf; i = i + 1) { 242 | ZVAL_STRING(&val, cf); 243 | 244 | zend_hash_next_index_insert_new(ht, &val); 245 | cf = *++column_families; 246 | } 247 | 248 | rocksdb_list_column_families_destroy(column_families, lencf); 249 | 250 | RETVAL_ARR(ht); 251 | } 252 | PHP_METHOD(rocksdb, createColumnFamily) { 253 | char *err = NULL; 254 | const char *name; 255 | size_t name_len; 256 | zval *object = getThis(); 257 | zval *options_zv = NULL; 258 | rocksdb_options_t *options; 259 | php_rocksdb_db_object *db_obj; 260 | db_obj = Z_ROCKSDB_DB_P(object); 261 | 262 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", 263 | &name, &name_len, &options_zv) == FAILURE) { 264 | return; 265 | } 266 | 267 | options = php_rocksdb_get_open_options(options_zv); 268 | db_obj->handles[db_obj->num_handles] = rocksdb_create_column_family(db_obj->db, (const rocksdb_options_t *) options, name, &err); 269 | db_obj->handle_names[db_obj->num_handles] = (char *) name; 270 | db_obj->num_handles++; 271 | 272 | rocksdb_options_destroy(options); 273 | 274 | ROCKSDB_CHECK_FOR_ERRORS(err); 275 | 276 | RETURN_TRUE; 277 | } 278 | PHP_METHOD(rocksdb, dropColumnFamily) { 279 | char *err = NULL; 280 | char *name = NULL; 281 | size_t name_len; 282 | php_rocksdb_db_object *this = Z_ROCKSDB_DB_P(getThis() TSRMLS_CC); 283 | 284 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", 285 | &name, &name_len) == FAILURE) { 286 | return; 287 | } 288 | 289 | int i = 0; 290 | while((i < this->num_handles) && (this->handle_names[i] != name)) i++; 291 | int h = (i < this->num_handles) ? (i) : (-1); 292 | 293 | if (h == -1) { 294 | RETURN_FALSE; 295 | } 296 | 297 | rocksdb_drop_column_family(this->db, this->handles[h], &err); 298 | 299 | ROCKSDB_CHECK_FOR_ERRORS(err); 300 | 301 | RETURN_TRUE; 302 | } 303 | PHP_METHOD(rocksdb, put) { 304 | char *key, *value; 305 | size_t key_len, value_len; 306 | zval *object = getThis(); 307 | zval *options_zv = NULL; 308 | php_rocksdb_db_object *db_obj; 309 | db_obj = Z_ROCKSDB_DB_P(object); 310 | char *err = NULL; 311 | 312 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a", 313 | &key, &key_len, &value, &value_len, &options_zv) == FAILURE) { 314 | return; 315 | } 316 | 317 | rocksdb_writeoptions_t *options = php_rocksdb_get_write_options(options_zv); 318 | rocksdb_put(db_obj->db, options, key, key_len, value, value_len, &err); 319 | rocksdb_writeoptions_destroy(options); 320 | 321 | ROCKSDB_CHECK_FOR_ERRORS(err); 322 | 323 | RETURN_TRUE; 324 | } 325 | PHP_METHOD(rocksdb, putCf) { 326 | char *key, *value, *cf; 327 | size_t key_len, value_len, cf_len; 328 | zval *object = getThis(); 329 | php_rocksdb_db_object *db_obj; 330 | db_obj = Z_ROCKSDB_DB_P(object); 331 | char *err = NULL; 332 | 333 | rocksdb_writeoptions_t *writeoptions; 334 | writeoptions = rocksdb_writeoptions_create(); 335 | 336 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", 337 | &key, &key_len, &value, &value_len, &cf, &cf_len) == FAILURE) { 338 | return; 339 | } 340 | 341 | int i=0; 342 | while((inum_handles) && (db_obj->handle_names[i] != cf)) i++; 343 | int h = (inum_handles) ? (i) : (-1); 344 | 345 | if (h == -1) { 346 | RETURN_FALSE; 347 | } 348 | 349 | rocksdb_put_cf(db_obj->db, writeoptions, db_obj->handles[h], key, key_len, value, value_len, &err); 350 | rocksdb_writeoptions_destroy(writeoptions); 351 | 352 | ROCKSDB_CHECK_FOR_ERRORS(err); 353 | 354 | RETURN_TRUE; 355 | } 356 | PHP_METHOD(rocksdb, delete) { 357 | char *key; 358 | size_t key_len; 359 | zval *object = getThis(); 360 | zval *options_zv = NULL; 361 | php_rocksdb_db_object *db_obj; 362 | db_obj = Z_ROCKSDB_DB_P(object); 363 | char *err = NULL; 364 | 365 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", 366 | &key, &key_len, &options_zv) == FAILURE) { 367 | return; 368 | } 369 | 370 | rocksdb_writeoptions_t *options = php_rocksdb_get_write_options(options_zv); 371 | rocksdb_delete(db_obj->db, options, key, key_len, &err); 372 | rocksdb_writeoptions_destroy(options); 373 | 374 | ROCKSDB_CHECK_FOR_ERRORS(err); 375 | 376 | RETURN_TRUE; 377 | } 378 | PHP_METHOD(rocksdb, deleteCf) { 379 | char *key, *cf; 380 | size_t key_len, cf_len; 381 | zval *object = getThis(); 382 | zval *options_zv = NULL; 383 | php_rocksdb_db_object *db_obj; 384 | db_obj = Z_ROCKSDB_DB_P(object); 385 | char *err = NULL; 386 | 387 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a", 388 | &key, &key_len, &cf, &cf_len, &options_zv) == FAILURE) { 389 | return; 390 | } 391 | 392 | int i = 0; 393 | while((i < db_obj->num_handles) && (db_obj->handle_names[i] != cf)) i++; 394 | int h = (i < db_obj->num_handles) ? (i) : (-1); 395 | 396 | if (h == -1) { 397 | RETURN_FALSE; 398 | } 399 | 400 | rocksdb_writeoptions_t *options = php_rocksdb_get_write_options(options_zv); 401 | rocksdb_delete_cf(db_obj->db, options, db_obj->handles[h], key, key_len, &err); 402 | rocksdb_writeoptions_destroy(options); 403 | 404 | ROCKSDB_CHECK_FOR_ERRORS(err); 405 | 406 | RETURN_TRUE; 407 | } 408 | PHP_METHOD(rocksdb, merge) { 409 | char *key, *value; 410 | size_t key_len, value_len; 411 | char *err = NULL; 412 | zval *options_zv = NULL; 413 | php_rocksdb_db_object *db_obj; 414 | db_obj = Z_ROCKSDB_DB_P(getThis()); 415 | 416 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a", 417 | &key, &key_len, &value, &value_len, &options_zv) == FAILURE) { 418 | return; 419 | } 420 | 421 | rocksdb_writeoptions_t *options = php_rocksdb_get_write_options(options_zv); 422 | rocksdb_merge(db_obj->db, options, (const char *) key, key_len, (const char *) value, value_len, &err); 423 | rocksdb_writeoptions_destroy(options); 424 | 425 | ROCKSDB_CHECK_FOR_ERRORS(err); 426 | 427 | RETURN_TRUE; 428 | } 429 | PHP_METHOD(rocksdb, write) { 430 | zval *write_batch; 431 | char *err = NULL; 432 | zval *object = getThis(); 433 | zval *options_zv = NULL; 434 | php_rocksdb_db_object *db_obj; 435 | db_obj = Z_ROCKSDB_DB_P(object); 436 | php_rocksdb_write_batch_object *write_batch_object; 437 | 438 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|a", 439 | &write_batch, rocksdb_write_batch_ce, &options_zv) == FAILURE) { 440 | return; 441 | } 442 | 443 | write_batch_object = Z_ROCKSDB_WRITE_BATCH_P(write_batch TSRMLS_CC); 444 | 445 | rocksdb_writeoptions_t *options = php_rocksdb_get_write_options(options_zv); 446 | rocksdb_write(db_obj->db, options, write_batch_object->batch, &err); 447 | rocksdb_writeoptions_destroy(options); 448 | 449 | ROCKSDB_CHECK_FOR_ERRORS(err); 450 | 451 | RETURN_TRUE; 452 | } 453 | PHP_METHOD(rocksdb, get) { 454 | char *key, *value; 455 | size_t key_len, value_len; 456 | zval *object = getThis(); 457 | zval *options_zv = NULL; 458 | php_rocksdb_db_object *db_obj; 459 | db_obj = Z_ROCKSDB_DB_P(object); 460 | char *err = NULL; 461 | 462 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", 463 | &key, &key_len, &options_zv) == FAILURE) { 464 | return; 465 | } 466 | 467 | rocksdb_readoptions_t *options = php_rocksdb_get_read_options(options_zv); 468 | value = rocksdb_get(db_obj->db, options, key, key_len, &value_len, &err); 469 | rocksdb_readoptions_destroy(options); 470 | 471 | ROCKSDB_CHECK_FOR_ERRORS(err); 472 | 473 | if (value == NULL) { 474 | RETURN_FALSE; 475 | } 476 | 477 | RETVAL_STRINGL(value, value_len); 478 | free(value); 479 | } 480 | PHP_METHOD(rocksdb, getCf) { 481 | char *key, *value, *cf; 482 | size_t key_len, value_len, cf_len; 483 | zval *options_zv = NULL; 484 | php_rocksdb_db_object *this = Z_ROCKSDB_DB_P(getThis()); 485 | char *err = NULL; 486 | 487 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a", 488 | &key, &key_len, &cf, &cf_len, &options_zv) == FAILURE) { 489 | return; 490 | } 491 | 492 | int i = 0; 493 | while((i < this->num_handles) && (this->handle_names[i] != cf)) i++; 494 | int h = (i < this->num_handles) ? (i) : (-1); 495 | 496 | if (h == -1) { 497 | RETURN_FALSE; 498 | } 499 | 500 | rocksdb_readoptions_t *options = php_rocksdb_get_read_options(options_zv); 501 | value = rocksdb_get_cf(this->db, options, this->handles[h], key, key_len, &value_len, &err); 502 | rocksdb_readoptions_destroy(options); 503 | 504 | ROCKSDB_CHECK_FOR_ERRORS(err); 505 | 506 | if (value == NULL) { 507 | RETURN_FALSE; 508 | } 509 | 510 | RETVAL_STRINGL(value, value_len); 511 | free(value); 512 | } 513 | PHP_METHOD(rocksdb, getIterator) { 514 | zval *readoptions_zv = NULL; 515 | 516 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", &readoptions_zv) == FAILURE) { 517 | return; 518 | } 519 | 520 | object_init_ex(return_value, rocksdb_iterator_ce); 521 | 522 | if (!readoptions_zv) { 523 | zend_call_method_with_1_params(return_value, rocksdb_iterator_ce, 524 | &rocksdb_iterator_ce->constructor, "__construct", NULL, getThis()); 525 | } else { 526 | zend_call_method_with_2_params(return_value, rocksdb_iterator_ce, 527 | &rocksdb_iterator_ce->constructor, "__construct", NULL, getThis(), readoptions_zv TSRMLS_CC); 528 | } 529 | } 530 | PHP_METHOD(rocksdb, createSnapshot) { 531 | if (zend_parse_parameters_none() == FAILURE) { 532 | return; 533 | } 534 | 535 | object_init_ex(return_value, rocksdb_snapshot_ce); 536 | 537 | zend_call_method_with_1_params(return_value, rocksdb_snapshot_ce, 538 | &rocksdb_snapshot_ce->constructor, "__construct", NULL, getThis()); 539 | } 540 | PHP_METHOD(rocksdb, getProperty) { 541 | char *prop; 542 | size_t prop_len; 543 | 544 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", 545 | &prop, &prop_len) == FAILURE) { 546 | return; 547 | } 548 | 549 | php_rocksdb_db_object *db_obj = Z_ROCKSDB_DB_P(getThis() TSRMLS_CC); 550 | 551 | char *value = rocksdb_property_value(db_obj->db, (const char *) prop); 552 | 553 | if (NULL == value) { 554 | RETURN_FALSE; 555 | } 556 | 557 | RETURN_STRING(value); 558 | } 559 | PHP_METHOD(rocksdb, getPropertyCf) { 560 | char *prop, *cf; 561 | size_t prop_len, cf_len; 562 | 563 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", 564 | &prop, &prop_len, &cf, &cf_len) == FAILURE) { 565 | return; 566 | } 567 | 568 | php_rocksdb_db_object *this = Z_ROCKSDB_DB_P(getThis() TSRMLS_CC); 569 | 570 | int i = 0; 571 | while((i < this->num_handles) && (this->handle_names[i] != cf)) i++; 572 | int h = (i < this->num_handles) ? (i) : (-1); 573 | 574 | if (h == -1) { 575 | RETURN_FALSE; 576 | } 577 | 578 | char *value = rocksdb_property_value_cf(this->db, this->handles[h], (const char *) prop); 579 | 580 | RETURN_STRING(value); 581 | } 582 | PHP_METHOD(rocksdb, flush) { 583 | zval *flushoptions_zv = NULL; 584 | rocksdb_flushoptions_t *flushoptions; 585 | php_rocksdb_db_object *this; 586 | 587 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|a", &flushoptions_zv) == FAILURE) { 588 | return; 589 | } 590 | 591 | char *err = NULL; 592 | this = Z_ROCKSDB_DB_P(getThis() TSRMLS_CC); 593 | 594 | flushoptions = php_rocksdb_get_flush_options(flushoptions_zv); 595 | rocksdb_flush(this->db, flushoptions, &err); 596 | rocksdb_flushoptions_destroy(flushoptions); 597 | 598 | ROCKSDB_CHECK_FOR_ERRORS(err); 599 | } 600 | PHP_METHOD(rocksdb, deleteFile) { 601 | char *name; 602 | size_t name_len; 603 | 604 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", 605 | &name, &name_len) == FAILURE) { 606 | return; 607 | } 608 | 609 | php_rocksdb_db_object *this = Z_ROCKSDB_DB_P(getThis() TSRMLS_CC); 610 | 611 | rocksdb_delete_file(this->db, (const char *) name); 612 | 613 | RETURN_TRUE; 614 | } 615 | PHP_METHOD(rocksdb, disableFileDeletions) { 616 | if (zend_parse_parameters_none() == FAILURE) { 617 | return; 618 | } 619 | 620 | char *err = NULL; 621 | php_rocksdb_db_object *this = Z_ROCKSDB_DB_P(getThis() TSRMLS_CC); 622 | 623 | rocksdb_disable_file_deletions(this->db, &err); 624 | 625 | ROCKSDB_CHECK_FOR_ERRORS(err); 626 | } 627 | PHP_METHOD(rocksdb, enableFileDeletions) { 628 | char *err = NULL; 629 | zend_bool *force_zv; 630 | php_rocksdb_db_object *this = Z_ROCKSDB_DB_P(getThis() TSRMLS_CC); 631 | 632 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "b", &force_zv) == FAILURE) { 633 | return; 634 | } 635 | 636 | rocksdb_enable_file_deletions(this->db, *force_zv, &err); 637 | 638 | ROCKSDB_CHECK_FOR_ERRORS(err); 639 | } 640 | PHP_METHOD(rocksdb, destroy) { 641 | char *err = NULL; 642 | zval *options_zv = NULL; 643 | php_rocksdb_db_object *this = NULL; 644 | this = Z_ROCKSDB_DB_P(getThis() TSRMLS_CC); 645 | 646 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &options_zv) == FAILURE) { 647 | return; 648 | } 649 | 650 | rocksdb_options_t *options = php_rocksdb_get_open_options(options_zv); 651 | rocksdb_destroy_db(options, this->name, &err); 652 | rocksdb_options_destroy(options); 653 | 654 | ROCKSDB_CHECK_FOR_ERRORS(err); 655 | 656 | RETURN_TRUE; 657 | } 658 | PHP_METHOD(rocksdb, repair) { 659 | char *name; 660 | size_t name_len; 661 | zval *options_zv = NULL; 662 | rocksdb_options_t *options; 663 | 664 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", 665 | &name, &name_len, &options_zv) == FAILURE) { 666 | return; 667 | } 668 | 669 | char *err = NULL; 670 | 671 | options = php_rocksdb_get_open_options(options_zv); 672 | rocksdb_repair_db(options, (const char *) name, &err); 673 | 674 | ROCKSDB_CHECK_FOR_ERRORS(err); 675 | } 676 | PHP_METHOD(rocksdb, close) { 677 | php_rocksdb_db_object *this; 678 | 679 | if (zend_parse_parameters_none() == FAILURE) { 680 | return; 681 | } 682 | 683 | this = Z_ROCKSDB_DB_P(getThis() TSRMLS_CC); 684 | 685 | if (this->db) { 686 | rocksdb_close(this->db); 687 | this->db = NULL; 688 | } 689 | 690 | RETURN_TRUE; 691 | } 692 | -------------------------------------------------------------------------------- /rocksdb.php: -------------------------------------------------------------------------------- 1 | "; 3 | 4 | if(!extension_loaded('rocksdb')) { 5 | dl('rocksdb.' . PHP_SHLIB_SUFFIX); 6 | } 7 | $module = 'rocksdb'; 8 | $functions = get_extension_funcs($module); 9 | echo "Functions available in the test extension:$br\n"; 10 | foreach($functions as $func) { 11 | echo $func."$br\n"; 12 | } 13 | echo "$br\n"; 14 | $function = 'confirm_' . $module . '_compiled'; 15 | if (extension_loaded($module)) { 16 | $str = $function($module); 17 | } else { 18 | $str = "Module $module is not compiled into PHP"; 19 | } 20 | echo "$str\n"; 21 | ?> 22 | -------------------------------------------------------------------------------- /rocksdb_backup_engine.c: -------------------------------------------------------------------------------- 1 | /* 2 | * rocksdb_backup.c 3 | * 4 | */ 5 | #ifdef HAVE_CONFIG_H 6 | #include "config.h" 7 | #endif 8 | 9 | #include "php.h" 10 | #include "zend_exceptions.h" 11 | #include "Zend/zend_interfaces.h" 12 | #include "php_rocksdb.h" 13 | 14 | zend_class_entry *rocksdb_backup_engine_ce; 15 | 16 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_backup_engine_construct_arginfo, 0, 0, 2) 17 | ZEND_ARG_INFO(0, path) 18 | ZEND_ARG_INFO(0, options) 19 | ZEND_END_ARG_INFO() 20 | 21 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_backup_engine_create_new_backup_arginfo, 0, 0, 1) 22 | ZEND_ARG_INFO(0, db) 23 | ZEND_END_ARG_INFO() 24 | 25 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_backup_engine_restore_db_from_latest_backup_arginfo, 0, 0, 3) 26 | ZEND_ARG_INFO(0, dir) 27 | ZEND_ARG_INFO(0, wal) 28 | ZEND_ARG_INFO(0, options) 29 | ZEND_END_ARG_INFO() 30 | 31 | const zend_function_entry rocksdb_backup_engine_class_methods[] = { 32 | PHP_ME(rocksdb_backup_engine, __construct, rocksdb_backup_engine_construct_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) 33 | PHP_ME(rocksdb_backup_engine, purgeOldBackups, NULL, ZEND_ACC_PUBLIC) 34 | PHP_ME(rocksdb_backup_engine, createNewBackup, rocksdb_backup_engine_create_new_backup_arginfo, ZEND_ACC_PUBLIC) 35 | PHP_ME(rocksdb_backup_engine, restoreDbFromLatestBackup, rocksdb_backup_engine_restore_db_from_latest_backup_arginfo, ZEND_ACC_PUBLIC) 36 | PHP_ME(rocksdb_backup_engine, getBackupInfo, NULL, ZEND_ACC_PUBLIC) 37 | PHP_ME(rocksdb_backup_engine, close, NULL, ZEND_ACC_PUBLIC) 38 | PHP_FE_END 39 | }; 40 | 41 | PHP_METHOD(rocksdb_backup_engine, __construct) { 42 | const char *name = NULL; 43 | char *err = NULL; 44 | size_t name_len; 45 | zval *options_zv = NULL; 46 | php_rocksdb_backup_engine_object *this = NULL; 47 | rocksdb_options_t *options = NULL; 48 | 49 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", 50 | &name, &name_len, &options_zv) == FAILURE) { 51 | return; 52 | } 53 | 54 | this = Z_ROCKSDB_BACKUP_ENGINE_P(getThis() TSRMLS_CC); 55 | 56 | options = php_rocksdb_get_open_options(options_zv); 57 | this->be = rocksdb_backup_engine_open(options, name, &err); 58 | rocksdb_options_destroy(options); 59 | 60 | ROCKSDB_CHECK_FOR_ERRORS(err); 61 | } 62 | PHP_METHOD(rocksdb_backup_engine, purgeOldBackups) { 63 | char *err = NULL; 64 | zend_ulong num; 65 | php_rocksdb_backup_engine_object *this; 66 | 67 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &num) == FAILURE) { 68 | return; 69 | } 70 | 71 | this = Z_ROCKSDB_BACKUP_ENGINE_P(getThis() TSRMLS_CC); 72 | rocksdb_backup_engine_purge_old_backups(this->be, num, &err); 73 | 74 | ROCKSDB_CHECK_FOR_ERRORS(err); 75 | } 76 | PHP_METHOD(rocksdb_backup_engine, createNewBackup) { 77 | char *err = NULL; 78 | zval *rocks_zv = NULL; 79 | php_rocksdb_db_object *rocks; 80 | php_rocksdb_backup_engine_object *this; 81 | 82 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", 83 | &rocks_zv, rocksdb_ce) == FAILURE) { 84 | return; 85 | } 86 | 87 | rocks = Z_ROCKSDB_DB_P(rocks_zv TSRMLS_CC); 88 | this = Z_ROCKSDB_BACKUP_ENGINE_P(getThis() TSRMLS_CC); 89 | 90 | rocksdb_backup_engine_create_new_backup(this->be, rocks->db, &err); 91 | 92 | ROCKSDB_CHECK_FOR_ERRORS(err); 93 | } 94 | PHP_METHOD(rocksdb_backup_engine, restoreDbFromLatestBackup) { 95 | char *db_dir, *wal_dir, *err = NULL; 96 | size_t db_dir_len, wal_dir_len; 97 | zval *restore_options_zv = NULL; 98 | rocksdb_restore_options_t *restore_options; 99 | php_rocksdb_backup_engine_object *this; 100 | 101 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|a", 102 | &db_dir, &db_dir_len, &wal_dir, &wal_dir_len, &restore_options_zv) == FAILURE) { 103 | return; 104 | } 105 | 106 | restore_options = php_rocksdb_get_restore_options(restore_options_zv); 107 | this = Z_ROCKSDB_BACKUP_ENGINE_P(getThis() TSRMLS_CC); 108 | 109 | rocksdb_backup_engine_restore_db_from_latest_backup(this->be, (const char *) db_dir, (const char *) wal_dir, restore_options, &err); 110 | 111 | ROCKSDB_CHECK_FOR_ERRORS(err); 112 | } 113 | PHP_METHOD(rocksdb_backup_engine, getBackupInfo) { 114 | if (zend_parse_parameters_none() == FAILURE) { 115 | return; 116 | } 117 | 118 | object_init_ex(return_value, rocksdb_backup_engine_info_ce); 119 | 120 | zend_call_method_with_1_params(return_value, rocksdb_backup_engine_info_ce, 121 | &rocksdb_backup_engine_info_ce->constructor, "__construct", NULL, getThis()); 122 | } 123 | PHP_METHOD(rocksdb_backup_engine, close) { 124 | php_rocksdb_backup_engine_object *this; 125 | 126 | if (zend_parse_parameters_none() == FAILURE) { 127 | return; 128 | } 129 | 130 | this = Z_ROCKSDB_BACKUP_ENGINE_P(getThis() TSRMLS_CC); 131 | 132 | rocksdb_backup_engine_close(this->be); 133 | this->be = NULL; 134 | } 135 | -------------------------------------------------------------------------------- /rocksdb_backup_engine_info.c: -------------------------------------------------------------------------------- 1 | /* 2 | * rocksdb_backup.c 3 | * 4 | */ 5 | #ifdef HAVE_CONFIG_H 6 | #include "config.h" 7 | #endif 8 | 9 | #include "php.h" 10 | 11 | #include "php_rocksdb.h" 12 | 13 | zend_class_entry *rocksdb_backup_engine_info_ce; 14 | 15 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_backup_engine_info__construct_arginfo, 0, 0, 1) 16 | ZEND_ARG_INFO(0, db) 17 | ZEND_END_ARG_INFO() 18 | 19 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_backup_engine_info_get_count_arginfo, 0, 0, 1) 20 | ZEND_ARG_INFO(0, index) 21 | ZEND_END_ARG_INFO() 22 | 23 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_backup_engine_info_get_timestamp_arginfo, 0, 0, 1) 24 | ZEND_ARG_INFO(0, index) 25 | ZEND_END_ARG_INFO() 26 | 27 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_backup_engine_info_get_backup_id_arginfo, 0, 0, 1) 28 | ZEND_ARG_INFO(0, index) 29 | ZEND_END_ARG_INFO() 30 | 31 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_backup_engine_info_get_size_arginfo, 0, 0, 1) 32 | ZEND_ARG_INFO(0, index) 33 | ZEND_END_ARG_INFO() 34 | 35 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_backup_engine_info_get_num_files_arginfo, 0, 0, 1) 36 | ZEND_ARG_INFO(0, index) 37 | ZEND_END_ARG_INFO() 38 | 39 | const zend_function_entry rocksdb_backup_engine_info_class_methods[] = { 40 | PHP_ME(rocksdb_backup_engine_info, __construct, rocksdb_backup_engine_info__construct_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) 41 | PHP_ME(rocksdb_backup_engine_info, getCount, rocksdb_backup_engine_info_get_count_arginfo, ZEND_ACC_PUBLIC) 42 | PHP_ME(rocksdb_backup_engine_info, getTimestamp, rocksdb_backup_engine_info_get_timestamp_arginfo, ZEND_ACC_PUBLIC) 43 | PHP_ME(rocksdb_backup_engine_info, getBackupId, rocksdb_backup_engine_info_get_backup_id_arginfo, ZEND_ACC_PUBLIC) 44 | PHP_ME(rocksdb_backup_engine_info, getSize, rocksdb_backup_engine_info_get_size_arginfo, ZEND_ACC_PUBLIC) 45 | PHP_ME(rocksdb_backup_engine_info, getNumFiles, rocksdb_backup_engine_info_get_num_files_arginfo, ZEND_ACC_PUBLIC) 46 | PHP_ME(rocksdb_backup_engine_info, destroy, NULL, ZEND_ACC_PUBLIC) 47 | PHP_FE_END 48 | }; 49 | 50 | PHP_METHOD(rocksdb_backup_engine_info, __construct) { 51 | zval *be_zv = NULL; 52 | php_rocksdb_backup_engine_object *backup_engine; 53 | php_rocksdb_backup_engine_info_object *this; 54 | 55 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &be_zv, rocksdb_backup_engine_ce) == FAILURE) { 56 | return; 57 | } 58 | 59 | this = Z_ROCKSDB_BACKUP_ENGINE_INFO_P(getThis() TSRMLS_CC); 60 | backup_engine = Z_ROCKSDB_BACKUP_ENGINE_P(be_zv TSRMLS_CC); 61 | 62 | this->info = rocksdb_backup_engine_get_backup_info(backup_engine->be); 63 | } 64 | PHP_METHOD(rocksdb_backup_engine_info, getCount) { 65 | php_rocksdb_backup_engine_info_object *this; 66 | this = Z_ROCKSDB_BACKUP_ENGINE_INFO_P(getThis() TSRMLS_CC); 67 | 68 | if (zend_parse_parameters_none() == FAILURE) { 69 | return; 70 | } 71 | 72 | int c = rocksdb_backup_engine_info_count(this->info); 73 | 74 | RETVAL_LONG(c); 75 | } 76 | PHP_METHOD(rocksdb_backup_engine_info, getTimestamp) { 77 | char *index; 78 | size_t index_len; 79 | 80 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &index, &index_len) == FAILURE) { 81 | return; 82 | } 83 | 84 | php_rocksdb_backup_engine_info_object *this; 85 | this = Z_ROCKSDB_BACKUP_ENGINE_INFO_P(getThis() TSRMLS_CC); 86 | 87 | int i = atoi(index); 88 | int64_t retval = rocksdb_backup_engine_info_timestamp(this->info, i); 89 | 90 | RETVAL_LONG(retval); 91 | } 92 | PHP_METHOD(rocksdb_backup_engine_info, getBackupId) { 93 | char *index; 94 | size_t index_len; 95 | 96 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &index, &index_len) == FAILURE) { 97 | return; 98 | } 99 | 100 | php_rocksdb_backup_engine_info_object *this; 101 | this = Z_ROCKSDB_BACKUP_ENGINE_INFO_P(getThis() TSRMLS_CC); 102 | 103 | int i = atoi(index); 104 | int64_t retval = rocksdb_backup_engine_info_backup_id(this->info, i); 105 | 106 | RETVAL_LONG(retval); 107 | } 108 | PHP_METHOD(rocksdb_backup_engine_info, getSize) { 109 | char *index; 110 | size_t index_len; 111 | 112 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &index, &index_len) == FAILURE) { 113 | return; 114 | } 115 | 116 | php_rocksdb_backup_engine_info_object *this; 117 | this = Z_ROCKSDB_BACKUP_ENGINE_INFO_P(getThis() TSRMLS_CC); 118 | 119 | int i = atoi(index); 120 | int64_t retval = rocksdb_backup_engine_info_size(this->info, i); 121 | 122 | RETVAL_LONG(retval); 123 | } 124 | PHP_METHOD(rocksdb_backup_engine_info, getNumFiles) { 125 | char *index; 126 | size_t index_len; 127 | 128 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &index, &index_len) == FAILURE) { 129 | return; 130 | } 131 | 132 | php_rocksdb_backup_engine_info_object *this; 133 | this = Z_ROCKSDB_BACKUP_ENGINE_INFO_P(getThis() TSRMLS_CC); 134 | 135 | int i = atoi(index); 136 | uint32_t retval = rocksdb_backup_engine_info_number_files(this->info, i); 137 | 138 | RETVAL_LONG(retval); 139 | } 140 | PHP_METHOD(rocksdb_backup_engine_info, destroy) { 141 | if (zend_parse_parameters_none() == FAILURE) { 142 | return; 143 | } 144 | 145 | php_rocksdb_backup_engine_info_object *this; 146 | this = Z_ROCKSDB_BACKUP_ENGINE_INFO_P(getThis() TSRMLS_CC); 147 | 148 | rocksdb_backup_engine_info_destroy(this->info); 149 | 150 | RETURN_TRUE; 151 | } 152 | -------------------------------------------------------------------------------- /rocksdb_cache.c: -------------------------------------------------------------------------------- 1 | /* 2 | * rocksdb_iterator.c 3 | * 4 | */ 5 | #ifdef HAVE_CONFIG_H 6 | #include "config.h" 7 | #endif 8 | 9 | #include "php.h" 10 | 11 | #include "php_rocksdb.h" 12 | 13 | zend_class_entry *rocksdb_cache_ce; 14 | 15 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_cache_class__construct_arginfo, 0, 0, 1) 16 | ZEND_ARG_INFO(0, capacity) 17 | ZEND_END_ARG_INFO() 18 | 19 | const zend_function_entry rocksdb_cache_class_methods[] = { 20 | PHP_ME(rocksdb_cache, __construct, rocksdb_cache_class__construct_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) 21 | PHP_ME(rocksdb_cache, destroy, NULL, ZEND_ACC_PUBLIC) 22 | PHP_FE_END 23 | }; 24 | 25 | PHP_METHOD(rocksdb_cache, __construct) {} 26 | PHP_METHOD(rocksdb_cache, destroy) {} -------------------------------------------------------------------------------- /rocksdb_ce.h: -------------------------------------------------------------------------------- 1 | /* 2 | +----------------------------------------------------------------------+ 3 | | PHP Version 7 | 4 | +----------------------------------------------------------------------+ 5 | | Copyright (c) 1997-2015 The PHP Group | 6 | +----------------------------------------------------------------------+ 7 | | This source file is subject to version 3.01 of the PHP license, | 8 | | that is bundled with this package in the file LICENSE, and is | 9 | | available through the world-wide-web at the following url: | 10 | | http://www.php.net/license/3_01.txt | 11 | | If you did not receive a copy of the PHP license and are unable to | 12 | | obtain it through the world-wide-web, please send a note to | 13 | | license@php.net so we can mail you a copy immediately. | 14 | +----------------------------------------------------------------------+ 15 | | Authors: Justinas Petrulis | 16 | +----------------------------------------------------------------------+ 17 | */ 18 | 19 | /* $Id$ */ 20 | #ifndef ROCKSDB_FE_H 21 | #define ROCKSDB_FE_H 22 | 23 | extern const zend_function_entry rocksdb_class_methods[]; 24 | extern const zend_function_entry rocksdb_backup_engine_class_methods[]; 25 | extern const zend_function_entry rocksdb_backup_engine_info_class_methods[]; 26 | extern const zend_function_entry rocksdb_cache_class_methods[]; 27 | extern const zend_function_entry rocksdb_iterator_class_methods[]; 28 | extern const zend_function_entry rocksdb_snapshot_class_methods[]; 29 | extern const zend_function_entry rocksdb_write_batch_class_methods[]; 30 | extern const zend_function_entry rocksdb_compaction_filter_interface_methods[]; 31 | extern const zend_function_entry rocksdb_comparator_interface_methods[]; 32 | extern const zend_function_entry rocksdb_merge_operator_interface_methods[]; 33 | 34 | // RocksDb class methods 35 | PHP_METHOD(rocksdb, __construct); 36 | PHP_METHOD(rocksdb, listColumnFamilies); 37 | PHP_METHOD(rocksdb, createColumnFamily); 38 | PHP_METHOD(rocksdb, dropColumnFamily); 39 | PHP_METHOD(rocksdb, put); 40 | PHP_METHOD(rocksdb, putCf); 41 | PHP_METHOD(rocksdb, delete); 42 | PHP_METHOD(rocksdb, deleteCf); 43 | PHP_METHOD(rocksdb, merge); 44 | PHP_METHOD(rocksdb, mergeCf); 45 | PHP_METHOD(rocksdb, write); 46 | PHP_METHOD(rocksdb, get); 47 | PHP_METHOD(rocksdb, getCf); 48 | PHP_METHOD(rocksdb, getIterator); 49 | PHP_METHOD(rocksdb, getIteratorCf); 50 | PHP_METHOD(rocksdb, createSnapshot); 51 | PHP_METHOD(rocksdb, getProperty); 52 | PHP_METHOD(rocksdb, getPropertyCf); 53 | PHP_METHOD(rocksdb, getApproximateSizes); 54 | PHP_METHOD(rocksdb, getApproximateSizesCf); 55 | PHP_METHOD(rocksdb, flush); 56 | PHP_METHOD(rocksdb, deleteFile); 57 | PHP_METHOD(rocksdb, disableFileDeletions); 58 | PHP_METHOD(rocksdb, enableFileDeletions); 59 | PHP_METHOD(rocksdb, destroy); 60 | PHP_METHOD(rocksdb, repair); 61 | PHP_METHOD(rocksdb, close); 62 | 63 | // RocksDb\BackupEngine 64 | PHP_METHOD(rocksdb_backup_engine, __construct); 65 | PHP_METHOD(rocksdb_backup_engine, purgeOldBackups); 66 | PHP_METHOD(rocksdb_backup_engine, createNewBackup); 67 | PHP_METHOD(rocksdb_backup_engine, restoreDbFromLatestBackup); 68 | PHP_METHOD(rocksdb_backup_engine, getBackupInfo); 69 | PHP_METHOD(rocksdb_backup_engine, close); 70 | 71 | // RocksDb\BackupEngineInfo class methods 72 | PHP_METHOD(rocksdb_backup_engine_info, __construct); 73 | PHP_METHOD(rocksdb_backup_engine_info, getCount); 74 | PHP_METHOD(rocksdb_backup_engine_info, getTimestamp); 75 | PHP_METHOD(rocksdb_backup_engine_info, getBackupId); 76 | PHP_METHOD(rocksdb_backup_engine_info, getSize); 77 | PHP_METHOD(rocksdb_backup_engine_info, getNumFiles); 78 | PHP_METHOD(rocksdb_backup_engine_info, destroy); 79 | 80 | // RocksDbCache class methods 81 | PHP_METHOD(rocksdb_cache, __construct); 82 | PHP_METHOD(rocksdb_cache, destroy); 83 | 84 | // RocksDb\Iterator class methods 85 | PHP_METHOD(rocksdb_iterator, __construct); 86 | PHP_METHOD(rocksdb_iterator, current); 87 | PHP_METHOD(rocksdb_iterator, key); 88 | PHP_METHOD(rocksdb_iterator, next); 89 | PHP_METHOD(rocksdb_iterator, rewind); 90 | PHP_METHOD(rocksdb_iterator, valid); 91 | PHP_METHOD(rocksdb_iterator, seek); 92 | 93 | // RocksDb\Snapshot class methods 94 | PHP_METHOD(rocksdb_snapshot, __construct); 95 | PHP_METHOD(rocksdb_snapshot, release); 96 | 97 | // Rocksdb\WriteBatch class methods 98 | PHP_METHOD(rocksdb_write_batch, __construct); 99 | PHP_METHOD(rocksdb_write_batch, createFrom); 100 | PHP_METHOD(rocksdb_write_batch, put); 101 | PHP_METHOD(rocksdb_write_batch, putCf); 102 | PHP_METHOD(rocksdb_write_batch, merge); 103 | PHP_METHOD(rocksdb_write_batch, mergeCf); 104 | PHP_METHOD(rocksdb_write_batch, delete); 105 | PHP_METHOD(rocksdb_write_batch, deleteCf); 106 | PHP_METHOD(rocksdb_write_batch, data); 107 | PHP_METHOD(rocksdb_write_batch, count); 108 | PHP_METHOD(rocksdb_write_batch, getIterator); 109 | PHP_METHOD(rocksdb_write_batch, clear); 110 | PHP_METHOD(rocksdb_write_batch, destroy); 111 | 112 | #endif /* ROCKSDB_FE_H */ 113 | 114 | 115 | /* 116 | * Local variables: 117 | * tab-width: 4 118 | * c-basic-offset: 4 119 | * End: 120 | * vim600: noet sw=4 ts=4 fdm=marker 121 | * vim<600: noet sw=4 ts=4 122 | */ 123 | -------------------------------------------------------------------------------- /rocksdb_iterator.c: -------------------------------------------------------------------------------- 1 | /* 2 | * rocksdb_iterator.c 3 | * 4 | */ 5 | #ifdef HAVE_CONFIG_H 6 | #include "config.h" 7 | #endif 8 | 9 | #include "php.h" 10 | 11 | #include "php_rocksdb.h" 12 | 13 | zend_class_entry *rocksdb_iterator_ce; 14 | 15 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_class__construct_arginfo, 0, 0, 2) 16 | ZEND_ARG_INFO(0, db) 17 | ZEND_ARG_INFO(0, read_options) 18 | ZEND_END_ARG_INFO() 19 | 20 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_iterator_class_seek_arginfo, 0, 0, 1) 21 | ZEND_ARG_INFO(0, key) 22 | ZEND_END_ARG_INFO() 23 | 24 | const zend_function_entry rocksdb_iterator_class_methods[] = { 25 | PHP_ME(rocksdb_iterator, __construct, rocksdb_class__construct_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) 26 | PHP_ME(rocksdb_iterator, current, NULL, ZEND_ACC_PUBLIC) 27 | PHP_ME(rocksdb_iterator, key, NULL, ZEND_ACC_PUBLIC) 28 | PHP_ME(rocksdb_iterator, next, NULL, ZEND_ACC_PUBLIC) 29 | PHP_ME(rocksdb_iterator, rewind, NULL, ZEND_ACC_PUBLIC) 30 | PHP_ME(rocksdb_iterator, valid, NULL, ZEND_ACC_PUBLIC) 31 | PHP_ME(rocksdb_iterator, seek, rocksdb_iterator_class_seek_arginfo, ZEND_ACC_PUBLIC) 32 | PHP_FE_END 33 | }; 34 | 35 | PHP_METHOD(rocksdb_iterator, __construct) { 36 | zval *db_zv = NULL; 37 | php_rocksdb_db_object *db_obj; 38 | zval *readoptions_zv = NULL; 39 | 40 | php_rocksdb_iterator_object *intern; 41 | rocksdb_readoptions_t *readoptions; 42 | 43 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|z", 44 | &db_zv, rocksdb_ce, &readoptions_zv) == FAILURE) { 45 | return; 46 | } 47 | 48 | intern = Z_ROCKSDB_ITERATOR_P(getThis() TSRMLS_CC); 49 | db_obj = Z_ROCKSDB_DB_P(db_zv); 50 | 51 | readoptions = php_rocksdb_get_read_options(readoptions_zv); 52 | intern->iterator = rocksdb_create_iterator(db_obj->db, readoptions); 53 | rocksdb_readoptions_destroy(readoptions); 54 | 55 | intern->db = db_zv; 56 | 57 | rocksdb_iter_seek_to_first(intern->iterator); 58 | } 59 | PHP_METHOD(rocksdb_iterator, current) { 60 | char *value = NULL; 61 | size_t value_len; 62 | php_rocksdb_iterator_object *intern; 63 | 64 | if (zend_parse_parameters_none() == FAILURE) { 65 | return; 66 | } 67 | 68 | intern = Z_ROCKSDB_ITERATOR_P(getThis() TSRMLS_CC); 69 | 70 | if (!rocksdb_iter_valid(intern->iterator) || 71 | !(value = (char *)rocksdb_iter_value(intern->iterator, &value_len))) { 72 | RETURN_FALSE; 73 | } 74 | 75 | RETVAL_STRINGL(value, value_len); 76 | } 77 | PHP_METHOD(rocksdb_iterator, key) { 78 | char *key = NULL; 79 | size_t key_len; 80 | php_rocksdb_iterator_object *intern; 81 | 82 | if (zend_parse_parameters_none() == FAILURE) { 83 | return; 84 | } 85 | 86 | intern = Z_ROCKSDB_ITERATOR_P(getThis() TSRMLS_CC); 87 | 88 | if (!rocksdb_iter_valid(intern->iterator) || 89 | !(key = (char *)rocksdb_iter_key(intern->iterator, &key_len))) { 90 | RETURN_FALSE; 91 | } 92 | 93 | RETVAL_STRINGL(key, key_len); 94 | } 95 | PHP_METHOD(rocksdb_iterator, next) { 96 | php_rocksdb_iterator_object *intern; 97 | 98 | if (zend_parse_parameters_none() == FAILURE) { 99 | return; 100 | } 101 | 102 | intern = Z_ROCKSDB_ITERATOR_P(getThis() TSRMLS_CC); 103 | 104 | if (rocksdb_iter_valid(intern->iterator)) { 105 | rocksdb_iter_next(intern->iterator); 106 | } 107 | } 108 | PHP_METHOD(rocksdb_iterator, rewind) { 109 | php_rocksdb_iterator_object *intern; 110 | 111 | if (zend_parse_parameters_none() == FAILURE) { 112 | return; 113 | } 114 | 115 | intern = Z_ROCKSDB_ITERATOR_P(getThis() TSRMLS_CC); 116 | 117 | if (rocksdb_iter_valid(intern->iterator)) { 118 | rocksdb_iter_prev(intern->iterator); 119 | } 120 | } 121 | PHP_METHOD(rocksdb_iterator, valid) { 122 | php_rocksdb_iterator_object *intern; 123 | 124 | if (zend_parse_parameters_none() == FAILURE) { 125 | return; 126 | } 127 | 128 | intern = Z_ROCKSDB_ITERATOR_P(getThis() TSRMLS_CC); 129 | 130 | RETVAL_BOOL(rocksdb_iter_valid(intern->iterator)); 131 | } 132 | PHP_METHOD(rocksdb_iterator, seek) { 133 | char *key; 134 | int key_len; 135 | php_rocksdb_iterator_object *intern; 136 | 137 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len ) == FAILURE) { 138 | return; 139 | } 140 | 141 | intern = Z_ROCKSDB_ITERATOR_P(getThis() TSRMLS_CC); 142 | 143 | rocksdb_iter_seek(intern->iterator, key, (size_t) key_len); 144 | } 145 | -------------------------------------------------------------------------------- /rocksdb_merge_operator.c: -------------------------------------------------------------------------------- 1 | /* 2 | * rocksdb_iterator.c 3 | * 4 | */ 5 | #ifdef HAVE_CONFIG_H 6 | #include "config.h" 7 | #endif 8 | 9 | #include "php.h" 10 | 11 | #include "php_rocksdb.h" 12 | 13 | zend_class_entry *rocksdb_merge_operator_ce; 14 | 15 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_merge_operator_full_merge_arginfo, 0, 0, 3) 16 | ZEND_ARG_INFO(0, key) 17 | ZEND_ARG_INFO(0, existing_value) 18 | ZEND_ARG_INFO(1, value) 19 | ZEND_END_ARG_INFO() 20 | 21 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_merge_operator_partial_merge_arginfo, 0, 0, 3) 22 | ZEND_ARG_INFO(0, key) 23 | ZEND_ARG_INFO(0, left_operand) 24 | ZEND_ARG_INFO(0, right_operand) 25 | ZEND_END_ARG_INFO() 26 | 27 | const zend_function_entry rocksdb_merge_operator_interface_methods[] = { 28 | PHP_ABSTRACT_ME(rocksdb_merge_operator, fullMerge, rocksdb_merge_operator_full_merge_arginfo) 29 | PHP_ABSTRACT_ME(rocksdb_merge_operator, partialMerge, rocksdb_merge_operator_partial_merge_arginfo) 30 | PHP_ABSTRACT_ME(rocksdb_merge_operator, getName, NULL) 31 | PHP_FE_END 32 | }; 33 | -------------------------------------------------------------------------------- /rocksdb_snapshot.c: -------------------------------------------------------------------------------- 1 | /* 2 | * rocksdb_snapshot.c 3 | * 4 | */ 5 | #ifdef HAVE_CONFIG_H 6 | #include "config.h" 7 | #endif 8 | 9 | #include "php.h" 10 | 11 | #include "php_rocksdb.h" 12 | 13 | zend_class_entry *rocksdb_snapshot_ce; 14 | 15 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_snapshot_class__construct_arginfo, 0, 0, 1) 16 | ZEND_ARG_INFO(0, db) 17 | ZEND_END_ARG_INFO() 18 | 19 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_snapshot_class_release_arginfo, 0, 0, 0) 20 | ZEND_END_ARG_INFO() 21 | 22 | const zend_function_entry rocksdb_snapshot_class_methods[] = { 23 | PHP_ME(rocksdb_snapshot, __construct, rocksdb_snapshot_class__construct_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) 24 | PHP_ME(rocksdb_snapshot, release, rocksdb_snapshot_class_release_arginfo, ZEND_ACC_PUBLIC) 25 | PHP_FE_END 26 | }; 27 | 28 | PHP_METHOD(rocksdb_snapshot, __construct) { 29 | zval *db_zv = NULL; 30 | php_rocksdb_db_object *db_obj; 31 | php_rocksdb_snapshot_object *intern; 32 | 33 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", 34 | &db_zv, rocksdb_ce) == FAILURE) { 35 | return; 36 | } 37 | 38 | intern = Z_ROCKSDB_SNAPSHOT_P(getThis() TSRMLS_CC); 39 | db_obj = Z_ROCKSDB_DB_P(db_zv TSRMLS_CC); 40 | 41 | intern->snapshot = (rocksdb_snapshot_t *)rocksdb_create_snapshot(db_obj->db); 42 | 43 | intern->db = db_zv; 44 | } 45 | PHP_METHOD(rocksdb_snapshot, release) { 46 | php_rocksdb_snapshot_object *intern; 47 | 48 | if (zend_parse_parameters_none() == FAILURE) { 49 | return; 50 | } 51 | 52 | intern = Z_ROCKSDB_SNAPSHOT_P(getThis() TSRMLS_CC); 53 | 54 | if (!intern->db) { 55 | return; 56 | } 57 | 58 | php_rocksdb_db_object *db = Z_ROCKSDB_DB_P(intern->db TSRMLS_CC); 59 | rocksdb_release_snapshot(db->db, intern->snapshot); 60 | 61 | intern->snapshot = NULL; 62 | intern->db = NULL; 63 | } 64 | -------------------------------------------------------------------------------- /rocksdb_write_batch.c: -------------------------------------------------------------------------------- 1 | /* 2 | * rocksdb_write_batch.c 3 | * 4 | */ 5 | #ifdef HAVE_CONFIG_H 6 | #include "config.h" 7 | #endif 8 | 9 | #include "php.h" 10 | 11 | #include "php_rocksdb.h" 12 | 13 | zend_class_entry *rocksdb_write_batch_ce; 14 | 15 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_write_batch_class_put_arginfo, 0, 0, 2) 16 | ZEND_ARG_INFO(0, key) 17 | ZEND_ARG_INFO(0, value) 18 | ZEND_END_ARG_INFO() 19 | 20 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_write_batch_class_merge_arginfo, 0, 0, 2) 21 | ZEND_ARG_INFO(0, key) 22 | ZEND_ARG_INFO(0, value) 23 | ZEND_END_ARG_INFO() 24 | 25 | ZEND_BEGIN_ARG_INFO_EX(rocksdb_write_batch_class_delete_arginfo, 0, 0, 1) 26 | ZEND_ARG_INFO(0, key) 27 | ZEND_END_ARG_INFO() 28 | 29 | const zend_function_entry rocksdb_write_batch_class_methods[] = { 30 | PHP_ME(rocksdb_write_batch, __construct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR) 31 | PHP_ME(rocksdb_write_batch, put, rocksdb_write_batch_class_put_arginfo, ZEND_ACC_PUBLIC) 32 | PHP_ME(rocksdb_write_batch, merge, rocksdb_write_batch_class_merge_arginfo, ZEND_ACC_PUBLIC) 33 | PHP_ME(rocksdb_write_batch, delete, rocksdb_write_batch_class_delete_arginfo, ZEND_ACC_PUBLIC) 34 | PHP_ME(rocksdb_write_batch, data, NULL, ZEND_ACC_PUBLIC) 35 | PHP_ME(rocksdb_write_batch, clear, NULL, ZEND_ACC_PUBLIC) 36 | PHP_ME(rocksdb_write_batch, destroy, NULL, ZEND_ACC_PUBLIC) 37 | PHP_FE_END 38 | }; 39 | 40 | PHP_METHOD(rocksdb_write_batch, __construct) { 41 | php_rocksdb_write_batch_object *this; 42 | rocksdb_writebatch_t *batch; 43 | 44 | if (zend_parse_parameters_none() == FAILURE) { 45 | return; 46 | } 47 | 48 | this = Z_ROCKSDB_WRITE_BATCH_P(getThis() TSRMLS_CC); 49 | batch = rocksdb_writebatch_create(); 50 | 51 | this->batch = batch; 52 | } 53 | PHP_METHOD(rocksdb_write_batch, put) { 54 | char *key, *value; 55 | size_t key_len, value_len; 56 | 57 | php_rocksdb_write_batch_object *this; 58 | 59 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", 60 | &key, &key_len, &value, &value_len) == FAILURE) { 61 | return; 62 | } 63 | 64 | this = Z_ROCKSDB_WRITE_BATCH_P(getThis() TSRMLS_CC); 65 | rocksdb_writebatch_put(this->batch, key, key_len, value, value_len); 66 | 67 | RETURN_TRUE; 68 | } 69 | PHP_METHOD(rocksdb_write_batch, merge) { 70 | char *key, *value; 71 | size_t key_len, value_len; 72 | 73 | php_rocksdb_write_batch_object *this; 74 | 75 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", 76 | &key, &key_len, &value, &value_len) == FAILURE) { 77 | return; 78 | } 79 | 80 | this = Z_ROCKSDB_WRITE_BATCH_P(getThis() TSRMLS_CC); 81 | rocksdb_writebatch_merge(this->batch, (const char *) key, key_len, (const char *) value, value_len); 82 | 83 | RETURN_TRUE; 84 | } 85 | PHP_METHOD(rocksdb_write_batch, delete) { 86 | char *key; 87 | size_t key_len; 88 | 89 | php_rocksdb_write_batch_object *this; 90 | 91 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len) == FAILURE) { 92 | return; 93 | } 94 | 95 | this = Z_ROCKSDB_WRITE_BATCH_P(getThis() TSRMLS_CC); 96 | rocksdb_writebatch_delete(this->batch, key, key_len); 97 | } 98 | PHP_METHOD(rocksdb_write_batch, data) { 99 | const char *value; 100 | size_t *size, size_len; 101 | php_rocksdb_write_batch_object *this; 102 | 103 | if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &size, &size_len) == FAILURE) { 104 | return; 105 | } 106 | 107 | this = Z_ROCKSDB_WRITE_BATCH_P(getThis() TSRMLS_CC); 108 | value = rocksdb_writebatch_data(this->batch, size); 109 | 110 | RETVAL_STRINGL(value, size_len); 111 | } 112 | PHP_METHOD(rocksdb_write_batch, clear) { 113 | php_rocksdb_write_batch_object *this; 114 | 115 | if (zend_parse_parameters_none() == FAILURE) { 116 | return; 117 | } 118 | 119 | this = Z_ROCKSDB_WRITE_BATCH_P(getThis() TSRMLS_CC); 120 | rocksdb_writebatch_clear(this->batch); 121 | 122 | RETURN_TRUE; 123 | } 124 | PHP_METHOD(rocksdb_write_batch, destroy) { 125 | php_rocksdb_write_batch_object *this; 126 | 127 | if (zend_parse_parameters_none() == FAILURE) { 128 | return; 129 | } 130 | 131 | this = Z_ROCKSDB_WRITE_BATCH_P(getThis() TSRMLS_CC); 132 | rocksdb_writebatch_destroy(this->batch); 133 | 134 | RETURN_TRUE; 135 | } 136 | -------------------------------------------------------------------------------- /tests/001.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Check for rocksdb presence 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | 20 | --EXPECT-- 21 | rocksdb extension is available 22 | -------------------------------------------------------------------------------- /tests/002-basic.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | rocksdb - basic: get(), put(), delete() 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true]); 12 | var_dump($db->put('key', 'value')); 13 | var_dump($db->get('key')); 14 | var_dump($db->get('non-exists-key')); 15 | var_dump($db->put('name', 'justinas')); 16 | var_dump($db->get('name')); 17 | var_dump($db->delete('name')); 18 | var_dump($db->get('name')); 19 | ?> 20 | --EXPECTF-- 21 | bool(true) 22 | string(5) "value" 23 | bool(false) 24 | bool(true) 25 | string(8) "justinas" 26 | bool(true) 27 | bool(false) 28 | -------------------------------------------------------------------------------- /tests/003-open.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | Open database create_if_missing, read_only 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true 13 | ]); 14 | $db->close(); 15 | $db = new RocksDb\RocksDb($rocksdb_path, [ 16 | 'create_if_missing' => true, 17 | 'read_only' => true 18 | ]); 19 | var_dump($db->put('key', 'value')); 20 | ?> 21 | --EXPECTF-- 22 | Fatal error: Uncaught RocksDb\Exception: Not implemented: Not supported operation in read only mode. in %s 23 | Stack trace: 24 | #0 %s: RocksDb\RocksDb->put('key', 'value') 25 | #1 {main} 26 | thrown in %s on line %d 27 | -------------------------------------------------------------------------------- /tests/004-open.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | rocksdb - open 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true, 13 | 'create_if_missing' => true 14 | ]); 15 | ?> 16 | --EXPECTF-- 17 | -------------------------------------------------------------------------------- /tests/005-open-cf.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | rocksdb - open 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true 13 | ], [], [], [0], []); 14 | ?> 15 | --EXPECTF-- 16 | Fatal error: Expected string for frame 0 in %s on line %d 17 | -------------------------------------------------------------------------------- /tests/006-open-cf.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | rocksdb - open 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true 13 | ], [], [], ['default'], []); 14 | ?> 15 | --EXPECTF-- 16 | -------------------------------------------------------------------------------- /tests/007-destroy.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | rocksdb - destroy 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true]); 9 | $db->close(); 10 | $db->destroy([]); 11 | ?> 12 | --EXPECTF-- 13 | -------------------------------------------------------------------------------- /tests/008-iterator.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | rocksdb - iterator 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true]); 12 | $db->put('x', '1'); 13 | $db->put('y', '2'); 14 | $db->put('z', '3'); 15 | $it = $db->getIterator([]); 16 | while($it->valid()) { 17 | var_dump($it->key(), $it->current()); 18 | $it->next(); 19 | } 20 | ?> 21 | --EXPECTF-- 22 | string(1) "x" 23 | string(1) "1" 24 | string(1) "y" 25 | string(1) "2" 26 | string(1) "z" 27 | string(1) "3" 28 | -------------------------------------------------------------------------------- /tests/009-write-batch.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | rocksdb - write batch 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true]); 12 | $batch = new RocksDb\WriteBatch(); 13 | $batch->put('x', 1); 14 | $batch->put('y', 2); 15 | $db->write($batch); 16 | var_dump($db->get('x')); 17 | var_dump($db->get('y')); 18 | ?> 19 | --EXPECTF-- 20 | string(1) "1" 21 | string(1) "2" 22 | -------------------------------------------------------------------------------- /tests/010-snapshot.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | rocksdb - snapshot 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true]); 12 | $db->put('x', 1); 13 | $snapshot = $db->createSnapshot(); 14 | $db->delete('x'); 15 | var_dump($db->get('x', [ 16 | 'snapshot' => $snapshot, 17 | ])); 18 | ?> 19 | --EXPECTF-- 20 | string(1) "1" 21 | -------------------------------------------------------------------------------- /tests/011-backup-engine.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | rocksdb - backup engine 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true]); 12 | $db->put('x', 1); 13 | $engine = new RocksDb\BackupEngine($rocksdb_path); 14 | $engine->createNewBackup($db); 15 | $db->delete('x'); 16 | $engine->restoreDbFromLatestBackup($rocksdb_path, $rocksdb_path, [ 17 | 'set_keep_log_files' => true, 18 | ]); 19 | $db->close(); 20 | $db = new RocksDb\RocksDb($rocksdb_path, ['create_if_missing' => true]); 21 | var_dump($db->get('x')); 22 | ?> 23 | --EXPECTF-- 24 | string(1) "1" 25 | -------------------------------------------------------------------------------- /tests/012-backup-engine-info.phpt: -------------------------------------------------------------------------------- 1 | --TEST-- 2 | rocksdb - backup engine info 3 | --SKIPIF-- 4 | 5 | --FILE-- 6 | true]); 12 | $engine = new RocksDb\BackupEngine($rocksdb_path); 13 | $engine->purgeOldBackups(0); 14 | $engine->createNewBackup($db); 15 | $info = $engine->getBackupInfo(); 16 | var_dump($info->getCount()); 17 | ?> 18 | --EXPECTF-- 19 | int(1) 20 | --------------------------------------------------------------------------------