July 2016 Summaries

The video short provides a demonstration of integrating Couchbase Lite into an Android project using Android Studio's Gradle build system. Additional guidance is available in the accompanying blog post, and further resources can be accessed through the developer portal. For community support, users are encouraged to post questions on forums and Stack Overflow, while updates can be followed on Twitter @CouchbaseDev and @HodGreeley.

On July 26, 2016, a guest speaker presented at the Findlay Area .NET User Group (FANUG) on the topic of Full Stack Development with .NET and NoSQL, and the session was recorded and shared on YouTube. The presentation included a .NET sample and a Xamarin Forms sample using Sync Gateway, both of which are accessible on GitHub. The speaker expressed appreciation for the enthusiastic participation of the group, highlighting the unexpected vibrancy of the user group given Findlay's small size and remote location, and recommended others to visit if they find themselves in northwest Ohio.

At the July meeting of the Silicon Valley Couchbase Meetup, the speaker, drawing on personal experience as a mobile developer, discussed the advantages of using Couchbase Lite and Couchbase Mobile, highlighting Couchbase Lite's ease of use compared to other alternatives and the robust capabilities of the Couchbase Mobile stack for complex applications. The talk facilitated engaging discussions among attendees, emphasizing the practical benefits of NoSQL databases in mobile development. Attendees were encouraged to explore additional resources on the developer portal, engage with the community on forums and Stack Overflow, and follow relevant updates on Twitter.

The blog post explores the use of Couchbase Mobile on Android, with insights applicable to iOS as well, focusing on JSON data handling and the transition from SQLite to NoSQL databases like Couchbase Lite. It highlights the advantages of using maps and lists for basic data operations and introduces the Jackson library as a robust tool for JSON manipulation, offering different approaches such as databinding to map JSON data to Java objects efficiently. The post discusses the use of annotations in Jackson for better control over object construction and advises caution when using features like additionalProperties to handle unspecified fields, as it may lead to unnoticed errors. Additionally, it mentions that Couchbase Lite utilizes Jackson internally but recommends not relying solely on this to avoid potential library conflicts. Resources and community support are available through Couchbase's developer portal and social media channels.

The Sub-Document (subdoc) API feature allows efficient access to parts of documents without transferring the entire document over the network. This reduces bandwidth usage and increases overall throughput. The subdoc API is implemented as part of the KV service in Couchbase, providing a high-performance set of simple APIs for accessing data within a single document. Subdoc operations can be used to perform lookups, mutations, and counter operations on documents, with options such as creating parents, handling CAS, and managing durability requirements. The subdoc API is designed to reduce network bandwidth and increase throughput, making it suitable for use in applications where efficient data access is critical. The API is atomic, ensuring that all sub-commands operate on the same version of the document, and can be used with N1QL queries when all Document IDs are known. However, the API does not support multi-document operations, and its naming convention may not conform to some programming languages' conventions.

Today, we are happy to announce the availability of Couchbase Server 3.1.6, the latest bug-fix release in the 3.x Couchbase Server series. This release includes several important bug fixes that improve the product's reliability, stability, and security. The fixes cover various aspects such as DCP, View Engine, and XDCR. A new version is now available for download from our download page, and users are encouraged to try it out and provide feedback. It is recommended that currently running 3.x series users upgrade to the latest version, which is Version 3.1.6.

During a presentation at the CBusJS Columbus JavaScript User Group on July 20, 2016, the speaker discussed Full Stack Development using Node.js and NoSQL. The session recording is available on YouTube, and examples of the CEAN stack and a Nativescript sample using Sync Gateway can be found on Github. The speaker expressed gratitude to attendees and recommended the group to anyone interested in JavaScript visiting the Columbus area.

A new Couchbase test container has been developed, allowing users to easily configure and run Couchbase clusters during tests without having to build their own Docker images. The container uses the official Couchbase Docker image and provides a custom waiting strategy for liveness checks. Users can configure the cluster by making API calls to set up ram quotas, usernames and passwords, and available services. The container also supports exposing multiple ports and setting HTTP wait strategies. This allows developers to easily test Couchbase without requiring extensive knowledge of Docker or Couchbase configuration.

The birth of BCBS 239 is a set of principles aimed at strengthening bank's risk aggregation and risk reporting practices, primarily in response to the financial crisis in 2007/2008. The crisis was partly caused by banks' inability to effectively report risk, leading to a breakdown in risk management. To address this, the principles aim to improve decision-making capabilities by enhancing management of information across legal entities, including the speed at which information is available. However, implementing these principles poses significant challenges due to the existence of data silos and the need for IT systems to move at the speed of business. Technology plays a crucial role in making this effort successful, particularly with advances in NoSQL databases such as Couchbase, which can help integrate and unify data from different silos, improve data quality, ensure availability, and facilitate dashboards that provide real-time views of risk exposure.

The seventh episode of the NoSQL Database Podcast, titled "Service Deployment with Juju Charms," features a discussion with Canonical's Michael Hall and Juju Charm contributor Jose Antonio Rey on deploying applications and services using Juju Charms. The episode provides insights into the background of Juju Charms, how to create them, and their usefulness in deploying NoSQL databases. Available on major podcasting platforms like iTunes, Pocket Casts, and Google Play, listeners can also direct questions to the hosts via email. The episode follows a previous discussion on RavenDB, a NoSQL database for .NET, and additional resources are available on the Couchbase developer portal.

The article by Sandhya Krishnamurthy explains the process of modeling and running the tax lot matching process using Couchbase and N1QL, focusing on the First In, First Out (FIFO) method for tax lot matching. It delves into how tax lots function as records of transactions with tax implications and describes various methodologies for identifying which tax lots to sell, such as FIFO, LIFO, and methods aimed at maximizing gains or losses. The article assumes a hedge fund or financial services context and provides an overview of how to adapt a relational database model to a NoSQL document model in Couchbase. It highlights the versatility of N1QL, a SQL-like query language with JSON-specific features, to handle complex data queries and outlines a step-by-step approach to executing the tax lot process, emphasizing the ability to handle intricate queries in N1QL similar to SQL. The article concludes by encouraging readers to explore further resources for a deeper understanding of Couchbase and N1QL.

Choosing the right fit – Immediate or Eventual Persistence? The author argues that eventual persistence is a viable option for some applications, particularly those that prioritize performance and cost over immediate durability. This approach means writing data to an intermediate layer, such as memory or a file system cache, with the actual write to disk queued up and happening asynchronously. In contrast, immediate persistence ensures writes are synchronous and acknowledged only after data is written to disk. The author suggests that certain workloads can function with deferred writes in favor of performance and cost, especially when paired with dependable storage solutions and high availability options. They also emphasize that durability is desirable but not always necessary, and that some applications may be able to tolerate rare cases of data loss without significant consequences.

Matthew Groves shares his journey of creating a portable Couchbase Server demonstration setup, affectionately named the "Couchcase," inspired by a friend's elaborate setup. He documents the challenges encountered and solutions found while preparing the hardware, focusing on using compute sticks with 64-bit capabilities, such as the GOLE Windows 10/Android stick and the Intel Compute Stick, to overcome operating system compatibility issues. Groves details the steps taken to update the BIOS, create a bootable USB drive with Ubuntu 14, and install necessary drivers, particularly for Wi-Fi functionality, highlighting the need for a USB-Ethernet adapter. The project aims to provide a simpler, portable, and efficient way to demonstrate Couchbase Server capabilities, with Groves inviting feedback and ideas from the community.

The text discusses how to use Full Text Search (FTS) in Couchbase Server 4.5 and higher using the Go programming language. The author creates a new project with the necessary dependencies, sets up a full-text search index on the default bucket, defines an example data model for resumes, and develops a GoLang application to search for specific text within documents. The code demonstrates how to create a search query, execute it, and parse the results into JSON. The author also shows how to make adjustments to the search query to be more specific, such as searching within a particular field. The example is used to illustrate the efficiency of using FTS in Couchbase for searching documents.

Creating custom Docker images for testing purposes is now straightforward using TestContainers. The GenericContainer class accepts a Future as an argument, which allows the image to be created asynchronously. This can be achieved by utilizing the ImageFromDockerfile class, which takes a Dockerfile and other necessary files from the classpath, allowing developers to build their own custom images just before running tests. Additionally, exposed ports are easily specified, and the waitingFor method ensures that the container is ready for testing. It's also possible to keep the images even after test completion by passing a flag.

Testing with Couchbase often involves using CouchbaseMock, mocking APIs, or maintaining a running Couchbase Server instance, which is not ideal for integration tests due to its lack of scalability and platform dependency. An alternative is to automate database start-up and shutdown within build scripts, but this introduces dependencies on specific build tools and platform-specific variations. Docker offers a uniform solution by acting as a distributed binary store, enabling consistent management of containers across platforms, which is ideal for test environments. TestContainers, a Java library, leverages Docker to provide lightweight, temporary instances of databases like Couchbase for JUnit tests, addressing these issues by allowing database instances to be set up and torn down easily during testing. This method also requires a custom wait strategy to ensure Couchbase nodes are fully operational before tests proceed, which involves checking the node status through a specific URL. Although current solutions may require building custom images for tests, the approach provides a robust framework for integration testing, and future enhancements could include more flexible modules for Couchbase testing without needing specific images.

Couchbase has released its Community Edition 4.1.0, which includes top bug fixes to improve product stability. This edition is designed for developers who want to get started with Couchbase and grow the community. The release strengthens the previous version by addressing issues and enhancing overall performance. For business-critical use-cases in production environments, Couchbase recommends its Enterprise Edition, offering the latest stable release.

The text delves into the process of updating documents in Couchbase Lite, a document-oriented database that stores documents as JSON objects. It explains that when a document is retrieved, a copy with immutable data is provided, which can be manipulated by copying the data into a separate map object or by using the createRevision() method to obtain a mutable UnsavedRevision. The article highlights the concept of document revisions and the potential for conflicts, similar to merge conflicts in source control, when multiple updates occur simultaneously. It introduces a more complex but efficient method of updating documents using the DocumentUpdater interface, which simplifies conflict resolution by allowing Couchbase Lite to handle conflicts through repeated update attempts until changes are successfully saved. The post encourages further exploration of revisions and conflict management in Couchbase Lite through additional resources and community engagement.

The performance benchmark conducted on Couchbase Server 4.5 running on Tegile IntelliFlash storage arrays highlights the benefits of combining Couchbase's scalability with Tegile's efficient storage solutions. Couchbase Server 4.5 introduced significant enhancements in KV functionality, memory optimization, and query performance, outpacing MongoDB in various operations. The testing setup included Cisco UCS servers, Tegile storage arrays, and a Linux-based operating environment, showcasing the system's ability to maintain low latency and high throughput across mixed workloads. Particularly, the YCSB Workload A demonstrated 95th percentile latency of 0.24ms, while Workload E maintained 13.64ms, both indicating the system's capability to handle complex queries efficiently. This collaboration between Tegile, Cisco, and Couchbase underscores the solution's reliability and scalability for enterprise-level applications, making it a robust choice for performance-intensive environments.

This video provides an overview of ScanConsistency options when executing N1QL queries in Couchbase, including a new option called AtPlus, which enhances query performance by reducing the number of times the query optimizer needs to re-evaluate the query plan. The video is intended for users who want to learn more about how to use Couchbase and offers additional resources, such as the Couchbase Developer Portal, Twitter, email, and forums, for those with questions or comments.

Couchbase 4.x offers a feature that enhances the creation of Global Secondary Indexes by allowing users to queue index creation statements and then execute them in parallel for improved efficiency and performance. This is particularly useful when creating multiple indexes with high availability, as users can defer the creation of indexes and later instruct the cluster to build them simultaneously using the BUILD INDEX command. This approach leverages the same Database Change Protocol (DCP) stream from Data Service nodes, optimizing network I/O utilization and significantly reducing the time required compared to a serial creation process. The parallel execution means that each Index Service node only needs a single DCP stream of the bucket’s data, leading to faster completion, especially beneficial when scripting multiple index creations in batches. Users are encouraged to explore this feature and consult the documentation for further guidance on its implementation.

Couchbase deployments often require secure communications between nodes, which can be accomplished using Internet Protocol Security (IPsec), a protocol suite that authenticates and encrypts IP packets. The article provides a guide for Couchbase Administrators to configure IPsec in transport mode, which is suitable for securing communication across nodes within the same network. Transport mode is preferred over tunnel mode for Couchbase clusters due to its practicality and ease of setup. The guide outlines the installation and configuration of OpenSwan on a Linux system, detailing steps such as modifying configuration files and setting up a pre-shared key for secure connections. The article emphasizes the importance of enabling Perfect Forward Secrecy for improved security and provides instructions for testing the setup to ensure proper communication between nodes.

Full text search (FTS) is a more efficient method for searching words and phrases within databases compared to using wildcards, which can cause performance drains. Starting with Couchbase 4.5, FTS is available as a developer preview feature. This tutorial demonstrates how to use full text search in a Node.js application using the Node.js SDK for Couchbase Server. The example project involves creating a resume parsing application that uses FTS to scan for relevant keywords or phrases and evaluate candidate qualifications based on search scoring.

A Developer Advocate at Couchbase is exploring an innovative approach to demonstrate Couchbase Server's capabilities using portable hardware. Inspired by a project involving Raspberry Pis and Couchbase Lite, the advocate is considering utilizing x64 architecture compute sticks, which are compact devices with sufficient processing power to run Couchbase Server. These compute sticks would enable the creation of a portable cluster that can be easily transported and set up at conferences and meetups. The idea involves using these devices to provide an interactive and tangible demonstration of Couchbase's cluster features, such as node failures and recovery, in a visually engaging manner. Despite the lack of an ARM version of Couchbase Server, the project aims to leverage these compute sticks to create a mobile "cloud in a box" setup for educational and promotional purposes, with plans to document the project's progress through blog updates.

At events, the author frequently encounters questions about data modeling, particularly from developers experienced with relational databases who are curious about NoSQL systems like Couchbase. Sharing personal experience, they transitioned from Oracle and Microsoft SQL Server to understanding NoSQL concepts, which initially seemed unfamiliar. The author created a video demonstrating how to model data in Couchbase, converting a simple relational database example into JSON document format and querying it seamlessly. Although the video doesn't cover all aspects, it provides a foundational understanding, and viewers are encouraged to ask questions in the comments for further clarification. For additional guidance on using NoSQL documents in applications, the author recommends consulting the developer portal for examples.

The blog post discusses the introduction of the Sub-document API in Couchbase Server 4.5 and its integration with the .NET SDK 2.3.x, enabling more efficient data manipulation by allowing partial updates to documents, rather than handling entire documents for each change. This API supports operations on individual elements, arrays, and dictionaries, and provides a fluent interface for chaining multiple operations, which are executed atomically. It introduces two builder types: MutateInBuilder for mutations and LookupInBuilder for read operations, each supporting various methods like insertions, removals, counter operations, and checks for the existence of elements. The blog also provides detailed code examples and explains error handling, emphasizing the API's ability to perform transactional updates. The post concludes with information on obtaining the latest .NET SDK version and encourages reader engagement for further questions or comments.

The Couchbase .NET SDK 2.3.3 release focuses on maintenance and bug fixes while introducing minor new features and an API rename. Key updates include the introduction of asynchronous batch methods for JSON document operations, allowing developers to utilize async/await paradigms for non-blocking execution. The release also allows for programmatic configuration of IO services, thanks to a community contribution, and upgrades the NewtonSoft package to support .NET Core compliant JSON serialization. Additionally, the SDK has renamed the "GetWithLock" method to "GetAndLock" for consistency across platforms, added experimental IPv6 support, and documented a known issue regarding sub-document commands during failover scenarios. Users are encouraged to upgrade, with the SDK available via direct download, NuGet, or GitHub.

The blog post announces the release of PHP SDK 2.0.0 GA, introducing new features, improvements, and fixes, with a focus on the Full Text Search API. The post provides a practical demonstration of using this API with Couchbase 4.5 and the beer-sample bucket to perform a simple search query. It highlights the process of setting up a cluster and bucket, executing a search query, and displaying the results, which include the score and ID of each hit. For installation, the post advises using the command `pecl install couchbase-2.2.0` and ensuring libcouchbase 2.6.1+ is installed, while encouraging users to report issues through Couchbase forums or the issue tracker.

The Go programming language is used to interact with Couchbase Server 4.5+ using the Couchbase Go SDK. A data story for a user profile document with social media information is presented, focusing on manipulations around the social media information. The project starts by creating a connection to a locally running Couchbase cluster and opening the default bucket. A `Person` structure is defined to represent the basic user information, along with a nested `SocialNetworking` structure for social media details. The main function creates an initial data structure, and then uses functions such as `createDocument`, `getDocument`, `getSubDocument`, and `upsertSubDocument` to manipulate the document. These functions demonstrate how to work with fragments of documents using the Couchbase Server Sub-Document API.

The sixth episode of the NoSQL Database Podcast has been released, featuring a discussion between Oren Eini (Ayende Rahien) from RavenDB, .NET expert Matthew Groves, and the podcast host. They discuss RavenDB, a NoSQL database for .NET, covering its technical operation, target audience, and available frameworks or SDKs. The episode can be accessed on major podcasting platforms such as Pocket Casts and iTunes. For any questions related to this episode, contact [email protected].

Ratpack is a framework that allows developers to build web applications using a modular and reactive approach. It integrates well with Spring Boot, making it easy to replace the traditional MVC part of a Spring Boot application with Ratpack. The author of this blog post used Gradle as their build tool and added the necessary dependencies to integrate Ratpack with Spring Boot. They then created a custom configuration class that implements `RatpackServerCustomizer` and defines the handlers, bindings, and server configuration for their application. The authors also demonstrated how to convert synchronous services to asynchronous ones using RxJava and how to wrap blocking legacy code in promises. Overall, this post provides a comprehensive guide on how to integrate Ratpack with Spring Boot and migrate existing applications to a more reactive architecture.

Couchbase has released version 4.5 of its NoSQL database, introducing enhancements such as improved N1QL features, faster queries, indexing, and role-based security. Cloud9 Charts has integrated support for this new version to enable native Business Intelligence (BI) integration, leveraging these new features while maintaining compatibility with previous versions. Key improvements in this release include high-performance joins with Index-JOIN support, array indexing for better performance in queries involving arrays, and memory-optimized indexes for write-intensive workloads. A notable addition is the INFER command, which provides metadata of document structures and facilitates dynamic N1QL query generation. Cloud9 Charts utilizes this functionality to enhance its BI solutions, offering a point-and-click interface for generating N1QL queries, which supports JSON and offers SQL-like familiarity. This integration aims to maximize the potential of N1QL for users of Couchbase.