[t:3894] merging 3894 to main. added a fix, a test, and updated the header for...

[t:3894] merging 3894 to main. added a fix, a test, and updated the header for row_size_supported. also reformatted some really messy code in make_db_h.c


git-svn-id: file:///svn/toku/tokudb@39075 c7de825b-a66e-492c-adef-691d508d4ae1

buildheader/db.h_4_1

@@ -546,7 +546,7 @@ struct __toku_db {
   int (*pre_acquire_fileops_shared_lock)(DB*, DB_TXN*);
   const DBT* (*dbt_pos_infty)(void) /* Return the special DBT that refers to positive infinity in the lock table.*/;
   const DBT* (*dbt_neg_infty)(void)/* Return the special DBT that refers to negative infinity in the lock table.*/;
-  int (*row_size_supported) (DB*, u_int32_t) /* Test whether a row size is supported. */;
+  int (*row_size_supported) (DB *, uint32_t key_size, uint32_t val_size) /* Test whether a row with the given key size and value size is supported. */;
   DESCRIPTOR descriptor /* saved row/dictionary descriptor for aiding in comparisons */;
   int (*change_descriptor) (DB*, DB_TXN*, const DBT* descriptor, u_int32_t) /* change row/dictionary descriptor for a db.  Available only while db is open */;
   int (*getf_set)(DB*, DB_TXN*, u_int32_t, DBT*, YDB_CALLBACK_FUNCTION, void*) /* same as DBC->c_getf_set without a persistent cursor) */;

buildheader/db.h_4_3

@@ -556,7 +556,7 @@ struct __toku_db {
   int (*pre_acquire_fileops_shared_lock)(DB*, DB_TXN*);
   const DBT* (*dbt_pos_infty)(void) /* Return the special DBT that refers to positive infinity in the lock table.*/;
   const DBT* (*dbt_neg_infty)(void)/* Return the special DBT that refers to negative infinity in the lock table.*/;
-  int (*row_size_supported) (DB*, u_int32_t) /* Test whether a row size is supported. */;
+  int (*row_size_supported) (DB *, uint32_t key_size, uint32_t val_size) /* Test whether a row with the given key size and value size is supported. */;
   DESCRIPTOR descriptor /* saved row/dictionary descriptor for aiding in comparisons */;
   int (*change_descriptor) (DB*, DB_TXN*, const DBT* descriptor, u_int32_t) /* change row/dictionary descriptor for a db.  Available only while db is open */;
   int (*getf_set)(DB*, DB_TXN*, u_int32_t, DBT*, YDB_CALLBACK_FUNCTION, void*) /* same as DBC->c_getf_set without a persistent cursor) */;

buildheader/db.h_4_4

@@ -558,7 +558,7 @@ struct __toku_db {
   int (*pre_acquire_fileops_shared_lock)(DB*, DB_TXN*);
   const DBT* (*dbt_pos_infty)(void) /* Return the special DBT that refers to positive infinity in the lock table.*/;
   const DBT* (*dbt_neg_infty)(void)/* Return the special DBT that refers to negative infinity in the lock table.*/;
-  int (*row_size_supported) (DB*, u_int32_t) /* Test whether a row size is supported. */;
+  int (*row_size_supported) (DB *, uint32_t key_size, uint32_t val_size) /* Test whether a row with the given key size and value size is supported. */;
   DESCRIPTOR descriptor /* saved row/dictionary descriptor for aiding in comparisons */;
   int (*change_descriptor) (DB*, DB_TXN*, const DBT* descriptor, u_int32_t) /* change row/dictionary descriptor for a db.  Available only while db is open */;
   int (*getf_set)(DB*, DB_TXN*, u_int32_t, DBT*, YDB_CALLBACK_FUNCTION, void*) /* same as DBC->c_getf_set without a persistent cursor) */;

buildheader/db.h_4_5

@@ -558,7 +558,7 @@ struct __toku_db {
   int (*pre_acquire_fileops_shared_lock)(DB*, DB_TXN*);
   const DBT* (*dbt_pos_infty)(void) /* Return the special DBT that refers to positive infinity in the lock table.*/;
   const DBT* (*dbt_neg_infty)(void)/* Return the special DBT that refers to negative infinity in the lock table.*/;
-  int (*row_size_supported) (DB*, u_int32_t) /* Test whether a row size is supported. */;
+  int (*row_size_supported) (DB *, uint32_t key_size, uint32_t val_size) /* Test whether a row with the given key size and value size is supported. */;
   DESCRIPTOR descriptor /* saved row/dictionary descriptor for aiding in comparisons */;
   int (*change_descriptor) (DB*, DB_TXN*, const DBT* descriptor, u_int32_t) /* change row/dictionary descriptor for a db.  Available only while db is open */;
   int (*getf_set)(DB*, DB_TXN*, u_int32_t, DBT*, YDB_CALLBACK_FUNCTION, void*) /* same as DBC->c_getf_set without a persistent cursor) */;

buildheader/db.h_4_6

@@ -561,7 +561,7 @@ struct __toku_db {
   int (*pre_acquire_fileops_shared_lock)(DB*, DB_TXN*);
   const DBT* (*dbt_pos_infty)(void) /* Return the special DBT that refers to positive infinity in the lock table.*/;
   const DBT* (*dbt_neg_infty)(void)/* Return the special DBT that refers to negative infinity in the lock table.*/;
-  int (*row_size_supported) (DB*, u_int32_t) /* Test whether a row size is supported. */;
+  int (*row_size_supported) (DB *, uint32_t key_size, uint32_t val_size) /* Test whether a row with the given key size and value size is supported. */;
   DESCRIPTOR descriptor /* saved row/dictionary descriptor for aiding in comparisons */;
   int (*change_descriptor) (DB*, DB_TXN*, const DBT* descriptor, u_int32_t) /* change row/dictionary descriptor for a db.  Available only while db is open */;
   int (*getf_set)(DB*, DB_TXN*, u_int32_t, DBT*, YDB_CALLBACK_FUNCTION, void*) /* same as DBC->c_getf_set without a persistent cursor) */;

buildheader/tdb.h

@@ -530,7 +530,7 @@ struct __toku_db {
   int (*pre_acquire_fileops_shared_lock)(DB*, DB_TXN*);
   const DBT* (*dbt_pos_infty)(void) /* Return the special DBT that refers to positive infinity in the lock table.*/;
   const DBT* (*dbt_neg_infty)(void)/* Return the special DBT that refers to negative infinity in the lock table.*/;
-  int (*row_size_supported) (DB*, u_int32_t) /* Test whether a row size is supported. */;
+  int (*row_size_supported) (DB *, uint32_t key_size, uint32_t val_size) /* Test whether a row with the given key size and value size is supported. */;
   DESCRIPTOR descriptor /* saved row/dictionary descriptor for aiding in comparisons */;
   int (*change_descriptor) (DB*, DB_TXN*, const DBT* descriptor, u_int32_t) /* change row/dictionary descriptor for a db.  Available only while db is open */;
   int (*getf_set)(DB*, DB_TXN*, u_int32_t, DBT*, YDB_CALLBACK_FUNCTION, void*) /* same as DBC->c_getf_set without a persistent cursor) */;

include/db.h

@@ -530,7 +530,7 @@ struct __toku_db {
   int (*pre_acquire_fileops_shared_lock)(DB*, DB_TXN*);
   const DBT* (*dbt_pos_infty)(void) /* Return the special DBT that refers to positive infinity in the lock table.*/;
   const DBT* (*dbt_neg_infty)(void)/* Return the special DBT that refers to negative infinity in the lock table.*/;
-  int (*row_size_supported) (DB*, u_int32_t) /* Test whether a row size is supported. */;
+  int (*row_size_supported) (DB *, uint32_t key_size, uint32_t val_size) /* Test whether a row with the given key size and value size is supported. */;
   DESCRIPTOR descriptor /* saved row/dictionary descriptor for aiding in comparisons */;
   int (*change_descriptor) (DB*, DB_TXN*, const DBT* descriptor, u_int32_t) /* change row/dictionary descriptor for a db.  Available only while db is open */;
   int (*getf_set)(DB*, DB_TXN*, u_int32_t, DBT*, YDB_CALLBACK_FUNCTION, void*) /* same as DBC->c_getf_set without a persistent cursor) */;

src/tests/Makefile

@@ -278,6 +278,7 @@ BDB_DONTRUN_TESTS = \
 	test_query \
 	test_rand_insert_mult_db \
 	test_redirect_func \
+	test_row_size_supported \
 	test_stress1 \
 	test_stress2 \
 	test_stress3 \

src/tests/test_row_size_supported.c

+#include "test.h"
+
+int test_main(int argc, char * const argv[])
+{
+    int r;
+    DB * db;
+    DB_ENV * db_env;
+    (void) argc;
+    (void) argv;
+
+    char buf[200];
+    snprintf(buf, 200, "rm -rf " ENVDIR);
+    r = system(buf); CHK(r);
+    r = toku_os_mkdir(ENVDIR, 0755); CHK(r);
+
+    // set things up
+    r = db_env_create(&db_env, 0); CHK(r);
+    r = db_env->open(db_env, ENVDIR, DB_CREATE|DB_INIT_MPOOL|DB_PRIVATE, 0755); CHK(r);
+    r = db_create(&db, db_env, 0); CHK(r);
+    r = db->open(db, NULL, "db", NULL, DB_BTREE, DB_CREATE, 0644); CHK(r);
+
+    // - does not test low bounds, so a 0 byte key is "okay"
+    // - assuming 32k keys and 32mb values are the max
+    r = db->row_size_supported(db, 0, 0);
+    assert(r == 0);
+    r = db->row_size_supported(db, 100000000, 100000000);
+    assert(r != 0);
+    r = db->row_size_supported(db, 100, 1);
+    assert(r == 0);
+    r = db->row_size_supported(db, 1, 100);
+    assert(r == 0);
+    r = db->row_size_supported(db, 4*1024, 4*1024*1024);
+    assert(r == 0);
+    r = db->row_size_supported(db, 32*1024, 32*1024*1024);
+    assert(r == 0);
+    r = db->row_size_supported(db, 32*1024 + 1, 32*1024*1024 + 1);
+    assert(r != 0);
+
+    // clean things up
+    r = db->close(db, 0); CHK(r);
+    r = db_env->close(db_env, 0); CHK(r);
+
+    return 0;
+}

src/ydb.c

@@ -5005,39 +5005,45 @@ db_open_iname(DB * db, DB_TXN * txn, const char *iname_in_env, u_int32_t flags,
     return r;
 }
 
-//Return 0 if proposed pair do not violate size constraints of DB
-//(insertion is legal)
-//Return non zero otherwise.
+// Return 0 if proposed pair do not violate size constraints of DB
+// (insertion is legal)
+// Return non zero otherwise.
 static int
 db_put_check_size_constraints(DB *db, const DBT *key, const DBT *val) {
-    unsigned int klimit, vlimit;
     int r = 0;
+    unsigned int klimit, vlimit;
+
     toku_brt_get_maximum_advised_key_value_lengths(&klimit, &vlimit);
-    if (key->size > klimit)
-	r = toku_ydb_do_error(db->dbenv, EINVAL, "The largest key allowed is %u bytes", klimit);
-    else if (val->size > vlimit)
-	r = toku_ydb_do_error(db->dbenv, EINVAL, "The largest value allowed is %u bytes", vlimit);
-    
+    if (key->size > klimit) {
+        r = toku_ydb_do_error(db->dbenv, EINVAL, 
+                "The largest key allowed is %u bytes", klimit);
+    } else if (val->size > vlimit) {
+        r = toku_ydb_do_error(db->dbenv, EINVAL, 
+                "The largest value allowed is %u bytes", vlimit);
+    }
     return r;
 }
 
-//Return 0 if supported.
-//Return ERANGE if out of range.
+// Return 0 if supported.
+// Return ERANGE if out of range.
 static int
-db_row_size_supported(DB *db, u_int32_t size) {
+db_row_size_supported(DB *db, uint32_t key_size, uint32_t val_size) {
+    int r = 0;
     DBT key, val;
 
-    toku_fill_dbt(&key, NULL, size);
-    toku_fill_dbt(&val, NULL, 0);
-    int r = db_put_check_size_constraints(db, &key, &val);
-    if (r!=0) r = ERANGE;
+    toku_fill_dbt(&key, NULL, key_size);
+    toku_fill_dbt(&val, NULL, val_size);
+    r = db_put_check_size_constraints(db, &key, &val);
+    if (r != 0) {
+        r = ERANGE;
+    }
     return r;
 }
 
 static int
-locked_db_row_size_supported(DB *db, u_int32_t size) {
+locked_db_row_size_supported(DB *db, uint32_t key_size, uint32_t val_size) {
     toku_ydb_lock();
-    int r = db_row_size_supported(db, size);
+    int r = db_row_size_supported(db, key_size, val_size);
     toku_ydb_unlock();
     return r;
 }