A native Microsoft SQL Server (TDS) client for Rust.

Tiberius A native Microsoft SQL Server (TDS) client for Rust. Supported SQL Server versions Version Support level Notes 2019 Tested on CI 2017 Tested

Information

Category: Rust / Database
Watchers: 15
Star: 250
Fork: 98
Last update: Nov 19, 2023

Resource links

https://github.com/prisma/tiberius

README
Issues 70

Tiberius

A native Microsoft SQL Server (TDS) client for Rust.

Supported SQL Server versions

Version	Support level	Notes
2019	Tested on CI
2017	Tested on CI
2016	Should work
2014	Should work
2012	Should work
2008	Should work
2005	Should work	With feature flag `tds73` disabled.

Documentation

The system should work with the Docker and Azure versions of SQL Server without trouble. For installing with Windows systems, please don't forget the following things:

Feature flags

Flag	Description	Default
`tls`	Enables TLS support.	`enabled`
`chrono`	Support for Chrono's datetime structures.	`enabled`
`tds73`	Support for new date and time types in TDS version 7.3. Disable if using version 7.2.	`enabled`
`rust_decimal`	Read and write `numeric`/`decimal` values using `rust_decimal`'s `Decimal`.	`disabled`
`sql-browser-async-std`	SQL Browser implementation for the `TcpStream` of async-std.	`disabled`
`sql-browser-tokio`	SQL Browser implementation for the `TcpStream` of Tokio.	`disabled`

Supported protocols

Tiberius does not rely on any protocol when connecting to an SQL Server instance. Instead the Client takes a socket that implements the AsyncRead and AsyncWrite traits from the futures-rs crate.

Currently there are good async implementations for TCP in the async-std, Tokio and Smol projects. To be able to use them together with Tiberius on Windows platforms with SQL Server, the TCP should be enabled in the server settings (disabled by default). In the offficial Docker image TCP is is enabled by default.

To use named pipes, Miow provides the NamedPipe that implements sync Read and Write traits. With some extra work one could write a crate that implements the AsyncRead and AsyncWrite traits to it. When this happens, Tiberius will support named pipes without any changes to the crate code.

The shared memory protocol is not documented and seems there is no Rust crates implementing it.

Encryption (TLS/SSL)

a) Make sure to use a trusted certificate

Make sure the certificate your using is trusted by your local machine. To create a self-signed certificate that is trusted you can use the following powershell:

$cert = New-SelfSignedCertificate -DnsName $serverName,localhost -CertStoreLocation cert:\LocalMachine\My
$rootStore = Get-Item cert:\LocalMachine\Root
$rootStore.Open("ReadWrite")
$rootStore.Add($cert)
$rootStore.Close();

You also have to change the certificate in the SQL Server settings.
In a production setting you likely want to use a certificate that is issued by a CA.

b) Disable certificate validation by using `TrustServerCertificate=true` in your connection string (requires 0.2.2)

c) Alternatively: Disable Encryption for LOCALHOST

For a connection to localhost, which will never leave your machine, it's safe to disable encryption. Currently this is only possible by doing someting like the following in your cargo.toml:

tiberius = { version = "0.X", default-features=false, features=["chrono"] }

This will disable encryption for your ENTIRE crate

70 Open More issues

Closed

Async/await TODO

Things to do until hitting the publish button for the async/await version of Tiberius. Started from a state where the transportation and quite a many basic types already work and are usable.

[x] date/datetimeoffset/datetime2/smalldatetime/datetime/time types
[x] text/ntext types
[x] binary/varbinary
[x] image
[x] xml
[x] User-defined types
[ ] Transaction system. Maybe the connection should finally be Arc<Mutex<Connection>> in the Client, so a transaction can roll back on Drop if needed. (https://github.com/prisma/tiberius/issues/28)
[x] Guid type
[x] Execute doesn't really need to be a stream, The results should be collected to a vector for better error handling and provided as an iterator or using the total method.
[x] ADO.NET connection strings
[x] Testing SSPI windows login (on windows)
[x] Windows authentication
[x] Testing SQL browser mode (on windows)
[x] Testing TLS
[x] Testing Azure
[ ] Builder and connection should handle all possible features and options.
[x] AppVeyor setup for this fork.
[x] Work on tokio, async-std and smol (https://github.com/prisma/tiberius/issues/29)
[x] Fix numeric handling (https://github.com/prisma/tiberius/issues/31)

opened Apr 21, 2020 by pimeys 15

Closed

Problem with blob (type=Image) query

It is fantastic to see new progress in tiberius. I had tried to use a much earlier version but no support of blob types was a show stopper.

I have tried using the sample code from the documentation, both against the tokio and the async-std executors. My database is Microsoft SQL Server 2016 (SP2-CU8) (KB4505830) - 13.0.5426.0 (X64) .

A simple SELECT query worked fine with both executors, however when I tried another query which retrieved a single row with two columns, row index (integer key column) and corresponding BLOB (Image type), from another table the result is corrupted:

let mut stream = client.simple_query(_query2).await?;
assert!(stream.next_resultset());
println!("{:?}",stream.columns().unwrap());

returns the name of the index and BLOB column

[Column { name: "i", column_type: Int4 }, Column { name: "琀攀猀琀搀愀琀愀开戀氀漀戀", column_type: Image }]

The types are correct for both columns but the column name for the BLOB column should be 'b'. It is corrupted. Also if I continue on and try extract the rows I get a "Error: Protocol error: invalid token type 0".

I am not overriding the default tiberius features and get the same results with the latest stable rust on both Windows and Ubuntu 64bit. Any suggestions for how to debug this?

I tried running the same query with freetds "tsql" and it returned the correct data.

opened Jun 12, 2020 by wackydoo 12

Closed

future cannot be sent between threads safely

I had problems with the "old tiberius" when I tried to use it with async web frameworks like actix or warp. I ended up having to run the tiberius stuff with something like tokio::task::spawn_local and use channels to connect the web part with the tiberius part. Which was a pain.

Maybe I'm not doing something correctly or maybe using something like deadpool could help.

[dependencies]
futures = "0.3.5"
tiberius = "0.4.0-alpha.6"
tokio = { version = "0.2", features = [ "process", "rt-util", "macros", "rt-core" ] }

use futures::stream::StreamExt;
use futures::stream::TryStreamExt;
use tiberius::{AuthMethod, Client};

async fn something(mut conn: Client) -> Vec<i8> {
    let mut stream = conn
        .query("SELECT @P1 AS first; SELECT @P2 AS second", &[&1i32, &2i32])
        .await
        .unwrap();

    let first_result: Vec<Option<i32>> = stream
        .by_ref()
        .map_ok(|x| x.get::<i32, _>(0))
        .try_collect()
        .await
        .unwrap();

    assert!(stream.next_resultset());

    Vec::new()
}

#[tokio::main]
async fn main() {
    let mut builder = Client::builder();
    builder.host("localhost");
    builder.port(1433);
    builder.database("master");
    builder.authentication(AuthMethod::sql_server("SA", "<YourStrong@Passw0rd>"));
    builder.trust_cert();

    let mut conn = builder.build().await.unwrap();

    let f = something(conn);

    tokio::spawn(f);
}

error: future cannot be sent between threads safely
   --> src/main.rs:36:5
    |
36  |     tokio::spawn(f);
    |     ^^^^^^^^^^^^ future returned by `something` is not `Send`
    |
   ::: /home/bbigras/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-0.2.21/src/task/spawn.rs:127:21
    |
127 |         T: Future + Send + 'static,
    |                     ---- required by this bound in `tokio::task::spawn::spawn`
    |
    = help: the trait `std::marker::Sync` is not implemented for `dyn tiberius::to_sql::ToSql`
note: future is not `Send` as this value is used across an await
   --> src/main.rs:6:22
    |
6   |       let mut stream = conn
    |  ______________________^
7   | |         .query("SELECT @P1 AS first; SELECT @P2 AS second", &[&1i32, &2i32])
    | |                                                               ----- has type `&dyn tiberius::to_sql::ToSql` which is not `Send`
8   | |         .await
    | |______________^ await occurs here, with `&1i32` maybe used later
9   |           .unwrap();
    |                    - `&1i32` is later dropped here

error: future cannot be sent between threads safely
   --> src/main.rs:36:5
    |
36  |     tokio::spawn(f);
    |     ^^^^^^^^^^^^ future returned by `something` is not `Send`
    |
   ::: /home/bbigras/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-0.2.21/src/task/spawn.rs:127:21

    |
127 |         T: Future + Send + 'static,
    |                     ---- required by this bound in `tokio::task::spawn::spawn`
    |
    = help: the trait `std::marker::Send` is not implemented for `dyn futures_core::stream::Stream<Item = std::result::Result<tiberius::tds::stream::token::ReceivedToken, tiberius::error::Error>>`
note: future is not `Send` as this value is used across an await
   --> src/main.rs:11:42
    |
6   |       let mut stream = conn
    |           ---------- has type `tiberius::result::QueryResult<'_>` which is not `Send`
...
11  |       let first_result: Vec<Option<i32>> = stream
    |  __________________________________________^
12  | |         .by_ref()
13  | |         .map_ok(|x| x.get::<i32, _>(0))
14  | |         .try_collect()
15  | |         .await
    | |______________^ await occurs here, with `mut stream` maybe used later
...
21  |   }
    |   - `mut stream` is later dropped here

opened Jun 1, 2020 by bbigras 7

Closed

Allow tiberius to be run on multiple runtimes

Main changes

Refactored to a core crate plus a crate for each runtime
Added a macro to tests that can test on all runtimes

I attempted to make the use of the runtime based crates less confusing by having both a local Client and a local ClientBuilder, such that tiberius_<rt>::Client::builder() returns a local ClientBuilder rather than one from the core crate. It would be quite easy to remove this if this is not desired.

opened May 15, 2020 by esheppa 5

Closed

Possibility to use Tiberius with different runtimes

It would be great if we'd be able to use Tiberius with other runtimes than Tokio. This means no spawning, and it also means the underlying transportation protocol should be possible to inject into the connection. TcpStream and TlsStream must be able to be chosen by the user, as long as the streams implement AsyncRead and AsyncWrite from the futures crate. The Tokio counterparts can deal with the abstractions by using Tokio's compat module.

For making it easier for the user, we could provide separate crates:

tiberius-tokio
tiberius-async-std

Or additionally this can be handled with feature flags.

The other part needing replacement is the use of tokio_codec. futures_codec is a good replacement using the standard AsyncRead and AsyncWrite.

One should take into consideration of replacing the bytes crate while doing the refactoring, due to bytes being quite unsafe and triggering segmentation faults if using it wrong. One crate to experiment with is byte_pool, being a safe replacement for bytes. Be aware of writing the corresponding byte extensions to the SqlReadBytes.

enhancement

opened May 9, 2020 by pimeys 5

Closed

Chrono structs doesn't work with default-features disabled

When using like this tiberius = { git = "https://github.com/prisma/tiberius", default-features = false, features = ["chrono"] } there is the trait tiberius::from_sql::FromSql<'_> is not implemented for `chrono::naive::datetime::NaiveDateTime

While same code works for tiberius = { git = "https://github.com/prisma/tiberius"}

opened Jun 3, 2020 by madmaxio 3

Open

Column Encryption

SQL Server supports Column Encryption (CEK), and we should probably implement some kind of support for it in Tiberius.

The client should take the needed keys, and transparently encrypt/decrypt columns if needed.

enhancement

opened Jun 10, 2020 by pimeys 0

Open

Other connection methods than TCP

Currently our documentation is talking about using the server with a TCP client. But in general our implementation does not dictate use of TCP, but a socket that implements AsyncRead and AsyncWrite. So if anybody knows a good named pipe implementations for Windows that implement the async IO traits, this would be the right place to talk about good implementations.

There's work in miow for NamedPipe that implements Read and Write. This needs an IOCP event loop that translates it to the async ecosystem. @yoshuawuyts is looking into implementing that.

The other protocol is the Local Procedure Call (LSP) or the asynchronous version of it (ALSP). This is a non-documented API and I have no idea if anybody is working on implementing Rust bindings to this API. Any tips are appreciated on this ticket. This is also the default connection method on Windows platforms.

In the end, if we have a working socket with the right traits, it should Just Work (tm) with Tiberius without making any changes to the crate.

documentation help wanted question

opened Jun 9, 2020 by pimeys 1

Open

Replace all BytesMut/Bytes with a Vec

We should not rely on bytes crate. A vector would be good enough, safer and in some cases might be even faster.

Tasks

Get rid of futures-codec
No more Sink for Connection, use AsyncWrite
For encoding, use Cursor and byteorder
For convenience, maybe implement a trait/struct that allows ergonomic little-endian writes!

enhancement

opened May 25, 2020 by pimeys 1

Open

Support integratedsecurity on Unix and MacOS

.NET Core supports integratedsecurity on Unix and MacOS via Kerberos through GSSAPI. It seems to all be open source under an MIT license now, so an implementation could be based on .NET Core. 😄

enhancement help wanted

opened May 12, 2020 by edmellum 3

Open

Statements

For better performance with lots of repetitive queries, a proper statement system would be nice. Whenever we execute a query, the server responds with a handle that can be reused with different parameters in the future. This means the query is parsed only once, saving the parsing time in the subsequent calls.

The work required:

query and execute should be able to take either a string or a statement as a parameter.
prepare function to create a new statement
A way of removing dropped statements from the server session

A good example how this could work can be found from steffengy's version.

Options for an API:

a) User keeps statements in memory and uses them when fit. b) We keeping statements in memory in Tiberius, hashing the incoming queries and using the already stored statement if possible.

If taking the approach b, we should be able to turn the feature off by configuration.

enhancement good first issue

opened May 9, 2020 by pimeys 1

Open

Transactions

We need a higher-level system for managing transactions. It is possible to trigger transactions with the normal BEGIN/COMMIT/ROLLBACK mechanism, but an abstraction that handles proper cleanup, committing, rolling back and so on, and offers the same query mechanisms as the Client would be useful.

The transaction should be started from the Client. When started, Rust's ownership system should prevent the usage of Client until the Transaction is dropped. The Transaction should provide at least the basics: execute and query, and additionally rollback and commit methods.

When the Transaction is dropped, it should know did the user finish it properly using the rollback or commit method, and if not, message the client to trigger a rollback before allowing more queries to be handled.

The last part can be done in many ways, and the tricky thing here is if wanting to set the ROLLBACK query in the Drop trait, which is not by design asynchronous. Transaction should have a mutable reference to the Client, so one way of doing this would be to set a flag in the Client about a dirty state, and the client (or Connection) takes care of triggering the ROLLBACK call before executing the next query.

enhancement

opened May 9, 2020 by pimeys 3

Microsoft Drivers for PHP for SQL Server

The Microsoft JDBC Driver for SQL Server is a Type 4 JDBC driver that provides database connectivity with SQL Server through the standard JDBC application program interfaces (APIs).

SQL Server Adapter For Rails

A set helpers for writing dynamic SQL queries with `pg-sql` in Javascript.

A benchmarking shootout of various db/SQL utilities for Go

SQL template strings, protecting against SQL injection

Azure Data Studio is a data management tool that enables working with SQL Server, Azure SQL DB and SQL DW from Windows, macOS and Linux.

An unofficial Microsoft Machine Learning Server Docker image.

A simple program to convert SQL rows into Microsoft Excel XLSX files.

PowerShell module for working with Azure SQL that supports tab completions, SSO, and using native SQL files

Visual Studio Code SQL Server extension.

Microsoft SEAL is an easy-to-use and powerful homomorphic encryption library.

Golang ORM with focus on PostgreSQL features and performance

The C++ REST SDK is a Microsoft project for cloud-based client-server communication in native code using a modern asynchronous C++ API design. This project aims to help C++ developers connect to and interact with services.

Microsoft SQL server adapter for REL written in Golang.

A React-Native Client for V2EX

Automatic import file (CSV, JSON) file to database (PostgreSQL | MySQL | SQLite | Oracle | Microsoft SQL Server)

Independent query builders for MySQL, PostgreSQL, SQLite, and Microsoft SQL Server.

Experimenting on ETL from Elasticsearch to Microsoft SQL Server through Logstash

PyPika is a python SQL query builder that exposes the full richness of the SQL language using a syntax that reflects the resulting query. PyPika excels at all sorts of SQL queries but is especially useful for data analysis.

sql interface for solr cloud

Share this repo

Related Repos

Database

🌍 MaxMindDB GeoIP database querying module for Garry's Mod

🌍 gm_maxminddb_geoip This module reads, queries and serializes to Lua tables data from the MaxMindDB GeoIP database. In other words, IP address goes

Database

Query GitHub Projects (beta) with SQL

gh-sql: Query GitHub Projects (beta) with SQL Installation gh extension install KOBA789/gh-sql NOTE: Currently, only linux-amd64 and darwin-amd64 are

Database

214

SQLite + Little Raft = 🚀

ChiselStore ChiselStore is an embeddable, distributed SQLite for Rust, powered by Little Raft. SQLite is a fast and compact relational database manage

Database

997

🚦 Microservices Status Page. Monitors a distributed infrastructure and sends alerts (Slac...

Vigil Microservices Status Page. Monitors a distributed infrastructure and sends alerts (Slack, SMS, etc.). Vigil is an open-source Status Page you ca

Database

sqlite3 Rewritten in RiiR Rust 🦀🦀🦀

Database

2.5k

GlueSQL is a SQL database library written in Rust.

GlueSQL is a SQL database library written in Rust. It provides a parser (sqlparser-rs), execution layer, and optional storage (sled) packaged into a single library. Developers can choose to use GlueSQL to build their own SQL database, or as an embedded SQL database using the default storage engine.

Database

2.5k

A cross-platform TUI database management tool written in Rust

Database

201

Engula empowers engineers to build reliable and cost-effective databases.

Engula is a storage engine that empowers engineers to build reliable and cost-effective databases with less effort and more confidence.

Database

1.8k

Skytable is an extremely fast, secure and reliable real-time NoSQL database with automated...

Skytable is an effort to provide the best of key/value stores, document stores and columnar databases, that is, simplicity, flexibility and queryability at scale

Database

Tool to view and solve puzzles from the lichess puzzle database

offline-chess-puzzles Tool to view and solve puzzles from the lichess puzzle database. It's a very simple tool for those who want to practice offline,

Database

306

SQLite clone from scratch in Rust

Project name is a Rust-SQLite, someone suggested SQLRite because is being developed in Rust and I like it, anyway the goal is write a database modeled off SQLite, in Rust.

Database

2.9k

GraphScope: A One-Stop Large-Scale Graph Computing System from Alibaba

GraphScope is a unified distributed graph computing platform that provides a one-stop environment for performing diverse graph operations on a cluster of computers through a user-friendly Python interface.