diff options
Diffstat (limited to 'examples/java/com/wiredtiger')
| -rw-r--r-- | examples/java/com/wiredtiger/examples/ex_access.java | 25 | ||||
| -rw-r--r-- | examples/java/com/wiredtiger/examples/ex_all.java | 1009 | ||||
| -rw-r--r-- | examples/java/com/wiredtiger/examples/ex_async.java | 222 | ||||
| -rw-r--r-- | examples/java/com/wiredtiger/examples/ex_call_center.java | 299 | ||||
| -rw-r--r-- | examples/java/com/wiredtiger/examples/ex_cursor.java | 239 | ||||
| -rw-r--r-- | examples/java/com/wiredtiger/examples/ex_log.java | 376 | ||||
| -rw-r--r-- | examples/java/com/wiredtiger/examples/ex_schema.java | 333 | ||||
| -rw-r--r-- | examples/java/com/wiredtiger/examples/ex_stat.java | 252 | ||||
| -rw-r--r-- | examples/java/com/wiredtiger/examples/ex_thread.java | 142 |
9 files changed, 2897 insertions, 0 deletions
diff --git a/examples/java/com/wiredtiger/examples/ex_access.java b/examples/java/com/wiredtiger/examples/ex_access.java index 368f16d32bf..d4046495df5 100644 --- a/examples/java/com/wiredtiger/examples/ex_access.java +++ b/examples/java/com/wiredtiger/examples/ex_access.java @@ -32,24 +32,45 @@ import com.wiredtiger.db.*; public class ex_access { public static void main(String[] args) { + /*! [access example connection] */ Connection conn; Session s; Cursor c; + try { conn = wiredtiger.open("WT_HOME", "create"); s = conn.open_session(null); + } catch (WiredTigerException wte) { + System.err.println("WiredTigerException: " + wte); + return; + } + /*! [access example connection] */ + try { + /*! [access example table create] */ s.create("table:t", "key_format=S,value_format=u"); + /*! [access example table create] */ + /*! [access example cursor open] */ c = s.open_cursor("table:t", null, null); + /*! [access example cursor open] */ } catch (WiredTigerException wte) { System.err.println("WiredTigerException: " + wte); return; } System.out.println("Key format: " + c.getKeyFormat()); System.out.println("Value format: " + c.getValueFormat()); + /*! [access example cursor insert] */ try { c.putKeyString("foo"); c.putValueByteArray("bar".getBytes()); c.insert(); + } catch (WiredTigerPackingException wtpe) { + System.err.println("WiredTigerPackingException: " + wtpe); + } catch (WiredTigerException wte) { + System.err.println("WiredTigerException: " + wte); + } + /*! [access example cursor insert] */ + /*! [access example cursor list] */ + try { c.reset(); while (c.next() == 0) { System.out.println("Got: " + c.getKeyString()); @@ -59,10 +80,14 @@ public class ex_access { } catch (WiredTigerException wte) { System.err.println("WiredTigerException: " + wte); } + /*! [access example cursor list] */ + + /*! [access example close] */ try { conn.close(null); } catch (WiredTigerException wte) { System.err.println("WiredTigerException: " + wte); } + /*! [access example close] */ } } diff --git a/examples/java/com/wiredtiger/examples/ex_all.java b/examples/java/com/wiredtiger/examples/ex_all.java new file mode 100644 index 00000000000..a0a2e2cdc6a --- /dev/null +++ b/examples/java/com/wiredtiger/examples/ex_all.java @@ -0,0 +1,1009 @@ +/*- + * Public Domain 2008-2014 WiredTiger, Inc. + * + * This is free and unencumbered software released into the public domain. + * + * Anyone is free to copy, modify, publish, use, compile, sell, or + * distribute this software, either in source code form or as a compiled + * binary, for any purpose, commercial or non-commercial, and by any + * means. + * + * In jurisdictions that recognize copyright laws, the author or authors + * of this software dedicate any and all copyright interest in the + * software to the public domain. We make this dedication for the benefit + * of the public at large and to the detriment of our heirs and + * successors. We intend this dedication to be an overt act of + * relinquishment in perpetuity of all present and future rights to this + * software under copyright law. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * ex_all.java + * Containing a call to every method in the WiredTiger API. + * + * It doesn't do anything very useful, just demonstrates how to call each + * method. This file is used to populate the API reference with code + * fragments. + */ +package com.wiredtiger.examples; +import com.wiredtiger.db.*; +import java.io.*; +import java.nio.*; + +/* Note: indentation in non-standard so it will display nicely in doc. */ +public class ex_all { + +public static String progname = "ex_all"; + +public static int cursor_ops(Session session) + throws WiredTigerException +{ + Cursor cursor; + int ret; + + /*! [Open a cursor] */ + cursor = session.open_cursor("table:mytable", null, null); + /*! [Open a cursor] */ + + /*! [Open a cursor on the metadata] */ + cursor = session.open_cursor("metadata:", null, null); + /*! [Open a cursor on the metadata] */ + + { + Cursor duplicate; + String key = "some key"; + /*! [Duplicate a cursor] */ + cursor = session.open_cursor("table:mytable", null, null); + cursor.putKeyString(key); + ret = cursor.search(); + + /* Duplicate the cursor. */ + duplicate = session.open_cursor(null, cursor, null); + /*! [Duplicate a cursor] */ + } + + { + Cursor overwrite_cursor; + String key = "some key", value = "some value"; + /*! [Reconfigure a cursor] */ + cursor = session.open_cursor("table:mytable", null, null); + cursor.putKeyString(key); + + /* Reconfigure the cursor to overwrite the record. */ + overwrite_cursor = session.open_cursor(null, cursor, "overwrite"); + ret = cursor.close(); + + overwrite_cursor.putValueString(value); + ret = overwrite_cursor.insert(); + /*! [Reconfigure a cursor] */ + } + + { + /*! [boolean configuration string example] */ + cursor = session.open_cursor("table:mytable", null, "overwrite"); + cursor = session.open_cursor("table:mytable", null, "overwrite=true"); + cursor = session.open_cursor("table:mytable", null, "overwrite=1"); + /*! [boolean configuration string example] */ + } + + { + /*! [open a named checkpoint] */ + cursor = session.open_cursor("table:mytable", null, "checkpoint=midnight"); + /*! [open a named checkpoint] */ + } + + { + /*! [open the default checkpoint] */ + cursor = session.open_cursor("table:mytable", null, + "checkpoint=WiredTigerCheckpoint"); + /*! [open the default checkpoint] */ + } + + { + /*! [Get the cursor's string key] */ + String key; /* Get the cursor's string key. */ + key = cursor.getKeyString(); + /*! [Get the cursor's string key] */ + } + + { + /*! [Set the cursor's string key] */ + /* Set the cursor's string key. */ + String key = "another key"; + cursor.putKeyString(key); + /*! [Set the cursor's string key] */ + } + + { + /*! [Get the cursor's record number key] */ + long recno; /* Get the cursor's record number key. */ + recno = cursor.getKeyLong(); + /*! [Get the cursor's record number key] */ + } + + { + /*! [Set the cursor's record number key] */ + long recno = 37; /* Set the cursor's record number key. */ + cursor.putKeyLong(recno); + /*! [Set the cursor's record number key] */ + } + + { + /*! [Get the cursor's composite key] */ + /* Get the cursor's "SiH" format composite key. */ + String first; + int second; + short third; + + first = cursor.getKeyString(); + second = cursor.getKeyInt(); + third = cursor.getKeyShort(); + /*! [Get the cursor's composite key] */ + } + + { + /*! [Set the cursor's composite key] */ + /* Set the cursor's "SiH" format composite key. */ + cursor.putKeyString("first"); + cursor.putKeyInt(5); + cursor.putKeyShort((short)7); + /*! [Set the cursor's composite key] */ + } + + { + /*! [Get the cursor's string value] */ + String value; /* Get the cursor's string value. */ + value = cursor.getValueString(); + /*! [Get the cursor's string value] */ + } + + { + /*! [Set the cursor's string value] */ + /* Set the cursor's string value. */ + String value = "another value"; + cursor.putValueString(value); + /*! [Set the cursor's string value] */ + } + + { + /*! [Get the cursor's raw value] */ + byte[] value; /* Get the cursor's raw value. */ + value = cursor.getValueByteArray(); + /*! [Get the cursor's raw value] */ + } + + { + /*! [Set the cursor's raw value] */ + byte[] value; /* Set the cursor's raw value. */ + value = "another value".getBytes(); + cursor.putValueByteArray(value); + /*! [Set the cursor's raw value] */ + } + + /*! [Return the next record] */ + ret = cursor.next(); + /*! [Return the next record] */ + + /*! [Return the previous record] */ + ret = cursor.prev(); + /*! [Return the previous record] */ + + /*! [Reset the cursor] */ + ret = cursor.reset(); + /*! [Reset the cursor] */ + + { + Cursor other = null; + /*! [Cursor comparison] */ + int compare; + compare = cursor.compare(other); + if (compare == 0) { + /* Cursors reference the same key */ + } else if (compare < 0) { + /* Cursor key less than other key */ + } else if (compare > 0) { + /* Cursor key greater than other key */ + } + /*! [Cursor comparison] */ + } + + { + /*! [Search for an exact match] */ + String key = "some key"; + cursor.putKeyString(key); + ret = cursor.search(); + /*! [Search for an exact match] */ + } + + cursor_search_near(cursor); + + { + /*! [Insert a new record or overwrite an existing record] */ + /* Insert a new record or overwrite an existing record. */ + String key = "some key", value = "some value"; + cursor = session.open_cursor("table:mytable", null, null); + cursor.putKeyString(key); + cursor.putValueString(value); + ret = cursor.insert(); + /*! [Insert a new record or overwrite an existing record] */ + } + + { + /*! [Insert a new record and fail if the record exists] */ + /* Insert a new record and fail if the record exists. */ + String key = "some key", value = "some value"; + cursor = session.open_cursor("table:mytable", null, "overwrite=false"); + cursor.putKeyString(key); + cursor.putValueString(value); + ret = cursor.insert(); + /*! [Insert a new record and fail if the record exists] */ + } + + { + /*! [Insert a new record and assign a record number] */ + /* Insert a new record and assign a record number. */ + long recno; + String value = "some value"; + cursor = session.open_cursor("table:mytable", null, "append"); + cursor.putValueString(value); + ret = cursor.insert(); + if (ret == 0) + recno = cursor.getKeyLong(); + /*! [Insert a new record and assign a record number] */ + } + + { + /*! [Update an existing record or insert a new record] */ + String key = "some key", value = "some value"; + cursor = session.open_cursor("table:mytable", null, null); + cursor.putKeyString(key); + cursor.putValueString(value); + ret = cursor.update(); + /*! [Update an existing record or insert a new record] */ + } + + { + /*! [Update an existing record and fail if DNE] */ + String key = "some key", value = "some value"; + cursor = session.open_cursor("table:mytable", null, "overwrite=false"); + cursor.putKeyString(key); + cursor.putValueString(value); + ret = cursor.update(); + /*! [Update an existing record and fail if DNE] */ + } + + { + /*! [Remove a record] */ + String key = "some key"; + cursor = session.open_cursor("table:mytable", null, null); + cursor.putKeyString(key); + ret = cursor.remove(); + /*! [Remove a record] */ + } + + { + /*! [Remove a record and fail if DNE] */ + String key = "some key"; + cursor = session.open_cursor("table:mytable", null, "overwrite=false"); + cursor.putKeyString(key); + ret = cursor.remove(); + /*! [Remove a record and fail if DNE] */ + } + + { + /*! [Display an error] */ + try { + String key = "non-existent key"; + cursor.putKeyString(key); + if ((ret = cursor.remove()) != 0) { + System.err.println( + "cursor.remove: " + wiredtiger.wiredtiger_strerror(ret)); + return (ret); + } + } catch (WiredTigerException wte) { /* Catch severe errors. */ + System.err.println("cursor.remove exception: " + wte); + } + /*! [Display an error] */ + } + + /*! [Close the cursor] */ + ret = cursor.close(); + /*! [Close the cursor] */ + + return (ret); +} + +static int +cursor_search_near(Cursor cursor) + throws WiredTigerException +{ + int ret; + String key = "some key"; + SearchStatus status; + + /*! [Search for an exact or adjacent match] */ + cursor.putKeyString(key); + status = cursor.search_near(); + if (status == SearchStatus.FOUND) { + /* an exact match */ + } else if (status == SearchStatus.SMALLER) { + /* returned smaller key */ + } else if (status == SearchStatus.LARGER) { + /* returned larger key */ + } else if (status == SearchStatus.NOTFOUND) { + /* no match found */ + } + /*! [Search for an exact or adjacent match] */ + + /*! [Forward scan greater than or equal] */ + cursor.putKeyString(key); + status = cursor.search_near(); + if (status == SearchStatus.FOUND || status == SearchStatus.LARGER) { + /* include first key returned in the scan */ + } + + while ((ret = cursor.next()) == 0) { + /* the rest of the scan */ + } + /*! [Forward scan greater than or equal] */ + + /*! [Backward scan less than] */ + cursor.putKeyString(key); + status = cursor.search_near(); + if (status == SearchStatus.SMALLER) { + /* include first key returned in the scan */ + } + + while ((ret = cursor.prev()) == 0) { + /* the rest of the scan */ + } + /*! [Backward scan less than] */ + + return (ret); +} + +static int +checkpoint_ops(Session session) + throws WiredTigerException +{ + int ret; + + /*! [Checkpoint examples] */ + /* Checkpoint the database. */ + ret = session.checkpoint(null); + + /* Checkpoint of the database, creating a named snapshot. */ + ret = session.checkpoint("name=June01"); + + /* + * Checkpoint a list of objects. + * JSON parsing requires quoting the list of target URIs. + */ + ret = session. + checkpoint("target=(\"table:table1\",\"table:table2\")"); + + /* + * Checkpoint a list of objects, creating a named snapshot. + * JSON parsing requires quoting the list of target URIs. + */ + ret = session. + checkpoint("target=(\"table:mytable\"),name=midnight"); + + /* Checkpoint the database, discarding all previous snapshots. */ + ret = session.checkpoint("drop=(from=all)"); + + /* Checkpoint the database, discarding the "midnight" snapshot. */ + ret = session.checkpoint("drop=(midnight)"); + + /* + * Checkpoint the database, discarding all snapshots after and + * including "noon". + */ + ret = session.checkpoint("drop=(from=noon)"); + + /* + * Checkpoint the database, discarding all snapshots before and + * including "midnight". + */ + ret = session.checkpoint("drop=(to=midnight)"); + + /* + * Create a checkpoint of a table, creating the "July01" snapshot and + * discarding the "May01" and "June01" snapshots. + * JSON parsing requires quoting the list of target URIs. + */ + ret = session.checkpoint("target=(\"table:mytable\"),name=July01,drop=(May01,June01)"); + /*! [Checkpoint examples] */ + + /*! [JSON quoting example] */ + /* + * Checkpoint a list of objects. + * JSON parsing requires quoting the list of target URIs. + */ + ret = session. + checkpoint("target=(\"table:table1\",\"table:table2\")"); + /*! [JSON quoting example] */ + + return (ret); +} + +static boolean +cursor_statistics(Session session) + throws WiredTigerException +{ + Cursor cursor; + + /*! [Statistics cursor database] */ + cursor = session.open_cursor( + "statistics:", null, null); + /*! [Statistics cursor database] */ + + /*! [Statistics cursor table] */ + cursor = session.open_cursor( + "statistics:table:mytable", null, null); + /*! [Statistics cursor table] */ + + /*! [Statistics cursor table fast] */ + cursor = session.open_cursor("statistics:table:mytable", null, "statistics=(fast)"); + /*! [Statistics cursor table fast] */ + + /*! [Statistics clear configuration] */ + cursor = session.open_cursor("statistics:", null, "statistics=(fast,clear)"); + /*! [Statistics clear configuration] */ + + /*! [Statistics cursor clear configuration] */ + cursor = session.open_cursor("statistics:table:mytable", + null, "statistics=(all,clear)"); + /*! [Statistics cursor clear configuration] */ + + return (true); +} + +static int +session_ops(Session session) + throws WiredTigerException +{ + int ret; + + /*! [Reconfigure a session] */ + ret = session.reconfigure("isolation=snapshot"); + /*! [Reconfigure a session] */ + + /*! [Create a table] */ + ret = session.create("table:mytable", "key_format=S,value_format=S"); + /*! [Create a table] */ + ret = session.drop("table:mytable", null); + + /*! [Create a column-store table] */ + ret = session.create("table:mytable", "key_format=r,value_format=S"); + /*! [Create a column-store table] */ + ret = session.drop("table:mytable", null); + + /*! [Create a table with columns] */ + /* + * Create a table with columns: keys are record numbers, values are + * (string, signed 32-bit integer, unsigned 16-bit integer). + */ + ret = session.create("table:mytable", + "key_format=r,value_format=SiH," + + "columns=(id,department,salary,year-started)"); + /*! [Create a table with columns] */ + ret = session.drop("table:mytable", null); + + /* + * This example code gets run, and the compression libraries might not + * be loaded, causing the create to fail. The documentation requires + * the code snippets, use if (false) to avoid running it. + */ + if (false) { // MIGHT_NOT_RUN + /*! [Create a bzip2 compressed table] */ + ret = session.create("table:mytable", + "block_compressor=bzip2,key_format=S,value_format=S"); + /*! [Create a bzip2 compressed table] */ + ret = session.drop("table:mytable", null); + + /*! [Create a snappy compressed table] */ + ret = session.create("table:mytable", + "block_compressor=snappy,key_format=S,value_format=S"); + /*! [Create a snappy compressed table] */ + ret = session.drop("table:mytable", null); + + /*! [Create a zlib compressed table] */ + ret = session.create("table:mytable", + "block_compressor=zlib,key_format=S,value_format=S"); + /*! [Create a zlib compressed table] */ + ret = session.drop("table:mytable", null); + } // if (false) + + /*! [Configure checksums to uncompressed] */ + ret = session.create("table:mytable", + "key_format=S,value_format=S,checksum=uncompressed"); + /*! [Configure checksums to uncompressed] */ + ret = session.drop("table:mytable", null); + + /*! [Configure dictionary compression on] */ + ret = session.create("table:mytable", + "key_format=S,value_format=S,dictionary=1000"); + /*! [Configure dictionary compression on] */ + ret = session.drop("table:mytable", null); + + /*! [Configure key prefix compression on] */ + ret = session.create("table:mytable", + "key_format=S,value_format=S,prefix_compression=true"); + /*! [Configure key prefix compression on] */ + ret = session.drop("table:mytable", null); + + if (false) { // MIGHT_NOT_RUN + /* Requires sync_file_range */ + /*! [os_cache_dirty_max configuration] */ + ret = session.create( + "table:mytable", "os_cache_dirty_max=500MB"); + /*! [os_cache_dirty_max configuration] */ + ret = session.drop("table:mytable", null); + + /* Requires posix_fadvise */ + /*! [os_cache_max configuration] */ + ret = session.create("table:mytable", "os_cache_max=1GB"); + /*! [os_cache_max configuration] */ + ret = session.drop("table:mytable", null); + } // if (false) + + /*! [Configure block_allocation] */ + ret = session.create("table:mytable", + "key_format=S,value_format=S,block_allocation=first"); + /*! [Configure block_allocation] */ + ret = session.drop("table:mytable", null); + + /*! [Create a cache-resident object] */ + ret = session.create("table:mytable", "key_format=r,value_format=S,cache_resident=true"); + /*! [Create a cache-resident object] */ + ret = session.drop("table:mytable", null); + + { + /* Create a table for the session operations. */ + ret = session.create( + "table:mytable", "key_format=S,value_format=S"); + + /*! [Compact a table] */ + ret = session.compact("table:mytable", null); + /*! [Compact a table] */ + + /*! [Rename a table] */ + ret = session.rename("table:old", "table:new", null); + /*! [Rename a table] */ + + /*! [Salvage a table] */ + ret = session.salvage("table:mytable", null); + /*! [Salvage a table] */ + + /*! [Truncate a table] */ + ret = session.truncate("table:mytable", null, null, null); + /*! [Truncate a table] */ + + { + /* + * Insert a pair of keys so we can truncate a range. + */ + Cursor cursor; + cursor = session.open_cursor( + "table:mytable", null, null); + cursor.putKeyString("June01"); + cursor.putValueString("value"); + ret = cursor.update(); + cursor.putKeyString("June30"); + cursor.putValueString("value"); + ret = cursor.update(); + cursor.close(); + + { + /*! [Truncate a range] */ + Cursor start, stop; + + start = session.open_cursor( + "table:mytable", null, null); + start.putKeyString("June01"); + ret = start.search(); + + stop = session.open_cursor( + "table:mytable", null, null); + stop.putKeyString("June30"); + ret = stop.search(); + + ret = session.truncate(null, start, stop, null); + /*! [Truncate a range] */ + } + } + + /*! [Upgrade a table] */ + ret = session.upgrade("table:mytable", null); + /*! [Upgrade a table] */ + + /*! [Verify a table] */ + ret = session.verify("table:mytable", null); + /*! [Verify a table] */ + + /*! [Drop a table] */ + ret = session.drop("table:mytable", null); + /*! [Drop a table] */ + } + + /*! [Close a session] */ + ret = session.close(null); + /*! [Close a session] */ + + return (ret); +} + +static int +transaction_ops(Connection conn, Session session) + throws WiredTigerException +{ + Cursor cursor; + int ret; + + /*! [transaction commit/rollback] */ + cursor = session.open_cursor("table:mytable", null, null); + ret = session.begin_transaction(null); + /* + * Cursors may be opened before or after the transaction begins, and in + * either case, subsequent operations are included in the transaction. + * The begin_transaction call resets all open cursors. + */ + + cursor.putKeyString("key"); + cursor.putValueString("value"); + switch (ret = cursor.update()) { + case 0: /* Update success */ + ret = session.commit_transaction(null); + /* + * The commit_transaction call resets all open cursors. + * If commit_transaction fails, the transaction was rolled-back. + */ + break; + case wiredtiger.WT_DEADLOCK: /* Update conflict */ + default: /* Other error */ + ret = session.rollback_transaction(null); + /* The rollback_transaction call resets all open cursors. */ + break; + } + + /* Cursors remain open and may be used for multiple transactions. */ + /*! [transaction commit/rollback] */ + ret = cursor.close(); + + /*! [transaction isolation] */ + /* A single transaction configured for snapshot isolation. */ + cursor = session.open_cursor("table:mytable", null, null); + ret = session.begin_transaction("isolation=snapshot"); + cursor.putKeyString("some-key"); + cursor.putValueString("some-value"); + ret = cursor.update(); + ret = session.commit_transaction(null); + /*! [transaction isolation] */ + + /*! [session isolation configuration] */ + /* Open a session configured for read-uncommitted isolation. */ + session = conn.open_session( + "isolation=read_uncommitted"); + /*! [session isolation configuration] */ + + /*! [session isolation re-configuration] */ + /* Re-configure a session for snapshot isolation. */ + ret = session.reconfigure("isolation=snapshot"); + /*! [session isolation re-configuration] */ + + return (ret); +} + +/*! [Implement WT_COLLATOR] */ +/* Not available for java */ +/*! [Implement WT_COLLATOR] */ + +/*! [WT_EXTRACTOR] */ +/* Not available for java */ +/*! [WT_EXTRACTOR] */ + +static int +connection_ops(Connection conn) + throws WiredTigerException +{ + int ret; + + if (false) { // Might not run. + /*! [Load an extension] */ + ret = conn.load_extension("my_extension.dll", null); + + ret = conn.load_extension( + "datasource/libdatasource.so", + "config=[device=/dev/sd1,alignment=64]"); + /*! [Load an extension] */ + } // if (false) + + /*! [Reconfigure a connection] */ + ret = conn.reconfigure("eviction_target=75"); + /*! [Reconfigure a connection] */ + + /*! [Get the database home directory] */ + System.out.println("The database home is " + conn.get_home()); + /*! [Get the database home directory] */ + + /*! [Check if the database is newly created] */ + if (conn.is_new() != 0) { + /* First time initialization. */ + } + /*! [Check if the database is newly created] */ + + { + /*! [Open a session] */ + Session session; + session = conn.open_session(null); + /*! [Open a session] */ + + session_ops(session); + } + + /*! [Configure method configuration] */ + /* + * Applications opening a cursor for the data-source object "my_data" + * have an additional configuration option "entries", which is an + * integer type, defaults to 5, and must be an integer between 1 and 10. + */ + ret = conn.configure_method( + "session.open_cursor", + "my_data:", "entries=5", "int", "min=1,max=10"); + + /* + * Applications opening a cursor for the data-source object "my_data" + * have an additional configuration option "devices", which is a list + * of strings. + */ + ret = conn.configure_method( + "session.open_cursor", "my_data:", "devices", "list", null); + /*! [Configure method configuration] */ + + /*! [Close a connection] */ + ret = conn.close(null); + /*! [Close a connection] */ + + return (ret); +} + +static int +pack_ops(Session session) +{ + { + /*! [Get the packed size] */ + /* Not available for java */ + /*! [Get the packed size] */ + } + + { + /*! [Pack fields into a buffer] */ + /* Not available for java */ + /*! [Pack fields into a buffer] */ + } + + { + /*! [Unpack fields from a buffer] */ + /* Not available for java */ + /*! [Unpack fields from a buffer] */ + } + + return (0); +} + +static boolean +backup(Session session) + throws WiredTigerException +{ + char buf[] = new char[1024]; + + /*! [backup]*/ + Cursor cursor; + String filename; + int ret = 0; + String databasedir = "/path/database"; + String backdir = "/path/database.backup"; + final String sep = File.separator; + + try { + /* Create the backup directory. */ + if (!(new File(backdir)).mkdir()) { + System.err.println(progname + ": cannot create backup dir: " + + backdir); + return false; + } + + /* Open the backup data source. */ + cursor = session.open_cursor("backup:", null, null); + + /* Copy the list of files. */ + while ((ret = cursor.next()) == 0 && + (filename = cursor.getKeyString()) != null) { + String src = databasedir + sep + filename; + String dest = backdir + sep + filename; + java.nio.file.Files.copy( + new java.io.File(src).toPath(), + new java.io.File(dest).toPath(), + java.nio.file.StandardCopyOption.REPLACE_EXISTING, + java.nio.file.StandardCopyOption.COPY_ATTRIBUTES); + } + if (ret == wiredtiger.WT_NOTFOUND) + ret = 0; + if (ret != 0) + System.err.println(progname + + ": cursor next(backup:) failed: " + + wiredtiger.wiredtiger_strerror(ret)); + + ret = cursor.close(); + } + catch (Exception ex) { + System.err.println(progname + + ": backup failed: " + ex.toString()); + } + /*! [backup]*/ + + /*! [backup of a checkpoint]*/ + ret = session.checkpoint("drop=(from=June01),name=June01"); + /*! [backup of a checkpoint]*/ + + return (ret == 0); +} + +public static int +allExample() + throws WiredTigerException +{ + Connection conn; + int ret = 0; + String home = "/home/example/WT_TEST"; + + /*! [Open a connection] */ + conn = wiredtiger.open(home, "create,cache_size=500M"); + /*! [Open a connection] */ + + connection_ops(conn); + /* + * The connection has been closed. + */ + + if (false) { // MIGHT_NOT_RUN + /* + * This example code gets run, and the compression libraries might not + * be installed, causing the open to fail. The documentation requires + * the code snippets, use if (false) to avoid running it. + */ + /*! [Configure bzip2 extension] */ + conn = wiredtiger.open(home, + "create," + + "extensions=[/usr/local/lib/libwiredtiger_bzip2.so]"); + /*! [Configure bzip2 extension] */ + conn.close(null); + + /*! [Configure snappy extension] */ + conn = wiredtiger.open(home, + "create," + + "extensions=[/usr/local/lib/libwiredtiger_snappy.so]"); + /*! [Configure snappy extension] */ + conn.close(null); + + /*! [Configure zlib extension] */ + conn = wiredtiger.open(home, + "create," + + "extensions=[/usr/local/lib/libwiredtiger_zlib.so]"); + /*! [Configure zlib extension] */ + conn.close(null); + + /* + * This example code gets run, and direct I/O might not be available, + * causing the open to fail. The documentation requires code snippets, + * use if (false) to avoid running it. + */ + /* Might Not Run: direct I/O may not be available. */ + /*! [Configure direct_io for data files] */ + conn = wiredtiger.open(home, "create,direct_io=[data]"); + /*! [Configure direct_io for data files] */ + conn.close(null); + } // if (false) + + /*! [Configure file_extend] */ + conn = wiredtiger.open( + home, "create,file_extend=(data=16MB)"); + /*! [Configure file_extend] */ + conn.close(null); + + /*! [Eviction configuration] */ + /* + * Configure eviction to begin at 90% full, and run until the cache + * is only 75% dirty. + */ + conn = wiredtiger.open(home, + "create,eviction_trigger=90,eviction_dirty_target=75"); + /*! [Eviction configuration] */ + conn.close(null); + + /*! [Eviction worker configuration] */ + /* Configure up to four eviction threads */ + conn = wiredtiger.open(home, + "create,eviction_trigger=90,eviction=(threads_max=4)"); + /*! [Eviction worker configuration] */ + conn.close(null); + + /*! [Statistics configuration] */ + conn = wiredtiger.open(home, "create,statistics=(all)"); + /*! [Statistics configuration] */ + conn.close(null); + + /*! [Statistics logging] */ + conn = wiredtiger.open( + home, "create,statistics_log=(wait=30)"); + /*! [Statistics logging] */ + conn.close(null); + + /*! [Statistics logging with a table] */ + conn = wiredtiger.open(home, + "create," + + "statistics_log=(sources=(\"table:table1\",\"table:table2\"))"); + /*! [Statistics logging with a table] */ + conn.close(null); + + /*! [Statistics logging with all tables] */ + conn = wiredtiger.open(home, + "create,statistics_log=(sources=(\"table:\"))"); + /*! [Statistics logging with all tables] */ + conn.close(null); + + if (false) { // MIGHT_NOT_RUN + /* + * This example code gets run, and a non-existent log file path might + * cause the open to fail. The documentation requires code snippets, + * use if (false) to avoid running it. + */ + /*! [Statistics logging with path] */ + conn = wiredtiger.open(home, + "create," + + "statistics_log=(wait=120,path=/log/log.%m.%d.%y)"); + /*! [Statistics logging with path] */ + conn.close(null); + + /* + * Don't run this code, because memory checkers get very upset when we + * leak memory. + */ + conn = wiredtiger.open(home, "create"); + /*! [Connection close leaking memory] */ + ret = conn.close("leak_memory=true"); + /*! [Connection close leaking memory] */ + } // if (false) + + /*! [Get the WiredTiger library version #1] */ + /* Not available for java */ + /*! [Get the WiredTiger library version #1] */ + + { + /*! [Get the WiredTiger library version #2] */ + /* Not available for java */ + /*! [Get the WiredTiger library version #2] */ + } + + return (0); +} + +public static int +main(String[] argv) +{ + try { + return (allExample()); + } + catch (WiredTigerException wte) { + System.err.println("Exception: " + wte); + return (-1); + } +} +} /* Non-standard indentation */ diff --git a/examples/java/com/wiredtiger/examples/ex_async.java b/examples/java/com/wiredtiger/examples/ex_async.java new file mode 100644 index 00000000000..c6cb0550571 --- /dev/null +++ b/examples/java/com/wiredtiger/examples/ex_async.java @@ -0,0 +1,222 @@ +/*- + * Public Domain 2008-2014 WiredTiger, Inc. + * + * This is free and unencumbered software released into the public domain. + * + * Anyone is free to copy, modify, publish, use, compile, sell, or + * distribute this software, either in source code form or as a compiled + * binary, for any purpose, commercial or non-commercial, and by any + * means. + * + * In jurisdictions that recognize copyright laws, the author or authors + * of this software dedicate any and all copyright interest in the + * software to the public domain. We make this dedication for the benefit + * of the public at large and to the detriment of our heirs and + * successors. We intend this dedication to be an overt act of + * relinquishment in perpetuity of all present and future rights to this + * software under copyright law. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * ex_async.java + * demonstrates how to use the asynchronous API. + */ +package com.wiredtiger.examples; +import com.wiredtiger.db.*; +import java.io.*; +import java.util.*; + +/*! [async example callback implementation] */ +class AsyncKeys implements AsyncCallback { + + public int numKeys = 0; + + public AsyncKeys() {} + + public void notifyError(String desc) { + System.err.println("ERROR: notify: " + desc); + } + + public int notify(AsyncOp op, int opReturn, int flags) { + /* + * Note: we are careful not to throw any errors here. Any + * exceptions would be swallowed by a native worker thread. + */ + int ret = 0; + try { + /*! [async get type] */ + /* Retrieve the operation's type. */ + AsyncOpType optype = op.getType(); + /*! [async get type] */ + /*! [async get identifier] */ + /* Retrieve the operation's 64-bit identifier. */ + long id = op.getId(); + /*! [async get identifier] */ + + if (optype == AsyncOpType.WT_AOP_SEARCH) { + /*! [async get the operation's string key] */ + String key = op.getKeyString(); + /*! [async get the operation's string key] */ + /*! [async get the operation's string value] */ + String value = op.getValueString(); + /*! [async get the operation's string value] */ + synchronized (this) { + numKeys += 1; + } + System.out.println("Id " + id + " got record: " + key + + " : " + value); + } + else { + notifyError("unexpected optype"); + ret = 1; + } + } + catch (Exception e) { + System.err.println("ERROR: exception in notify: " + e.toString() + + ", opreturn=" + opReturn); + ret = 1; + } + return (ret); + } +} +/*! [async example callback implementation] */ + +public class ex_async { + + public static String home; + + public static final int MAX_KEYS = 15; + + public static AsyncOp tryAsyncNewOp(Connection conn, String uri, + String config, AsyncCallback cb) throws WiredTigerException + { + WiredTigerException savedwte = null; + + for (int tries = 0; tries < 10; tries++) + try { + return conn.async_new_op(uri, config, cb); + } + catch (WiredTigerException wte) { + /* + * If we used up all the handles, pause and retry to + * give the workers a chance to catch up. + */ + System.err.println( + "asynchronous operation handle not available: " + wte); + savedwte = wte; + try { + Thread.sleep(1); + } catch (InterruptedException ie) { + /* not a big problem, continue to retry */ + } + } + + throw savedwte; + } + + public static int + asyncExample() + throws WiredTigerException + { + AsyncOp op; + Connection conn; + Session session; + int i, ret; + String k[] = new String[MAX_KEYS]; + String v[] = new String[MAX_KEYS]; + + /*! [async example callback implementation part 2] */ + AsyncKeys asynciface = new AsyncKeys(); + /*! [async example callback implementation part 2] */ + + /*! [async example connection] */ + conn = wiredtiger.open(home, "create,cache_size=100MB," + + "async=(enabled=true,ops_max=20,threads=2)"); + /*! [async example connection] */ + + /*! [async example table create] */ + session = conn.open_session(null); + ret = session.create("table:async", "key_format=S,value_format=S"); + /*! [async example table create] */ + + /* Insert a set of keys asynchronously. */ + for (i = 0; i < MAX_KEYS; i++) { + /*! [async handle allocation] */ + op = tryAsyncNewOp(conn, "table:async", null, asynciface); + /*! [async handle allocation] */ + + /*! [async insert] */ + /* + * Set the operation's string key and value, and then do + * an asynchronous insert. + */ + /*! [async set the operation's string key] */ + k[i] = "key" + i; + op.putKeyString(k[i]); + /*! [async set the operation's string key] */ + + /*! [async set the operation's string value] */ + v[i] = "value" + i; + op.putValueString(v[i]); + /*! [async set the operation's string value] */ + + ret = op.insert(); + /*! [async insert] */ + } + + /*! [async flush] */ + /* Wait for all outstanding operations to complete. */ + ret = conn.async_flush(); + /*! [async flush] */ + + /*! [async compaction] */ + /* + * Compact a table asynchronously, limiting the run-time to 5 minutes. + */ + op = tryAsyncNewOp(conn, "table:async", "timeout=300", asynciface); + ret = op.compact(); + /*! [async compaction] */ + + /* Search for the keys we just inserted, asynchronously. */ + for (i = 0; i < MAX_KEYS; i++) { + op = tryAsyncNewOp(conn, "table:async", null, asynciface); + /*! [async search] */ + /* + * Set the operation's string key and value, and then do + * an asynchronous search. + */ + k[i] = "key" + i; + op.putKeyString(k[i]); + ret = op.search(); + /*! [async search] */ + } + + /* + * Connection close automatically does an async_flush so it will wait + * for all queued search operations to complete. + */ + ret = conn.close(null); + + System.out.println("Searched for " + asynciface.numKeys + " keys"); + + return (ret); + } + + public static int + main(String[] argv) + { + try { + return (asyncExample()); + } + catch (WiredTigerException wte) { + System.err.println("Exception: " + wte); + return (-1); + } + } +} diff --git a/examples/java/com/wiredtiger/examples/ex_call_center.java b/examples/java/com/wiredtiger/examples/ex_call_center.java new file mode 100644 index 00000000000..553f63612bd --- /dev/null +++ b/examples/java/com/wiredtiger/examples/ex_call_center.java @@ -0,0 +1,299 @@ +/*- + * Public Domain 2008-2014 WiredTiger, Inc. + * + * This is free and unencumbered software released into the public domain. + * + * Anyone is free to copy, modify, publish, use, compile, sell, or + * distribute this software, either in source code form or as a compiled + * binary, for any purpose, commercial or non-commercial, and by any + * means. + * + * In jurisdictions that recognize copyright laws, the author or authors + * of this software dedicate any and all copyright interest in the + * software to the public domain. We make this dedication for the benefit + * of the public at large and to the detriment of our heirs and + * successors. We intend this dedication to be an overt act of + * relinquishment in perpetuity of all present and future rights to this + * software under copyright law. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * ex_call_center.java + * This is an example application that demonstrates how to map a + * moderately complex SQL application into WiredTiger. + */ + +package com.wiredtiger.examples; +import com.wiredtiger.db.*; +import java.io.*; +import java.util.*; + +/*! [call-center decl] */ +/* + * In SQL, the tables are described as follows: + * + * CREATE TABLE Customers(id INTEGER PRIMARY KEY, + * name VARCHAR(30), address VARCHAR(50), phone VARCHAR(15)) + * CREATE INDEX CustomersPhone ON Customers(phone) + * + * CREATE TABLE Calls(id INTEGER PRIMARY KEY, call_date DATE, + * cust_id INTEGER, emp_id INTEGER, call_type VARCHAR(12), + * notes VARCHAR(25)) + * CREATE INDEX CallsCustDate ON Calls(cust_id, call_date) + * + * In this example, both tables will use record numbers for their IDs, which + * will be the key. The C structs for the records are as follows. + */ + +/* Customer records. */ +class Customer { + public long id; + public String name; + public String address; + public String phone; + public Customer(long id, String name, String address, String phone) { + this.id = id; + this.name = name; + this.address = address; + this.phone = phone; + } + public Customer() {} +} + +/* Call records. */ +class Call { + public long id; + public long call_date; + public long cust_id; + public long emp_id; + public String call_type; + public String notes; + public Call(long id, long call_date, long cust_id, long emp_id, + String call_type, String notes) { + this.id = id; + this.call_date = call_date; + this.cust_id = cust_id; + this.emp_id = emp_id; + this.call_type = call_type; + this.notes = notes; + } + public Call() {} +} +/*! [call-center decl] */ + +public class ex_call_center { + + public static String home; + + public static int + callCenterExample() + throws WiredTigerException + { + Connection conn; + Cursor cursor; + Session session; + int count, ret; + SearchStatus nearstatus; + List<Customer> custSample = new ArrayList<Customer>(); + List<Call> callSample = new ArrayList<Call>(); + + custSample.add(new Customer(0, "Professor Oak", + "LeafGreen Avenue", "123-456-7890")); + custSample.add(new Customer(0, "Lorelei", + "Sevii Islands", "098-765-4321")); + callSample.add(new Call(0, 32, 1, 2, "billing", "unavailable")); + callSample.add(new Call(0, 33, 1, 2, "billing", "available")); + callSample.add(new Call(0, 34, 1, 2, "reminder", "unavailable")); + callSample.add(new Call(0, 35, 1, 2, "reminder", "available")); + + /* + * Create a clean test directory for this run of the test program if the + * environment variable isn't already set (as is done by make check). + */ + if (System.getenv("WIREDTIGER_HOME") == null) { + home = "WT_HOME"; + try { + Process proc = Runtime.getRuntime().exec("/bin/rm -rf WT_HOME"); + BufferedReader br = new BufferedReader( + new InputStreamReader(proc.getInputStream())); + while(br.ready()) + System.out.println(br.readLine()); + br.close(); + new File("WT_HOME").mkdir(); + } catch (IOException ioe) { + System.err.println("IOException: WT_HOME: " + ioe); + return(1); + } + } else + home = null; + + try { + conn = wiredtiger.open(home, "create"); + session = conn.open_session(null); + } catch (WiredTigerException wte) { + System.err.println("WiredTigerException: " + wte); + return(1); + } + /* Note: further error checking omitted for clarity. */ + + /*! [call-center work] */ + /* + * Create the customers table, give names and types to the columns. + * The columns will be stored in two groups: "main" and "address", + * created below. + */ + ret = session.create("table:customers", + "key_format=r," + + "value_format=SSS," + + "columns=(id,name,address,phone)," + + "colgroups=(main,address)"); + + /* Create the main column group with value columns except address. */ + ret = session.create( + "colgroup:customers:main", "columns=(name,phone)"); + + /* Create the address column group with just the address. */ + ret = session.create( + "colgroup:customers:address", "columns=(address)"); + + /* Create an index on the customer table by phone number. */ + ret = session.create( + "index:customers:phone", "columns=(phone)"); + + /* Populate the customers table with some data. */ + cursor = session.open_cursor("table:customers", null, "append"); + for (Customer cust : custSample) { + cursor.putValueString(cust.name); + cursor.putValueString(cust.address); + cursor.putValueString(cust.phone); + ret = cursor.insert(); + } + ret = cursor.close(); + + /* + * Create the calls table, give names and types to the columns. All the + * columns will be stored together, so no column groups are declared. + */ + ret = session.create("table:calls", + "key_format=r," + + "value_format=qrrSS," + + "columns=(id,call_date,cust_id,emp_id,call_type,notes)"); + + /* + * Create an index on the calls table with a composite key of cust_id + * and call_date. + */ + ret = session.create("index:calls:cust_date", + "columns=(cust_id,call_date)"); + + /* Populate the calls table with some data. */ + cursor = session.open_cursor("table:calls", null, "append"); + for (Call call : callSample) { + cursor.putValueLong(call.call_date); + cursor.putValueLong(call.cust_id); + cursor.putValueLong(call.emp_id); + cursor.putValueString(call.call_type); + cursor.putValueString(call.notes); + ret = cursor.insert(); + } + ret = cursor.close(); + + /* + * First query: a call arrives. In SQL: + * + * SELECT id, name FROM Customers WHERE phone=? + * + * Use the cust_phone index, lookup by phone number to fill the + * customer record. The cursor will have a key format of "S" for a + * string because the cust_phone index has a single column ("phone"), + * which is of type "S". + * + * Specify the columns we want: the customer ID and the name. This + * means the cursor's value format will be "rS". + */ + cursor = session.open_cursor( + "index:customers:phone(id,name)", null, null); + cursor.putKeyString("123-456-7890"); + ret = cursor.search(); + if (ret == 0) { + Customer cust = new Customer(); + cust.id = cursor.getValueLong(); + cust.name = cursor.getValueString(); + System.out.println("Read customer record for " + cust.name + + " (ID " + cust.id + ")"); + } + ret = cursor.close(); + + /* + * Next query: get the recent order history. In SQL: + * + * SELECT * FROM Calls WHERE cust_id=? ORDER BY call_date DESC LIMIT 3 + * + * Use the call_cust_date index to find the matching calls. Since it is + * is in increasing order by date for a given customer, we want to start + * with the last record for the customer and work backwards. + * + * Specify a subset of columns to be returned. (Note that if these were + * all covered by the index, the primary would not have to be accessed.) + * Stop after getting 3 records. + */ + cursor = session.open_cursor( + "index:calls:cust_date(cust_id,call_type,notes)", + null, null); + + /* + * The keys in the index are (cust_id,call_date) -- we want the largest + * call date for a given cust_id. Search for (cust_id+1,0), then work + * backwards. + */ + long custid = 1; + cursor.putKeyLong(custid + 1); + cursor.putKeyLong(0); + nearstatus = cursor.search_near(); + + /* + * If the table is empty, search_near will return WT_NOTFOUND, else the + * cursor will be positioned on a matching key if one exists, or an + * adjacent key if one does not. If the positioned key is equal to or + * larger than the search key, go back one. + */ + if (ret == 0 && (nearstatus == SearchStatus.LARGER || + nearstatus == SearchStatus.FOUND)) + ret = cursor.prev(); + for (count = 0; ret == 0 && count < 3; ++count) { + Call call = new Call(); + call.cust_id = cursor.getValueLong(); + call.call_type = cursor.getValueString(); + call.notes = cursor.getValueString(); + if (call.cust_id != custid) + break; + System.out.println("Call record: customer " + call.cust_id + + " (" + call.call_type + + ": " + call.notes + ")"); + ret = cursor.prev(); + } + /*! [call-center work] */ + + ret = conn.close(null); + + return (ret); + } + + public static int + main(String[] argv) + { + try { + return (callCenterExample()); + } + catch (WiredTigerException wte) { + System.err.println("Exception: " + wte); + return (-1); + } + } +} diff --git a/examples/java/com/wiredtiger/examples/ex_cursor.java b/examples/java/com/wiredtiger/examples/ex_cursor.java new file mode 100644 index 00000000000..7b8de7739d2 --- /dev/null +++ b/examples/java/com/wiredtiger/examples/ex_cursor.java @@ -0,0 +1,239 @@ +/*- + * Public Domain 2008-2014 WiredTiger, Inc. + * + * This is free and unencumbered software released into the public domain. + * + * Anyone is free to copy, modify, publish, use, compile, sell, or + * distribute this software, either in source code form or as a compiled + * binary, for any purpose, commercial or non-commercial, and by any + * means. + * + * In jurisdictions that recognize copyright laws, the author or authors + * of this software dedicate any and all copyright interest in the + * software to the public domain. We make this dedication for the benefit + * of the public at large and to the detriment of our heirs and + * successors. We intend this dedication to be an overt act of + * relinquishment in perpetuity of all present and future rights to this + * software under copyright law. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * ex_cursor.java + * This is an example demonstrating some cursor types and operations. + */ + +package com.wiredtiger.examples; +import com.wiredtiger.db.*; +import java.io.*; +import java.util.*; + +public class ex_cursor { + + public static String home; + + /*! [cursor next] */ + public static int + cursor_forward_scan(Cursor cursor) + throws WiredTigerException + { + String key, value; + int ret; + + while ((ret = cursor.next()) == 0) { + key = cursor.getKeyString(); + value = cursor.getValueString(); + } + return (ret); + } + /*! [cursor next] */ + + /*! [cursor prev] */ + public static int + cursor_reverse_scan(Cursor cursor) + throws WiredTigerException + { + String key, value; + int ret; + + while ((ret = cursor.prev()) == 0) { + key = cursor.getKeyString(); + value = cursor.getValueString(); + } + return (ret); + } + /*! [cursor prev] */ + + /*! [cursor reset] */ + public static int + cursor_reset(Cursor cursor) + throws WiredTigerException + { + return (cursor.reset()); + } + /*! [cursor reset] */ + + /*! [cursor search] */ + public static int + cursor_search(Cursor cursor) + throws WiredTigerException + { + String value; + int ret; + + cursor.putKeyString("foo"); + + if ((ret = cursor.search()) != 0) + value = cursor.getValueString(); + + return (ret); + } + /*! [cursor search] */ + + /*! [cursor search near] */ + public static int + cursor_search_near(Cursor cursor) + throws WiredTigerException + { + String key, value; + SearchStatus exact; + + key = "foo"; + cursor.putKeyString(key); + + exact = cursor.search_near(); + if (exact == SearchStatus.SMALLER) + /* Returned key smaller than search key */ + key = cursor.getKeyString(); + else if (exact == SearchStatus.LARGER) + /* Returned key larger than search key */ + key = cursor.getKeyString(); + /* Else exact match found, and key already set */ + + value = cursor.getValueString(); + + return (0); + } + /*! [cursor search near] */ + + /*! [cursor insert] */ + public static int + cursor_insert(Cursor cursor) + throws WiredTigerException + { + cursor.putKeyString("foo"); + cursor.putValueString("bar"); + + return (cursor.insert()); + } + /*! [cursor insert] */ + + /*! [cursor update] */ + public static int + cursor_update(Cursor cursor) + throws WiredTigerException + { + cursor.putKeyString("foo"); + cursor.putValueString("newbar"); + + return (cursor.update()); + } + /*! [cursor update] */ + + /*! [cursor remove] */ + public static int + cursor_remove(Cursor cursor) + throws WiredTigerException + { + cursor.putKeyString("foo"); + return (cursor.remove()); + } + /*! [cursor remove] */ + + public static int + cursorExample() + throws WiredTigerException + { + Connection conn; + Cursor cursor; + Session session; + int ret; + + /* + * Create a clean test directory for this run of the test program if the + * environment variable isn't already set (as is done by make check). + */ + if (System.getenv("WIREDTIGER_HOME") == null) { + home = "WT_HOME"; + try { + Process proc = Runtime.getRuntime().exec("/bin/rm -rf WT_HOME"); + BufferedReader br = new BufferedReader( + new InputStreamReader(proc.getInputStream())); + while(br.ready()) + System.out.println(br.readLine()); + br.close(); + new File("WT_HOME").mkdir(); + } catch (IOException ioe) { + System.err.println("IOException: WT_HOME: " + ioe); + return(1); + } + } else + home = null; + + conn = wiredtiger.open(home, "create,statistics=(fast)"); + session = conn.open_session(null); + + ret = session.create("table:world", + "key_format=r,value_format=5sii," + + "columns=(id,country,population,area)"); + + /*! [open cursor #1] */ + cursor = session.open_cursor("table:world", null, null); + /*! [open cursor #1] */ + + /*! [open cursor #2] */ + cursor = session.open_cursor("table:world(country,population)", null, null); + /*! [open cursor #2] */ + + /*! [open cursor #3] */ + cursor = session.open_cursor("statistics:", null, null); + /*! [open cursor #3] */ + + /* Create a simple string table to illustrate basic operations. */ + ret = session.create("table:map", "key_format=S,value_format=S"); + cursor = session.open_cursor("table:map", null, null); + ret = cursor_insert(cursor); + ret = cursor_reset(cursor); + ret = cursor_forward_scan(cursor); + ret = cursor_reset(cursor); + ret = cursor_reverse_scan(cursor); + ret = cursor_search_near(cursor); + ret = cursor_update(cursor); + ret = cursor_remove(cursor); + ret = cursor.close(); + + /* Note: closing the connection implicitly closes open session(s). */ + if ((ret = conn.close(null)) != 0) + System.err.println("Error connecting to " + home + ": " + + wiredtiger.wiredtiger_strerror(ret)); + + return (ret); + } + + public static int + main(String[] argv) + { + try { + return (cursorExample()); + } + catch (WiredTigerException wte) { + System.err.println("Exception: " + wte); + return (-1); + } + } +} diff --git a/examples/java/com/wiredtiger/examples/ex_log.java b/examples/java/com/wiredtiger/examples/ex_log.java new file mode 100644 index 00000000000..d7bc6987878 --- /dev/null +++ b/examples/java/com/wiredtiger/examples/ex_log.java @@ -0,0 +1,376 @@ +/*- + * Public Domain 2008-2014 WiredTiger, Inc. + * + * This is free and unencumbered software released into the public domain. + * + * Anyone is free to copy, modify, publish, use, compile, sell, or + * distribute this software, either in source code form or as a compiled + * binary, for any purpose, commercial or non-commercial, and by any + * means. + * + * In jurisdictions that recognize copyright laws, the author or authors + * of this software dedicate any and all copyright interest in the + * software to the public domain. We make this dedication for the benefit + * of the public at large and to the detriment of our heirs and + * successors. We intend this dedication to be an overt act of + * relinquishment in perpetuity of all present and future rights to this + * software under copyright law. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * ex_log.java + * demonstrates how to logging and log cursors. + */ +package com.wiredtiger.examples; +import com.wiredtiger.db.*; +import java.io.*; +import java.util.*; + +class Lsn { + int file; + long offset; +} + +public class ex_log { + + public static String home1 = "WT_HOME_LOG_1"; + public static String home2 = "WT_HOME_LOG_2"; + public static String uri = "table:logtest"; + + public static final String CONN_CONFIG = + "create,cache_size=100MB,log=(archive=false,enabled=true)"; + public static final int MAX_KEYS = 10; + + static Session + setup_copy() + throws WiredTigerException + { + int ret = 0; + Connection conn; + + conn = wiredtiger.open(home2, CONN_CONFIG); + Session session = conn.open_session(null); + session.create(uri, "key_format=S,value_format=S"); + return (session); + } + + static int + compare_tables(Session session, Session sess_copy) + throws WiredTigerException + { + int ret; + + Cursor cursor = session.open_cursor(uri, null, null); + Cursor curs_copy = sess_copy.open_cursor(uri, null, null); + + while ((ret = cursor.next()) == 0) { + ret = curs_copy.next(); + String key = cursor.getKeyString(); + String value = cursor.getValueString(); + String key_copy = curs_copy.getKeyString(); + String value_copy = curs_copy.getValueString(); + if (!key.equals(key_copy) || !value.equals(value_copy)) { + System.err.println( + "Mismatched: key " + key + + ", key_copy " + key_copy + + " value " + value + + " value_copy " + value_copy); + return (1); + } + } + if (ret != wiredtiger.WT_NOTFOUND) + System.err.println("WT_CURSOR.next: " + + wiredtiger.wiredtiger_strerror(ret)); + ret = cursor.close(); + + ret = curs_copy.next(); + if (ret != wiredtiger.WT_NOTFOUND) + System.err.println("WT_CURSOR.next: " + + wiredtiger.wiredtiger_strerror(ret)); + ret = curs_copy.close(); + + return (ret); + } + + /*! [log cursor walk] */ + static void + print_record(Lsn lsn, int opcount, + int rectype, int optype, long txnid, int fileid, + byte[] key, byte[] value) + { + System.out.print( + "LSN [" + lsn.file + "][" + lsn.offset + "]." + opcount + + ": record type " + rectype + " optype " + optype + + " txnid " + txnid + " fileid " + fileid); + System.out.println(" key size " + key.length + + "value size " + value.length); + if (rectype == wiredtiger.WT_LOGREC_MESSAGE) + System.out.println("Application Record: " + new String(value)); + } + + /* + * simple_walk_log -- + * A simple walk of the log. + */ + static int + simple_walk_log(Session session) + throws WiredTigerException + { + Cursor cursor; + Lsn lsn = new Lsn(); + byte[] logrec_key, logrec_value; + long txnid; + int fileid, opcount, optype, rectype; + int ret; + + /*! [log cursor open] */ + cursor = session.open_cursor("log:", null, null); + /*! [log cursor open] */ + + while ((ret = cursor.next()) == 0) { + /*! [log cursor get_key] */ + lsn.file = cursor.getKeyInt(); + lsn.offset = cursor.getKeyLong(); + opcount = cursor.getKeyInt(); + /*! [log cursor get_key] */ + /*! [log cursor get_value] */ + txnid = cursor.getValueLong(); + rectype = cursor.getValueInt(); + optype = cursor.getValueInt(); + fileid = cursor.getValueInt(); + logrec_key = cursor.getValueByteArray(); + logrec_value = cursor.getValueByteArray(); + /*! [log cursor get_value] */ + + print_record(lsn, opcount, + rectype, optype, txnid, fileid, logrec_key, logrec_value); + } + if (ret == wiredtiger.WT_NOTFOUND) + ret = 0; + ret = cursor.close(); + return (ret); + } + /*! [log cursor walk] */ + + static int + walk_log(Session session) + throws WiredTigerException + { + Connection wt_conn2; + Cursor cursor, cursor2; + Lsn lsn, lsnsave; + byte[] logrec_key, logrec_value; + Session session2; + long txnid; + int fileid, opcount, optype, rectype; + int i, ret; + boolean in_txn, first; + + session2 = setup_copy(); + wt_conn2 = session2.getConnection(); + cursor = session.open_cursor("log:", null, null); + cursor2 = session2.open_cursor(uri, null, "raw=true"); + i = 0; + in_txn = false; + txnid = 0; + lsn = new Lsn(); + lsnsave = new Lsn(); + while ((ret = cursor.next()) == 0) { + lsn.file = cursor.getKeyInt(); + lsn.offset = cursor.getKeyLong(); + opcount = cursor.getKeyInt(); + + /* + * Save one of the LSNs we get back to search for it + * later. Pick a later one because we want to walk from + * that LSN to the end (where the multi-step transaction + * was performed). Just choose the record that is MAX_KEYS. + */ + if (++i == MAX_KEYS) + lsnsave = lsn; + txnid = cursor.getValueLong(); + rectype = cursor.getValueInt(); + optype = cursor.getValueInt(); + fileid = cursor.getValueInt(); + logrec_key = cursor.getValueByteArray(); + logrec_value = cursor.getValueByteArray(); + + print_record(lsn, opcount, + rectype, optype, txnid, fileid, logrec_key, logrec_value); + + /* + * If we are in a transaction and this is a new one, end + * the previous one. + */ + if (in_txn && opcount == 0) { + ret = session2.commit_transaction(null); + in_txn = false; + } + + /* + * If the operation is a put, replay it here on the backup + * connection. Note, we cheat by looking only for fileid 1 + * in this example. The metadata is fileid 0. + */ + if (fileid == 1 && rectype == wiredtiger.WT_LOGREC_COMMIT && + optype == wiredtiger.WT_LOGOP_ROW_PUT) { + if (!in_txn) { + ret = session2.begin_transaction(null); + in_txn = true; + } + cursor2.putKeyByteArray(logrec_key); + cursor2.putValueByteArray(logrec_value); + ret = cursor2.insert(); + } + } + if (in_txn) + ret = session2.commit_transaction(null); + + ret = cursor2.close(); + /* + * Compare the tables after replay. They should be identical. + */ + if (compare_tables(session, session2) != 0) + System.out.println("compare failed"); + ret = session2.close(null); + ret = wt_conn2.close(null); + + ret = cursor.reset(); + /*! [log cursor set_key] */ + cursor.putKeyInt(lsnsave.file); + cursor.putKeyLong(lsnsave.offset); + /*! [log cursor set_key] */ + /*! [log cursor search] */ + ret = cursor.search(); + /*! [log cursor search] */ + System.out.println("Reset to saved..."); + /* + * Walk all records starting with this key. + */ + first = true; + while (ret == 0) { /*TODO: not quite right*/ + lsn.file = cursor.getKeyInt(); + lsn.offset = cursor.getKeyLong(); + opcount = cursor.getKeyInt(); + if (first) { + first = false; + if (lsnsave.file != lsn.file || + lsnsave.offset != lsn.offset) { + System.err.println("search returned the wrong LSN"); + System.exit(1); + } + } + txnid = cursor.getValueLong(); + rectype = cursor.getValueInt(); + optype = cursor.getValueInt(); + fileid = cursor.getValueInt(); + logrec_key = cursor.getValueByteArray(); + logrec_value = cursor.getValueByteArray(); + + print_record(lsn, opcount, rectype, optype, txnid, + fileid, logrec_key, logrec_value); + + ret = cursor.next(); + if (ret != 0) + break; + } + ret = cursor.close(); + return (ret); + } + + public static int + logExample() + throws WiredTigerException + { + Connection wt_conn; + Cursor cursor; + Session session; + int i, record_count, ret; + + try { + String command = "/bin/rm -rf " + home1 + " " + home2; + Process proc = Runtime.getRuntime().exec(command); + BufferedReader br = new BufferedReader( + new InputStreamReader(proc.getInputStream())); + while(br.ready()) + System.out.println(br.readLine()); + br.close(); + new File(home1).mkdir(); + new File(home2).mkdir(); + } catch (IOException ioe) { + System.err.println("IOException: " + ioe); + return (1); + } + if ((wt_conn = wiredtiger.open(home1, CONN_CONFIG)) == null) { + System.err.println("Error connecting to " + home1); + return (1); + } + + session = wt_conn.open_session(null); + ret = session.create(uri, "key_format=S,value_format=S"); + + cursor = session.open_cursor(uri, null, null); + /* + * Perform some operations with individual auto-commit transactions. + */ + for (record_count = 0, i = 0; i < MAX_KEYS; i++, record_count++) { + String k = "key" + i; + String v = "value" + i; + cursor.putKeyString(k); + cursor.putValueString(v); + ret = cursor.insert(); + } + ret = session.begin_transaction(null); + /* + * Perform some operations within a single transaction. + */ + for (i = MAX_KEYS; i < MAX_KEYS+5; i++, record_count++) { + String k = "key" + i; + String v = "value" + i; + cursor.putKeyString(k); + cursor.putValueString(v); + ret = cursor.insert(); + } + ret = session.commit_transaction(null); + ret = cursor.close(); + + /*! [log cursor printf] */ + ret = session.log_printf("Wrote " + record_count + " records"); + /*! [log cursor printf] */ + + /* + * Close and reopen the connection so that the log ends up with + * a variety of records such as file sync and checkpoint. We + * have archiving turned off. + */ + ret = wt_conn.close(null); + if ((wt_conn = wiredtiger.open(home1, CONN_CONFIG)) == null) { + System.err.println("Error connecting to " + home1); + return (ret); + } + + session = wt_conn.open_session(null); + ret = simple_walk_log(session); + ret = walk_log(session); + ret = wt_conn.close(null); + return (ret); + } + + public static int + main() + { + try { + return (logExample()); + } + catch (WiredTigerException wte) { + System.err.println("Exception: " + wte); + return (-1); + } + } +} diff --git a/examples/java/com/wiredtiger/examples/ex_schema.java b/examples/java/com/wiredtiger/examples/ex_schema.java new file mode 100644 index 00000000000..9b84912e0f0 --- /dev/null +++ b/examples/java/com/wiredtiger/examples/ex_schema.java @@ -0,0 +1,333 @@ +/*- + * Public Domain 2008-2014 WiredTiger, Inc. + * + * This is free and unencumbered software released into the public domain. + * + * Anyone is free to copy, modify, publish, use, compile, sell, or + * distribute this software, either in source code form or as a compiled + * binary, for any purpose, commercial or non-commercial, and by any + * means. + * + * In jurisdictions that recognize copyright laws, the author or authors + * of this software dedicate any and all copyright interest in the + * software to the public domain. We make this dedication for the benefit + * of the public at large and to the detriment of our heirs and + * successors. We intend this dedication to be an overt act of + * relinquishment in perpetuity of all present and future rights to this + * software under copyright law. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * ex_schema.java + * This is an example application demonstrating how to create and access + * tables using a schema. + */ +package com.wiredtiger.examples; +import com.wiredtiger.db.*; +import java.io.*; +import java.util.*; + +public class ex_schema { + + public static String home; + + /*! [schema declaration] */ + /* The class for the data we are storing in a WiredTiger table. */ + static class PopRecord { + public String country; // Stored in database as fixed size char[5]; + public short year; + public long population; + public PopRecord(String country, short year, long population) { + this.country = country; + this.year = year; + this.population = population; + } + } + + static List<PopRecord> popData; + + static { + popData = new ArrayList<PopRecord>(); + + popData.add(new PopRecord("AU", (short)1900, 4000000 )); + popData.add(new PopRecord("AU", (short)2000, 19053186 )); + popData.add(new PopRecord("CAN", (short)1900, 5500000 )); + popData.add(new PopRecord("CAN", (short)2000, 31099561 )); + popData.add(new PopRecord("UK", (short)1900, 369000000 )); + popData.add(new PopRecord("UK", (short)2000, 59522468 )); + popData.add(new PopRecord("USA", (short)1900, 76212168 )); + popData.add(new PopRecord("USA", (short)2000, 301279593 )); + }; + /*! [schema declaration] */ + + public static int + schemaExample() + throws WiredTigerException + { + Connection conn; + Cursor cursor; + Session session; + String country; + long recno, population; + short year; + int ret; + + /* + * Create a clean test directory for this run of the test program if the + * environment variable isn't already set (as is done by make check). + */ + if (System.getenv("WIREDTIGER_HOME") == null) { + home = "WT_HOME"; + try { + Process proc = Runtime.getRuntime().exec("/bin/rm -rf WT_HOME"); + BufferedReader br = new BufferedReader( + new InputStreamReader(proc.getInputStream())); + while(br.ready()) + System.out.println(br.readLine()); + br.close(); + new File("WT_HOME").mkdir(); + } catch (IOException ioe) { + System.err.println("IOException: WT_HOME: " + ioe); + return(1); + } + } else + home = null; + + try { + conn = wiredtiger.open(home, "create"); + session = conn.open_session(null); + } catch (WiredTigerException wte) { + System.err.println("WiredTigerException: " + wte); + return(1); + } + + /*! [Create a table with column groups] */ + /* + * Create the population table. + * Keys are record numbers, the format for values is (5-byte string, + * long, long). + * See ::wiredtiger_struct_pack for details of the format strings. + */ + ret = session.create("table:poptable", + "key_format=r,value_format=5sHQ," + + "columns=(id,country,year,population),colgroups=(main,population)"); + + /* + * Create two column groups: a primary column group with the country + * code, year and population (named "main"), and a population column + * group with the population by itself (named "population"). + */ + ret = session.create("colgroup:poptable:main", + "columns=(country,year,population)"); + ret = session.create("colgroup:poptable:population", + "columns=(population)"); + /*! [Create a table with column groups] */ + + /*! [Create an index] */ + /* Create an index with a simple key. */ + ret = session.create("index:poptable:country", + "columns=(country)"); + /*! [Create an index] */ + + /*! [Create an index with a composite key] */ + /* Create an index with a composite key (country,year). */ + ret = session.create("index:poptable:country_plus_year", + "columns=(country,year)"); + /*! [Create an index with a composite key] */ + + /*! [Insert and list records] */ + /* Insert the records into the table. */ + cursor = session.open_cursor("table:poptable", null, "append"); + for (PopRecord p : popData) { + cursor.putValueString(p.country); + cursor.putValueShort(p.year); + cursor.putValueLong(p.population); + ret = cursor.insert(); + } + ret = cursor.close(); + + /* List the records in the table. */ + cursor = session.open_cursor("table:poptable", null, null); + while ((ret = cursor.next()) == 0) { + recno = cursor.getKeyLong(); + country = cursor.getValueString(); + year = cursor.getValueShort(); + population = cursor.getValueLong(); + System.out.print("ID " + recno); + System.out.println(": country " + country + ", year " + year + + ", population " + population); + } + ret = cursor.close(); + /*! [Insert and list records] */ + + /*! [List the records in the table using raw mode.] */ + cursor = session.open_cursor("table:poptable", null, "raw"); + while ((ret = cursor.next()) == 0) { + byte[] key, value; + + key = cursor.getKeyByteArray(); + System.out.println(Arrays.toString(key)); + value = cursor.getValueByteArray(); + System.out.println("raw key: " + Arrays.toString(key) + + ", raw value: " + Arrays.toString(value)); + } + /*! [List the records in the table using raw mode.] */ + + /*! [Read population from the primary column group] */ + /* + * Open a cursor on the main column group, and return the information + * for a particular country. + */ + cursor = session.open_cursor("colgroup:poptable:main", null, null); + cursor.putKeyLong(2); + if ((ret = cursor.search()) == 0) { + country = cursor.getValueString(); + year = cursor.getValueShort(); + population = cursor.getValueLong(); + System.out.println("ID 2: country " + country + + ", year " + year + ", population " + population); + } + /*! [Read population from the primary column group] */ + ret = cursor.close(); + + /*! [Read population from the standalone column group] */ + /* + * Open a cursor on the population column group, and return the + * population of a particular country. + */ + cursor = session.open_cursor("colgroup:poptable:population", null, null); + cursor.putKeyLong(2); + if ((ret = cursor.search()) == 0) { + population = cursor.getValueLong(); + System.out.println("ID 2: population " + population); + } + /*! [Read population from the standalone column group] */ + ret = cursor.close(); + + /*! [Search in a simple index] */ + /* Search in a simple index. */ + cursor = session.open_cursor("index:poptable:country", null, null); + cursor.putKeyString("AU"); + ret = cursor.search(); + country = cursor.getValueString(); + year = cursor.getValueShort(); + population = cursor.getValueLong(); + System.out.println("AU: country " + country + ", year " + year + + ", population " + population); + /*! [Search in a simple index] */ + ret = cursor.close(); + + /*! [Search in a composite index] */ + /* Search in a composite index. */ + cursor = session.open_cursor( + "index:poptable:country_plus_year", null, null); + cursor.putKeyString("USA"); + cursor.putKeyShort((short)1900); + ret = cursor.search(); + country = cursor.getValueString(); + year = cursor.getValueShort(); + population = cursor.getValueLong(); + System.out.println("US 1900: country " + country + + ", year " + year + ", population " + population); + /*! [Search in a composite index] */ + ret = cursor.close(); + + /*! [Return a subset of values from the table] */ + /* + * Use a projection to return just the table's country and year + * columns. + */ + cursor = session.open_cursor("table:poptable(country,year)", null, null); + while ((ret = cursor.next()) == 0) { + country = cursor.getValueString(); + year = cursor.getValueShort(); + System.out.println("country " + country + ", year " + year); + } + /*! [Return a subset of values from the table] */ + ret = cursor.close(); + + /*! [Return a subset of values from the table using raw mode] */ + /* + * Use a projection to return just the table's country and year + * columns. + */ + cursor = session.open_cursor("table:poptable(country,year)", null, null); + while ((ret = cursor.next()) == 0) { + country = cursor.getValueString(); + year = cursor.getValueShort(); + System.out.println("country " + country + ", year " + year); + } + /*! [Return a subset of values from the table using raw mode] */ + ret = cursor.close(); + + /*! [Return the table's record number key using an index] */ + /* + * Use a projection to return just the table's record number key + * from an index. + */ + cursor = session.open_cursor("index:poptable:country_plus_year(id)", null, null); + while ((ret = cursor.next()) == 0) { + country = cursor.getKeyString(); + year = cursor.getKeyShort(); + recno = cursor.getValueLong(); + System.out.println("row ID " + recno + ": country " + country + + ", year " + year); + } + /*! [Return the table's record number key using an index] */ + ret = cursor.close(); + + /*! [Return a subset of the value columns from an index] */ + /* + * Use a projection to return just the population column from an + * index. + */ + cursor = session.open_cursor( + "index:poptable:country_plus_year(population)", null, null); + while ((ret = cursor.next()) == 0) { + country = cursor.getKeyString(); + year = cursor.getKeyShort(); + population = cursor.getValueLong(); + System.out.println("population " + population + + ": country " + country + ", year " + year); + } + /*! [Return a subset of the value columns from an index] */ + ret = cursor.close(); + + /*! [Access only the index] */ + /* + * Use a projection to avoid accessing any other column groups when + * using an index: supply an empty list of value columns. + */ + cursor = session.open_cursor( + "index:poptable:country_plus_year()", null, null); + while ((ret = cursor.next()) == 0) { + country = cursor.getKeyString(); + year = cursor.getKeyShort(); + System.out.println("country " + country + ", year " + year); + } + /*! [Access only the index] */ + ret = cursor.close(); + + ret = conn.close(null); + + return (ret); + } + + public static int + main(String[] argv) + { + try { + return (schemaExample()); + } + catch (WiredTigerException wte) { + System.err.println("Exception: " + wte); + return (-1); + } + } +} diff --git a/examples/java/com/wiredtiger/examples/ex_stat.java b/examples/java/com/wiredtiger/examples/ex_stat.java new file mode 100644 index 00000000000..c81bb64c22a --- /dev/null +++ b/examples/java/com/wiredtiger/examples/ex_stat.java @@ -0,0 +1,252 @@ +/*- + * Public Domain 2008-2014 WiredTiger, Inc. + * + * This is free and unencumbered software released into the public domain. + * + * Anyone is free to copy, modify, publish, use, compile, sell, or + * distribute this software, either in source code form or as a compiled + * binary, for any purpose, commercial or non-commercial, and by any + * means. + * + * In jurisdictions that recognize copyright laws, the author or authors + * of this software dedicate any and all copyright interest in the + * software to the public domain. We make this dedication for the benefit + * of the public at large and to the detriment of our heirs and + * successors. We intend this dedication to be an overt act of + * relinquishment in perpetuity of all present and future rights to this + * software under copyright law. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * ex_stat.java + * This is an example demonstrating how to query database statistics. + */ +package com.wiredtiger.examples; +import com.wiredtiger.db.*; +import java.io.*; +import java.util.*; + +public class ex_stat { + + public static String home; + + /*! [statistics display function] */ + int + print_cursor(Cursor cursor) + throws WiredTigerException + { + String desc, pvalue; + long value; + int ret; + + while ((ret = cursor.next()) == 0) { + desc = cursor.getValueString(); + pvalue = cursor.getValueString(); + value = cursor.getValueLong(); + if (value != 0) + System.out.println(desc + "=" + pvalue); + } + + return (ret == wiredtiger.WT_NOTFOUND ? 0 : ret); + } + /*! [statistics display function] */ + + int + print_database_stats(Session session) + throws WiredTigerException + { + Cursor cursor; + int ret; + + /*! [statistics database function] */ + cursor = session.open_cursor("statistics:", null, null); + + ret = print_cursor(cursor); + ret = cursor.close(); + /*! [statistics database function] */ + + return (ret); + } + + int + print_file_stats(Session session) + throws WiredTigerException + { + Cursor cursor; + int ret; + + /*! [statistics table function] */ + cursor = session.open_cursor("statistics:table:access", null, null); + ret = print_cursor(cursor); + ret = cursor.close(); + /*! [statistics table function] */ + + return (ret); + } + + int + print_overflow_pages(Session session) + throws WiredTigerException + { + /*! [statistics retrieve by key] */ + Cursor cursor; + String desc, pvalue; + long value; + int ret; + + cursor = session.open_cursor("statistics:table:access", null, null); + + cursor.putKeyInt(wiredtiger.WT_STAT_DSRC_BTREE_OVERFLOW); + ret = cursor.search(); + desc = cursor.getValueString(); + pvalue = cursor.getValueString(); + value = cursor.getValueLong(); + System.out.println(desc + "=" + pvalue); + + ret = cursor.close(); + /*! [statistics retrieve by key] */ + + return (ret); + } + + /*! [statistics calculation helper function] */ + long + get_stat(Cursor cursor, int stat_field) + throws WiredTigerException + { + long value; + int ret; + + cursor.putKeyInt(stat_field); + if ((ret = cursor.search()) != 0) { + System.err.println("stat_field: " + stat_field + " not found"); + value = 0; + } + else { + String desc = cursor.getValueString(); + String pvalue = cursor.getValueString(); + value = cursor.getValueLong(); + } + return (value); + } + /*! [statistics calculation helper function] */ + + int + print_derived_stats(Session session) + throws WiredTigerException + { + Cursor cursor; + int ret; + + /*! [statistics calculate open table stats] */ + cursor = session.open_cursor("statistics:table:access", null, null); + /*! [statistics calculate open table stats] */ + + { + /*! [statistics calculate table fragmentation] */ + long ckpt_size = get_stat(cursor, + wiredtiger.WT_STAT_DSRC_BLOCK_CHECKPOINT_SIZE); + long file_size = get_stat(cursor, + wiredtiger.WT_STAT_DSRC_BLOCK_SIZE); + + System.out.println("File is " + + (int)(100 * (file_size - ckpt_size) / file_size) + + "% fragmented\n"); + /*! [statistics calculate table fragmentation] */ + } + + { + /*! [statistics calculate write amplification] */ + long app_insert = get_stat(cursor, + wiredtiger.WT_STAT_DSRC_CURSOR_INSERT_BYTES); + long app_remove = get_stat(cursor, + wiredtiger.WT_STAT_DSRC_CURSOR_REMOVE_BYTES); + long app_update = get_stat(cursor, + wiredtiger.WT_STAT_DSRC_CURSOR_UPDATE_BYTES); + + long fs_writes = get_stat(cursor, + wiredtiger.WT_STAT_DSRC_CACHE_BYTES_WRITE); + + if (app_insert + app_remove + app_update != 0) + System.out.println("Write amplification is " + + (double)fs_writes / (app_insert + app_remove + app_update)); + /*! [statistics calculate write amplification] */ + } + + ret = cursor.close(); + + return (ret); + } + + public int + statExample() + throws WiredTigerException + { + Connection conn; + Cursor cursor; + Session session; + int ret; + + /* + * Create a clean test directory for this run of the test program if the + * environment variable isn't already set (as is done by make check). + */ + if (System.getenv("WIREDTIGER_HOME") == null) { + home = "WT_HOME"; + try { + Process proc = Runtime.getRuntime().exec("/bin/rm -rf WT_HOME"); + BufferedReader br = new BufferedReader( + new InputStreamReader(proc.getInputStream())); + while(br.ready()) + System.out.println(br.readLine()); + br.close(); + new File("WT_HOME").mkdir(); + } catch (IOException ioe) { + System.err.println("IOException: WT_HOME: " + ioe); + return(1); + } + } else + home = null; + + conn = wiredtiger.open(home, "create,statistics=(all)"); + session = conn.open_session(null); + + ret = session.create("table:access", "key_format=S,value_format=S"); + + cursor = session.open_cursor("table:access", null, null); + cursor.putKeyString("key"); + cursor.putValueString("value"); + ret = cursor.insert(); + ret = cursor.close(); + + ret = session.checkpoint(null); + + ret = print_database_stats(session); + + ret = print_file_stats(session); + + ret = print_overflow_pages(session); + + ret = print_derived_stats(session); + + return (conn.close(null) == 0 ? ret : -1); + } + + public static int + main(String[] argv) + { + try { + return ((new ex_stat()).statExample()); + } + catch (WiredTigerException wte) { + System.err.println("Exception: " + wte); + return (-1); + } + } +} diff --git a/examples/java/com/wiredtiger/examples/ex_thread.java b/examples/java/com/wiredtiger/examples/ex_thread.java new file mode 100644 index 00000000000..c6b9a5479a9 --- /dev/null +++ b/examples/java/com/wiredtiger/examples/ex_thread.java @@ -0,0 +1,142 @@ +/*- + * Public Domain 2008-2014 WiredTiger, Inc. + * + * This is free and unencumbered software released into the public domain. + * + * Anyone is free to copy, modify, publish, use, compile, sell, or + * distribute this software, either in source code form or as a compiled + * binary, for any purpose, commercial or non-commercial, and by any + * means. + * + * In jurisdictions that recognize copyright laws, the author or authors + * of this software dedicate any and all copyright interest in the + * software to the public domain. We make this dedication for the benefit + * of the public at large and to the detriment of our heirs and + * successors. We intend this dedication to be an overt act of + * relinquishment in perpetuity of all present and future rights to this + * software under copyright law. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. + * + * ex_thread.java + * This is an example demonstrating how to create and access a simple + * table from multiple threads. + */ + +package com.wiredtiger.examples; +import com.wiredtiger.db.*; +import java.io.*; +import java.util.*; + +/*! [thread scan] */ +class ScanThread extends Thread { + private Connection conn; + + public ScanThread(Connection conn) { + this.conn = conn; + } + + public void run() + { + try { + int ret; + + Session session = conn.open_session(null); + Cursor cursor = session.open_cursor("table:access", null, null); + + /* Show all records. */ + while ((ret = cursor.next()) == 0) { + String key = cursor.getKeyString(); + String value = cursor.getValueString(); + System.out.println("Got record: " + key + " : " + value); + } + if (ret != wiredtiger.WT_NOTFOUND) + System.err.println("Cursor.next: " + + wiredtiger.wiredtiger_strerror(ret)); + } catch (WiredTigerException wte) { + System.err.println("Exception " + wte); + } + } +} +/*! [thread scan] */ + +public class ex_thread { + + public static String home; + + public static final int NUM_THREADS = 10; + + /*! [thread main] */ + static int main(String[] argv) + { + try { + Thread[] threads = new Thread[NUM_THREADS]; + int i, ret; + Connection conn; + + /* + * Create a clean test directory for this run of the test program if the + * environment variable isn't already set (as is done by make check). + */ + if (System.getenv("WIREDTIGER_HOME") == null) { + home = "WT_HOME"; + try { + Process proc = Runtime.getRuntime().exec("/bin/rm -rf " + home); + BufferedReader br = new BufferedReader( + new InputStreamReader(proc.getInputStream())); + while(br.ready()) + System.out.println(br.readLine()); + br.close(); + new File(home).mkdir(); + } catch (IOException ioe) { + System.err.println("IOException: " + home + ": " + ioe); + return(1); + } + } else + home = null; + + if ((conn = wiredtiger.open(home, "create")) == null) { + System.err.println("Error connecting to " + home); + return(1); + } + + /* Note: further error checking omitted for clarity. */ + + Session session = conn.open_session(null); + ret = session.create("table:access", "key_format=S,value_format=S"); + Cursor cursor = session.open_cursor("table:access", null, "overwrite"); + cursor.putKeyString("key1"); + cursor.putValueString("value1"); + ret = cursor.insert(); + ret = session.close(null); + + for (i = 0; i < NUM_THREADS; i++) { + threads[i] = new ScanThread(conn); + threads[i].start(); + } + + for (i = 0; i < NUM_THREADS; i++) + try { + threads[i].join(); + ret = -1; + } + catch (InterruptedException ie) { + } + + ret = conn.close(null); + return (ret); + } + catch (WiredTigerException wte) { + System.err.println("Exception: " + wte); + return (-1); + } + } + /*! [thread main] */ + +} |