Database APIs

En Cuisine ! API wrapper, the open database about recipes.

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

Gets JSON data from different APIs to build a local database that can be used in other applications

The tool will allow communication through a Rest API, enabling the retrieval and transmission of data to and from the database. Additionally, it will provide other necessary functions for launching your own CV website.

iplookupapi.com provides a reliable & scalable IP lookup API for software developers. It uses a database of IP addresses associated with cities and other relevant information like time zone, latitude, and longitude.

ADBC is Apache Arrow Database Connectivity. It provides a API that can connect to different databases by wrapping database specific APIs. This is not a new approach. There are existing APIs such as Active Record, Sequel and ODBC. The difference between the existing APIs and ADBC is the focus on large data and performance. ADBC is an important part to use Ruby for data processing. We can extract large data from many databases (not only RDBMSs but also data ware houses and so on) and load large data into many databases with ADBC. To use Ruby for data processing, we need data. ADBC helps it.

Provides a simple, easy to use interface for the Movie Database API.

GQLite is a C++-language library, with a C interface, that implements a small, fast, self-contained, high-reliability, full-featured, Graph Query database engine. The data is stored in a SQLite database, which the fasted and most used SQL database. This enable to achieve high performance and for application to combine Graph queries with traditional SQL queries. GQLite source code is license under the [MIT License](LICENSE) and is free to everyone to use for any purpose. The official repositories contains bindings/APIs for C, C++, Python, Ruby and Crystal. The library is still in its early stage, but it is now fully functional. Development effort has now slowed down and new features are added on a by-need basis. It supports a subset of [OpenCypher](https://opencypher.org/), and the intent is to also support ISO GQL in the future when it become available. Example of use -------------- ```ruby require 'gqlite' begin # Create a database on the file "test.db" connection = GQLite::Connection.new sqlite_filename: "test.db" # Execute a simple query to create a node and return all the nodes value = connection.execute_oc_query("CREATE () MATCH (n) RETURN n") # Print the result if value.nil? puts "Empty results" else puts "Results are #{value.to_s}" end rescue GQLite::Error => ex # Report any error puts "An error has occured: #{ex.message}" end ``` The documentation for the openCypher query language can found in [openCypher](https://gitlab.com/gqlite/GQLite/-/blob/docs/opencypher.md) and for the [API](https://gitlab.com/gqlite/GQLite/-/blob/docs/api.md).

ensembl-api provides a ruby API to the Ensembl databases (http://www.ensembl.org)

Gran Pulse may be used for health checking the project and its dependencies, like database, cache and external APIs

fixture_dependencies is an advanced fixture loader for ActiveRecord and Sequel, allowing the loading of models from YAML fixtures, along with their entire dependency graph. It has the following features: - Fixtures specify association names instead of foreign keys - Support both Sequel and ActiveRecord - Supports many_to_one/belongs_to, one_to_many/has_many, many_to_many/has_and_belongs_to_many, and has_one associations - Loads a fixture's dependency graph in such a manner that foreign key constraints aren't violated - Has a very simple API (FixtureDependencies.load(:model__fixture)) - Handles almost all cyclic dependencies - Includes Rails and Sequel test helpers for Test::Unit (and a Sequel test helper for RSpec) that load fixtures for every test inside a transaction, so fixture data is never left in your database - Adds dynamic fixtures (similar to ActiveRecord) with ERb.

RSCM is to SCM what DBI/JDBC/ODBC are to databases - an SCM-independent API for accessing different SCMs

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

Trackdown is a Ruby gem that easily allows you to geolocate IP addresses. It's a simple, convenient wrapper on top of the MaxMind database. Plug your MaxMind license key and you're good to go. It keeps your MaxMind database updated regularly, and it offers a handy API for Rails applications to fetch country, city, and emoji flag information for any IP address.

A unified Ruby API for popular databases.

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.

The Oracle Database@Google Cloud API provides a set of APIs to manage Oracle database services, such as Exadata and Autonomous Databases.

This is the simple REST client for Oracle Database@Google Cloud API V1. Simple REST clients are Ruby client libraries that provide access to Google services via their HTTP REST API endpoints. These libraries are generated and updated automatically based on the discovery documents published by the service, and they handle most concerns such as authentication, pagination, retry, timeouts, and logging. You can use this client to access the Oracle Database@Google Cloud API, but note that some services may provide a separate modern client that is easier to use.

easy way of accessing a postgres database, both visually and via api

payment help returns you with the strings of information depending on the profile details and your order total price with help of bank api database

An easy to use ruby gem to fetch data from the finalforms database

Provides a RESTful API for database tables for your rails apps.

Adds finalizers to ActiveRecord models to clean up both database child dependencies and external resources (APIs, etc). Finalizers run in background jobs and are fully retryable.