duckdb 0.0.12 → 0.2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a0f6c8a46cecbe281cf970b5e8c6fd11c2903a5ddd58bf683341bcb299d7a36
-  data.tar.gz: 6ba452c2aa37f77c68905413e3bb6cb27697f8db23bfeca1e8ca1886ce6fb1ab
+  metadata.gz: 96e1030a16d014daaab4b84c0c15cde0d023fcb0fb761bee97056127f3530533
+  data.tar.gz: 2010828495199a8959b2246c0de6262de273387daaa3b3b9a8ebbca6e2fda47c
 SHA512:
-  metadata.gz: beb0db8d6e590ee4014aa4fb1e09a7093d6b13cebe3ad38f90cf6f29707b5e768696732f33c5d53027032ba7eacc8bf8ddecb9b112a042f05b17bbb98e086197
-  data.tar.gz: 228651ac8ed6c13044cbf0e3709444464ff552b0b431b051446def7dce074b38ef8a242f72e75c8c1ba788ae13dfc88a2041f7f2e9e70b64fb3c34c9c2c8ad85
+  metadata.gz: da434b1e0f179cf6392beb998be0eba637cd782a74a4ea4474752b1c900afe1cbf43a5816cb7ff37c8b6e34226a0a2bcc4e4e89e54c28697e5ec39695775f31f
+  data.tar.gz: be2f05c2b472db0e548da9acd69aebd41ff0685fdcf925970af36d489882539a88fb51c49a791edd1e4f34daf9aac16311e15ce6771e9f504b987e1d29e1aa93

data/.github/workflows/test_on_macos.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        ruby: ['2.5.8', '2.6.6', '2.7.2', '3.0.0', 'head']
+        ruby: ['2.5.8', '2.6.7', '2.7.3', '3.0.1', 'head']
 
     steps:
     - uses: actions/checkout@v2
@@ -17,15 +17,9 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby }}
 
-    - name: Install duckdb
-      env:
-        DUCKDB_VERSION: 0.2.4
+    - name: Install latest duckdb by brew
       run: |
         brew install duckdb
-        git clone -b v${DUCKDB_VERSION} https://github.com/cwida/duckdb.git duckdb-v${DUCKDB_VERSION}
-        cp duckdb-v${DUCKDB_VERSION}/src/include/duckdb.h /usr/local/include
-        mkdir -p /usr/local/include/duckdb/common
-        cp duckdb-v${DUCKDB_VERSION}/src/include/duckdb/common/winapi.hpp /usr/local/include/duckdb/common
 
     - name: Build and test with Rake with Ruby ${{ matrix.ruby }}
       run: |

data/.github/workflows/test_on_ubuntu.yml

@@ -8,8 +8,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ['2.5.8', '2.6.6', '2.7.2', '3.0.0', 'head']
-        duckdb: ['0.2.4', '0.2.5']
+        ruby: ['2.5.8', '2.6.7', '2.7.3', '3.0.1', 'head']
+        duckdb: ['0.2.6', '0.2.5']
 
     steps:
     - uses: actions/checkout@v2
@@ -19,14 +19,14 @@ jobs:
       with:
         ruby-version: ${{ matrix.ruby }}
 
-    - name: duckdb 0.2.4 cache
-      id: duckdb-cache-v0_2_4
+    - name: duckdb 0.2.6 cache
+      id: duckdb-cache-v0_2_6
       uses: actions/cache@v1.1.0
       with:
-        path: duckdb-v0.2.4
-        key: ${{ runner.os }}-duckdb-v0_2_4_001
+        path: duckdb-v0.2.6
+        key: ${{ runner.os }}-duckdb-v0_2_6_001
         restore-keys: |
-          ${{ runner.os }}-duckdb-v0_2_4
+          ${{ runner.os }}-duckdb-v0_2_6
 
     - name: duckdb 0.2.5 cache
       id: duckdb-cache-v0_2_5
@@ -37,15 +37,15 @@ jobs:
         restore-keys: |
           ${{ runner.os }}-duckdb-v0_2_5
 
-    - name: Build duckdb 0.2.4
-      if: steps.duckdb-cache-v0_2_4.outputs.cache-hit != 'true'
+    - name: Build duckdb 0.2.6
+      if: steps.duckdb-cache-v0_2_6.outputs.cache-hit != 'true'
       run: |
-        git clone -b v0.2.4 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.4
-        cd duckdb-tmp-v0.2.4 && make && cd ..
-        rm -rf duckdb-v0.2.4
-        mkdir -p duckdb-v0.2.4/build/release/src duckdb-v0.2.4/src
-        cp -rip duckdb-tmp-v0.2.4/build/release/src/*.so duckdb-v0.2.4/build/release/src
-        cp -rip duckdb-tmp-v0.2.4/src/include duckdb-v0.2.4/src/
+        git clone -b v0.2.6 https://github.com/cwida/duckdb.git duckdb-tmp-v0.2.6
+        cd duckdb-tmp-v0.2.6 && make && cd ..
+        rm -rf duckdb-v0.2.6
+        mkdir -p duckdb-v0.2.6/build/release/src duckdb-v0.2.6/src
+        cp -rip duckdb-tmp-v0.2.6/build/release/src/*.so duckdb-v0.2.6/build/release/src
+        cp -rip duckdb-tmp-v0.2.6/src/include duckdb-v0.2.6/src/
 
     - name: Build duckdb 0.2.5
       if: steps.duckdb-cache-v0_2_5.outputs.cache-hit != 'true'

data/.travis.yml

@@ -2,17 +2,17 @@ language: ruby
 cache:
   bundler: true
   directories:
-    - ${HOME}/duckdb-v0.2.5
+    - ${HOME}/duckdb-v0.2.6
 before_install:
   - yes | gem update --system
-  - if [[ ! -d ${HOME}/duckdb-v0.2.5/build ]]; then cd ${HOME} && git clone -b v0.2.5 https://github.com/cwida/duckdb.git duckdb-v0.2.5 && cd duckdb-v0.2.5 && make && cd ${TRAVIS_BUILD_DIR}; fi
+  - if [[ ! -d ${HOME}/duckdb-v0.2.6/build ]]; then cd ${HOME} && git clone -b v0.2.6 https://github.com/cwida/duckdb.git duckdb-v0.2.6 && cd duckdb-v0.2.6 && make && cd ${TRAVIS_BUILD_DIR}; fi
 
 env:
-  - DUCKDB_VERSION=0.2.5
+  - DUCKDB_VERSION=0.2.6
 rvm:
   - 2.5.8
-  - 2.6.6
-  - 2.7.2
-  - 3.0.0
+  - 2.6.7
+  - 2.7.3
+  - 3.0.1
   - ruby-head
 script: bundle exec rake -- --with-duckdb-include=${HOME}/duckdb-v${DUCKDB_VERSION}/src/include --with-duckdb-lib=${HOME}/duckdb-v${DUCKDB_VERSION}/build/release/src/

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # ChangeLog
 
+# 0.2.6.0
+
+- change version policy
+  - ruby-duckdb W.X.Y.Z supports duckdb W.X.Y
+- add DuckDB::Appender
+- bump DuckDB to v0.2.6 in CI.
+- remove unnecessary duckdb header file from MacOS CI.
+- add DuckDB::Connection#prepared_statement.
+
 ## 0.0.12
 
 - bump DuckDB to v0.2.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    duckdb (0.0.12)
+    duckdb (0.2.6.0)
 
 GEM
   remote: https://rubygems.org/
@@ -22,4 +22,4 @@ DEPENDENCIES
   rake-compiler
 
 BUNDLED WITH
-   2.2.3
+   2.2.17

data/ext/duckdb/appender.c

@@ -0,0 +1,315 @@
+#include "ruby-duckdb.h"
+
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+static VALUE cDuckDBAppender;
+
+static void deallocate(void *);
+static VALUE allocate(VALUE klass);
+static VALUE appender_initialize(VALUE klass, VALUE con, VALUE schema, VALUE table);
+static VALUE appender_begin_row(VALUE self);
+static VALUE appender_end_row(VALUE self);
+static VALUE appender_append_bool(VALUE self, VALUE val);
+static VALUE appender_append_int8(VALUE self, VALUE val);
+static VALUE appender_append_int16(VALUE self, VALUE val);
+static VALUE appender_append_int32(VALUE self, VALUE val);
+static VALUE appender_append_int64(VALUE self, VALUE val);
+static VALUE appender_append_uint8(VALUE self, VALUE val);
+static VALUE appender_append_uint16(VALUE self, VALUE val);
+static VALUE appender_append_uint32(VALUE self, VALUE val);
+static VALUE appender_append_uint64(VALUE self, VALUE val);
+static VALUE appender_append_float(VALUE self, VALUE val);
+static VALUE appender_append_double(VALUE self, VALUE val);
+static VALUE appender_append_varchar(VALUE self, VALUE val);
+static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len);
+static VALUE appender_append_blob(VALUE self, VALUE val);
+static VALUE appender_append_null(VALUE self);
+static VALUE appender_flush(VALUE self);
+static VALUE appender_close(VALUE self);
+
+static void deallocate(void * ctx)
+{
+    rubyDuckDBAppender *p = (rubyDuckDBAppender *)ctx;
+
+    duckdb_appender_destroy(&(p->appender));
+    xfree(p);
+}
+
+static VALUE allocate(VALUE klass)
+{
+    rubyDuckDBAppender *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBAppender));
+    return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
+}
+
+static VALUE appender_initialize(VALUE self, VALUE con, VALUE schema, VALUE table) {
+
+    rubyDuckDBConnection *ctxcon;
+    rubyDuckDBAppender *ctx;
+    char *pschema = 0;
+
+    if (!rb_obj_is_kind_of(con, cDuckDBConnection)) {
+        rb_raise(rb_eTypeError, "1st argument should be instance of DackDB::Connection");
+    }
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+    Data_Get_Struct(con, rubyDuckDBConnection, ctxcon);
+
+    if (schema != Qnil) {
+        pschema = StringValuePtr(schema);
+    }
+
+    if (duckdb_appender_create(ctxcon->con, pschema, StringValuePtr(table), &(ctx->appender)) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to create appender");
+    }
+    return self;
+}
+
+static VALUE appender_begin_row(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_appender_begin_row(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to flush");
+    }
+    return self;
+}
+
+static VALUE appender_end_row(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_appender_end_row(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to flush");
+    }
+    return self;
+}
+
+static VALUE appender_append_bool(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (val != Qtrue && val != Qfalse) {
+        rb_raise(rb_eArgError, "argument must be boolean");
+    }
+
+    if (duckdb_append_bool(ctx->appender, (val == Qtrue)) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append boolean");
+    }
+    return self;
+}
+
+static VALUE appender_append_int8(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    int8_t i8val = (int8_t)NUM2INT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_int8(ctx->appender, i8val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_int16(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    int16_t i16val = NUM2INT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_int16(ctx->appender, i16val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_int32(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    int32_t i32val = (int32_t)NUM2INT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_int32(ctx->appender, i32val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_int64(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    int64_t i64val = NUM2LL(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_int64(ctx->appender, i64val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_uint8(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    int8_t ui8val = (uint8_t)NUM2UINT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_uint8(ctx->appender, ui8val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_uint16(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    uint16_t ui16val = (uint16_t)NUM2UINT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_uint16(ctx->appender, ui16val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_uint32(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    uint32_t ui32val = (uint32_t)NUM2UINT(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_uint32(ctx->appender, ui32val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_uint64(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    uint64_t ui64val = (int64_t)NUM2ULL(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_uint64(ctx->appender, ui64val) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_float(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    float fval = (float)NUM2DBL(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_float(ctx->appender, fval) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_double(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    double dval = NUM2DBL(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_double(ctx->appender, dval) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_varchar(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+    char *pval = StringValuePtr(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_varchar(ctx->appender, pval) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_varchar_length(VALUE self, VALUE val, VALUE len) {
+    rubyDuckDBAppender *ctx;
+
+    char *pval = StringValuePtr(val);
+    idx_t length = (idx_t)NUM2ULL(len);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_varchar_length(ctx->appender, pval, length) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_blob(VALUE self, VALUE val) {
+    rubyDuckDBAppender *ctx;
+
+    char *pval = StringValuePtr(val);
+    idx_t length = (idx_t)RSTRING_LEN(val);
+
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_blob(ctx->appender, (void *)pval, length) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_append_null(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_append_null(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to append");
+    }
+    return self;
+}
+
+static VALUE appender_flush(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_appender_flush(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to flush");
+    }
+    return self;
+}
+
+static VALUE appender_close(VALUE self) {
+    rubyDuckDBAppender *ctx;
+    Data_Get_Struct(self, rubyDuckDBAppender, ctx);
+
+    if (duckdb_appender_close(ctx->appender) == DuckDBError) {
+        rb_raise(eDuckDBError, "failed to flush");
+    }
+    return self;
+}
+
+void init_duckdb_appender(void) {
+    cDuckDBAppender = rb_define_class_under(mDuckDB, "Appender", rb_cObject);
+    rb_define_alloc_func(cDuckDBAppender, allocate);
+    rb_define_method(cDuckDBAppender, "initialize", appender_initialize, 3);
+    rb_define_method(cDuckDBAppender, "begin_row", appender_begin_row, 0);
+    rb_define_method(cDuckDBAppender, "end_row", appender_end_row, 0);
+    rb_define_method(cDuckDBAppender, "append_bool", appender_append_bool, 1);
+    rb_define_method(cDuckDBAppender, "append_int8", appender_append_int8, 1);
+    rb_define_method(cDuckDBAppender, "append_int16", appender_append_int16, 1);
+    rb_define_method(cDuckDBAppender, "append_int32", appender_append_int32, 1);
+    rb_define_method(cDuckDBAppender, "append_int64", appender_append_int64, 1);
+    rb_define_method(cDuckDBAppender, "append_uint8", appender_append_uint8, 1);
+    rb_define_method(cDuckDBAppender, "append_uint16", appender_append_uint16, 1);
+    rb_define_method(cDuckDBAppender, "append_uint32", appender_append_uint32, 1);
+    rb_define_method(cDuckDBAppender, "append_uint64", appender_append_uint64, 1);
+    rb_define_method(cDuckDBAppender, "append_float", appender_append_float, 1);
+    rb_define_method(cDuckDBAppender, "append_double", appender_append_double, 1);
+    rb_define_method(cDuckDBAppender, "append_varchar", appender_append_varchar, 1);
+    rb_define_method(cDuckDBAppender, "append_varchar_length", appender_append_varchar_length, 2);
+    rb_define_method(cDuckDBAppender, "append_blob", appender_append_blob, 1);
+    rb_define_method(cDuckDBAppender, "append_null", appender_append_null, 0);
+    rb_define_method(cDuckDBAppender, "flush", appender_flush, 0);
+    rb_define_method(cDuckDBAppender, "close", appender_close, 0);
+}
+#endif /* HAVE_DUCKDB_APPENDER_CREATE */

data/ext/duckdb/appender.h

@@ -0,0 +1,17 @@
+#ifndef RUBY_DUCKDB_APPENDER_H
+#define RUBY_DUCKDB_APPENDER_H
+
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+struct _rubyDuckDBAppender {
+    duckdb_appender appender;
+};
+
+typedef struct _rubyDuckDBAppender rubyDuckDBAppender;
+
+void init_duckdb_appender(void);
+
+#endif
+
+#endif
+

data/ext/duckdb/duckdb.c

@@ -18,4 +18,10 @@ Init_duckdb_native(void)
     init_duckdb_blob();
 
 #endif /* HAVE_DUCKDB_VALUE_BLOB */
+
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+    init_duckdb_appender();
+
+#endif /* HAVE_DUCKDB_APPENDER_CREATE */
 }

data/ext/duckdb/extconf.rb

@@ -3,5 +3,7 @@ require 'mkmf'
 dir_config('duckdb')
 if have_library('duckdb')
   have_func('duckdb_value_blob', 'duckdb.h')
+  have_func('duckdb_bind_blob', 'duckdb.h')
+  have_func('duckdb_appender_create', 'duckdb.h')
   create_makefile('duckdb/duckdb_native')
 end

data/ext/duckdb/ruby-duckdb.h

@@ -15,6 +15,12 @@
 
 #endif /* HAVE_DUCKDB_VALUE_BLOB */
 
+#ifdef HAVE_DUCKDB_APPENDER_CREATE
+
+#include "./appender.h"
+
+#endif /* HAVE_DUCKDB_APPENDER_CREATE */
+
 extern VALUE mDuckDB;
 extern VALUE cDuckDBDatabase;
 extern VALUE cDuckDBConnection;

data/lib/duckdb/connection.rb

@@ -44,6 +44,14 @@ module DuckDB
       end
     end
 
+    #
+    # returns PreparedStatement object.
+    # The first argument is SQL string.
+    #
+    def prepared_statement(str)
+      PreparedStatement.new(self, str)
+    end
+
     alias execute query
     alias open connect
     alias close disconnect

data/lib/duckdb/version.rb

@@ -1,5 +1,5 @@
 module DuckDB
   # The version string of ruby-duckdb.
   # Currently, ruby-duckdb is NOT semantic versioning.
-  VERSION = '0.0.12'.freeze
+  VERSION = '0.2.6.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duckdb
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.2.6.0
 platform: ruby
 authors:
 - Masaki Suketa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-13 00:00:00.000000000 Z
+date: 2021-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -88,6 +88,8 @@ files:
 - bin/console
 - bin/setup
 - duckdb.gemspec
+- ext/duckdb/appender.c
+- ext/duckdb/appender.h
 - ext/duckdb/blob.c
 - ext/duckdb/blob.h
 - ext/duckdb/connection.c
@@ -131,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.0.dev
 signing_key: 
 specification_version: 4
 summary: This module is Ruby binding for DuckDB database engine.