Database Clients

CouchProxy is a simple proxy server that distributes reads and writes to a cluster of Apache CouchDB servers so they appear to be a single huge database. Documents are stored and retrieved from a particular CouchDB instance, using consistent hashing of the document id. Map/reduce views are processed concurrently on each CouchDB instance and merged together by the proxy before returning the results to the client.

SQL client for any JDBC-compliant database. Written in JRuby.

Ruby client for Datakick - the open product database

em-synchrony-couchdb is a simple, convenient, and non-blocking client for CouchDB implemented using the em-synchrony version of EventMachine::HttpRequest and based completely on the em-couchdb gem. With em-synchrony-couchdb, you can easily save, query, delete documents, databases to/from a CouchDB database in your favourite language - Ruby.

Ruby REST client for Delphix virtual database appliance

Axibase Time Series Database Client for Ruby is an easy-to-use client for interfacing with ATSD metadata and data REST API services.

Client for communication with Czech Database of Distraints. Connected to Bisnode WS CEE SOAP API.

Small, lightweight CouchDB client and object document mapper. Library is meant to be kept lean while still exposing the most powerful features of the database. Took a little inspiration from outoftime/sunspot.

Bucket Client is a ruby gem that allows programmers to interact with popular Blob Storage cloud services. This intends to act as a layer of abstraction, much like ORM is to databases. With this, you may easily change the blob storage provider or even defer them. The supported cloud storage include: - Google Cloud Platform Cloud Storage - Amazon Web Service S3 Bucket - Digital Ocean Spaces - Azure Blob Storage (Microsoft).

Client for the Bandicoot relational algebra database.

The client allows you to interface to the nVentory database, to register nodes, retrieve info about nodes or update them.

== README.md: #ScheduledResource This gem is for displaying how things are used over time -- a schedule for a set of "resources". You can configure the elements of the schedule and there are utilities and protocols to connect them: - Configuration (specification and management), - Query interfaces (a REST-like API and internal protocols to query the models), and - A basic Rails controller implementation. We have a way to configure the schedule, internal methods to generate the data, and a way to retrieve data from the client. However this gem is largely view-framework agnostic. We could use a variety of client-side packages or even more traditional Rails view templates to generate HTML. In any case, to get a good feel in a display like this we need some client-side code. The gem includes client-side modules to: - Manage <b>time and display geometries</b> with "infinite" scroll along the time axis. - <b>Format display cells</b> in ways specific to the resource models. - <b>Update text justification</b> as the display is scrolled horizontally. ## Configuration A **scheduled resource** is something that can be used for one thing at a time. So if "Rocky & Bullwinkle" is on channel 3 from 10am to 11am on Saturday, then 'channel 3' is the <u>resource</u> and that showing of the episode is a <u>resource-use</u> block. Resources and use-blocks are typically Rails models. Each resource and its use-blocks get one row in the display. That row has a label to the left with some timespan visible on the rest of the row. Something else you would expect see in a schedule would be headers and labels -- perhaps one row with the date and another row with the hour. Headers and labels also fit the model of resources and use-blocks. Basic timezone-aware classes (ZTime*) for those are included in this gem. ### Config File The schedule configuration comes from <tt>config/resource_schedule.yml</tt> which has three top-level sections: - ResourceKinds: A hash where the key is a Resource and the value is a UseBlock. (Both are class names), - Resources: A list where each item is a Resource Class followed by one or more resource ids, and - visibleTime: The visible timespan of the schedule in seconds. The example file <tt>config/resource_schedule.yml</tt> (installed when you run <tt>schedulize</tt>) should be enough to display a two-row schedule with just the date above and the hour below. Of course you can monkey-patch or subclass these classes for your own needs. ### The schedule API The 'schedule' endpoint uses parameters <tt>t1</tt> and <tt>t2</tt> to specify a time interval for the request. A third parameter <tt>inc</tt> allows an initial time window to be expanded without repeating blocks that span those boundaries. The time parameters _plus the configured resources_ define the data to be returned. ### More About Configuration Management The <b>ScheduledResource</b> class manages resource and use-block class names, id's and labels for a schedule according to the configuration file. A ScheduledResource instance ties together: 1. A resource class (eg TvStation), 2. An id (a channel number in this example), and 3. Strings and other assets that will go into the DOM. The id is used to - select a resource _instance_ and - select instances of the _resource use block_ class (eg Program instances). The id _could_ be a database id but more often is something a little more suited to human use in the configuration. In any case it is used by model class method <tt>(resource_use_block_class).get_all_blocks()</tt> to select the right use-blocks for the resource. A resource class name and id are are joined with a '_' to form a tag that also serves as an id for the DOM. Once the configuration yaml is loaded that data is maintained in the session structure. Of course having a single configuration file limits the application's usefulness. A more general approach would be to have a user model with login and configuration would be associated with the user. ## Installation Add this line to your application's Gemfile: ```ruby gem 'scheduled_resource' ``` And then execute: $ bundle Or install it yourself as: $ gem install scheduled_resource Then from your application's root execute: $ schedulize . This will install a few image placeholders, client-side modules and a stylesheet under <tt>vendor/assets</tt>, an example configuration in <tt>config/resource_schedule.yml</tt> and an example controller in <tt>app/controllers/schedule_controller.rb</tt>. Also, if you use $ bundle show scheduled_resource to locate the installed source you can browse example classes <tt>lib/z_time_*.rb</tt> and the controller helper methods in <tt>lib/scheduled_resource/helper.rb</tt> ## Testing This gem also provides for a basic test application using angularjs to display a minimal but functional schedule showing just the day and hour headers in two different timezones (US Pacific and Eastern). Proceed as follows, starting with a fresh Rails app: $ rails new test_sr As above, add the gem to the Gemfile, then $ cd test_sr $ bundle $ schedulize . Add lines such as these to <tt>config/routes.rb</tt> get "/schedule/index" => "schedule#index" get "/schedule" => "schedule#schedule" Copy / merge these files from the gem source into the test app: $SR_SRC/app/views/layouts/application.html.erb $SR_SRC/app/views/schedule/index.html.erb $SR_SRC/app/assets/javascripts/{angular.js,script.js,controllers.js} and add <tt>//= require angular</tt> to application.js just below the entries for <tt>jquery</tt>. After you run the server and browse to http://0.0.0.0:3000/schedule/index you should see the four time-header rows specified by the sample config file. ## More Examples A better place to see the use of this gem is at [tv4](https://github.com/emeyekayee/tv4). Specifically, models <tt>app/models/event.rb</tt> and <tt>app/models/station.rb</tt> give better examples of implementing the ScheduledResource protocol and adapting to a db schema organized along somewhat different lines. ## Contributing 1. Fork it ( https://github.com/emeyekayee/scheduled_resource/fork ) 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Add some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create a new Pull Request

A Ruby database driver for ClickHouse (also Clickhouse CLI and web GUI included)

Isolated multi-tenant Ruby on Rails engine to manage translations in the database in-place or in a backend with option to fork other translation databases or to request translations from a Crowdsourcing platform like Volontari.at

This is the ruby client of DBChain. DBChain is a blockchain based relational database. Developers can use traditional ways to quickly develop blockchain applications with DBChain.

The Ruboss Framework brings the design principles and productivity of Rails to Flex development, and makes integration with RESTful APIs as simple as possible. Here's some of the things you can do: * *Create* a complete _Adobe_ _Flex_ or _AIR_ application in less than 5 minutes. Use our lightweight Ruby-based code generation toolkit to create a fully functional CRUD application. Simply do: sudo gem install ruboss4ruby And then run: ruboss-gen -h * *Integrate* with _Ruby_ _On_ _Rails_, _Merb_ or _Sinatra_ applications that use _ActiveRecord_, _DataMapper_, _CouchRest_, _ActiveCouch_, etc. * *Communicate* between your Flex/AIR rich client and service providers using either _XML_ or _JSON_. * *Persist* your data directly in Adobe AIR's _SQLite_ database or _CouchDB_ without any additional infrastructure or intermediate servers. * *Deploy* your Ruboss application on the Google App Engine and use Google DataStore for persistence.

A Client for the Internet Game Database

LiveJournal API client. Fork of the original livejournal gem. Post to livejournal, retrieve friends lists, edit entries, sync journal to an offline database.

A Ruby client for the Cassandra distributed database.

Ruby client for the Empire API. Empire is an API for accessing enterprise SaaS services such as Salesforce, Zendesk, Google Apps, etc. Empire provides a uniform, database-like interface to every service that it supports. Empire makes it easy to integrate data from multiple enterprise services into your own enterprise app.

Client library for interacting with HBase the Hadoop database.

Sometimes you need to collect data before you can write it to the database. That is the impedius for this gem. The collection of data could happen across multiple client interactions spanning pages or even sessions.

Always network clients require a connection pool, like database connection, cache connection and others. Generic connection pool can be used with anything. It is extracted from ActiveRecord ConnectionPool. Sharing a limited number of network connections among many threads. Connections are created delayed.

Client library for Passrock Binary Database

A ruby client to help with interacting to http://www.sportsdatabase.com/api.

The Dictionary Server Protocol (DICT) is a TCP transaction based query/response protocol that allows a client to access dictionary definitions from a set of natural language dictionary databases. See RFC 2229 for details. http://tools.ietf.org/html/rfc2229

A database cli in Ruby, like the psql client for Postgres.

Ruby client for the Empire API. Empire is an API for accessing enterprise SaaS services such as Salesforce, Zendesk, Google Apps, etc. Empire provides a uniform, database-like interface to every service that it supports. Empire makes it easy to integrate data from multiple enterprise services into your own enterprise app.

A Rake task to painlessly open a database shell. Launches the command line client of the current Rails environment's database and automatically connects to the right database.

A gRPC-client that allows to interact with the Reindexer document-oriented database

Client for Tempest Graph Database.

DashCreator is a client-side dashboard creator gem. It can be used with any database to create filters, charts and dashboards of your own with a graphical interface.

Pure Ruby client for VoltDB - one of the fastest in-memory databases on the planet. Threadsafe and fast enough wire client implementation, based on protocol specifications Version 1 (01/26/2016).

The VWS API client was created to allow developers programmatically interact with Vuforia’s cloud recognition system. Use the VWS API client to upload image targets into the Vuforia system, add application metadata, and monitor the status of databases and targets.

riak-client is a rich client for Riak, the distributed database by Basho. It supports the full HTTP and Protocol Buffers interfaces including storage operations, bucket configuration, link-walking, secondary indexes and map-reduce.

The gem makes it easier to switch databases at runtime without the need to configure them all in `mongoid.yml` file. This is helpful when you do not know the databases you're connecting to at the build time, say you're developing a multi-tenancy or a white-labeable application where every tenant has its own database and you do not have the ability to enumerate them all in `mongoid.yml`

Client library for accessing the imedo doctor search database

Client for Hypesets database. Hypesets is a persisted database for counting unique objects.

The aim of JSON-Lisp is to allow for an executable code format that is simple and portable, as well as easy to parse and execute in a controlled, sandboxed environment. This allows it to be stored in a database, sent over an HTTP connection, collected from user input, and executed on either a client or a server's machine.

Ruby client library for Errdb(Extensibel Round Robin Database)

Serve several clients with one single database with incremental and secure ids by tenant.

A Ruby client for the Cassandra distributed database.

A Ruby client for the Cassandra distributed database.

This gem provides an abstraction layer to define Firebase Realtime Database models and basic services. Once the model was defined you can generate a client library to Android, Swift and Javascript.

Connects to a Neo4J database using the REST interface but executes queries only using cypher

Programatical Interface to the RIPE Database API (REST Client) - THIS IS NOT YET READY FOR PRIME TIME

Ruby client for the Karma key-counter database

A Web DB client for managing your database by rails engine.

Easily and directly query database backup files, convert into other file formats.

The Oracle Database@Google Cloud API provides a set of APIs to manage Oracle database services, such as Exadata and Autonomous Databases. Note that google-cloud-oracle_database-v1 is a version-specific client library. For most uses, we recommend installing the main client library google-cloud-oracle_database instead. See the readme for more details.