dnim/rust-postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update for API changes

Browse Source
This commit is contained in:
Steven Fackler 2014-02-21 23:18:39 -08:00
parent 721288a024
commit 75de360e9f
7 changed files with 97 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/lib.rs
View File

@ -69,6 +69,7 @@ extern crate extra;
extern crate openssl; extern crate openssl;
extern crate serialize; extern crate serialize;
extern crate sync; extern crate sync;
extern crate time;
#[phase(syntax)] #[phase(syntax)]
extern crate phf_mac; extern crate phf_mac;
extern crate phf; extern crate phf;
@ -568,7 +569,7 @@ impl InnerPostgresConnection {
match if_ok_pg!(self.read_message()) { match if_ok_pg!(self.read_message()) {
ParseComplete => {} ParseComplete => {}
ErrorResponse { fields } => { ErrorResponse { fields } => {
if_ok!(self.wait_for_ready()); try!(self.wait_for_ready());
return Err(PgDbError(PostgresDbError::new(fields))); return Err(PgDbError(PostgresDbError::new(fields)));
} }
_ => unreachable!() _ => unreachable!()
@ -589,14 +590,14 @@ impl InnerPostgresConnection {
_ => unreachable!() _ => unreachable!()
}; };
if_ok!(self.wait_for_ready()); try!(self.wait_for_ready());
// now that the connection is ready again, get unknown type names // now that the connection is ready again, get unknown type names
for param in param_types.mut_iter() { for param in param_types.mut_iter() {
match *param { match *param {
PgUnknownType { oid, .. } => PgUnknownType { oid, .. } =>
*param = PgUnknownType { *param = PgUnknownType {
name: if_ok!(self.get_type_name(oid)), name: try!(self.get_type_name(oid)),
oid: oid oid: oid
}, },
_ => {} _ => {}
@ -607,7 +608,7 @@ impl InnerPostgresConnection {
match desc.ty { match desc.ty {
PgUnknownType { oid, .. } => PgUnknownType { oid, .. } =>
desc.ty = PgUnknownType { desc.ty = PgUnknownType {
name: if_ok!(self.get_type_name(oid)), name: try!(self.get_type_name(oid)),
oid: oid oid: oid
}, },
_ => {} _ => {}
@ -629,7 +630,7 @@ impl InnerPostgresConnection {
Some(name) => return Ok(name.clone()), Some(name) => return Ok(name.clone()),
None => {} None => {}
} }
let name = if_ok!(self.quick_query( let name = try!(self.quick_query(
format!("SELECT typname FROM pg_type WHERE oid={}", oid)))[0][0] format!("SELECT typname FROM pg_type WHERE oid={}", oid)))[0][0]
.unwrap(); .unwrap();
self.unknown_types.insert(oid, name.clone()); self.unknown_types.insert(oid, name.clone());
@ -657,7 +658,7 @@ impl InnerPostgresConnection {
opt.map(|b| str::from_utf8_owned(b).unwrap())) opt.map(|b| str::from_utf8_owned(b).unwrap()))
.collect()), .collect()),
ErrorResponse { fields } => { ErrorResponse { fields } => {
if_ok!(self.wait_for_ready()); try!(self.wait_for_ready());
return Err(PgDbError(PostgresDbError::new(fields))); return Err(PgDbError(PostgresDbError::new(fields)));
} }
_ => {} _ => {}
@ -762,7 +763,7 @@ impl PostgresConnection {
pub fn try_transaction<'a>(&'a self) pub fn try_transaction<'a>(&'a self)
-> Result<PostgresTransaction<'a>, PostgresError> { -> Result<PostgresTransaction<'a>, PostgresError> {
check_desync!(self); check_desync!(self);
if_ok!(self.quick_query("BEGIN")); try!(self.quick_query("BEGIN"));
Ok(PostgresTransaction { Ok(PostgresTransaction {
conn: self, conn: self,
commit: Cell::new(true), commit: Cell::new(true),
@ -889,15 +890,15 @@ impl<'conn> PostgresTransaction<'conn> {
fn finish_inner(&mut self) -> Result<(), PostgresError> { fn finish_inner(&mut self) -> Result<(), PostgresError> {
if task::failing() || !self.commit.get() { if task::failing() || !self.commit.get() {
if self.nested { if self.nested {
if_ok!(self.conn.quick_query("ROLLBACK TO sp")); try!(self.conn.quick_query("ROLLBACK TO sp"));
} else { } else {
if_ok!(self.conn.quick_query("ROLLBACK")); try!(self.conn.quick_query("ROLLBACK"));
} }
} else { } else {
if self.nested { if self.nested {
if_ok!(self.conn.quick_query("RELEASE sp")); try!(self.conn.quick_query("RELEASE sp"));
} else { } else {
if_ok!(self.conn.quick_query("COMMIT")); try!(self.conn.quick_query("COMMIT"));
} }
} }
Ok(()) Ok(())
@ -934,7 +935,7 @@ impl<'conn> PostgresTransaction<'conn> {
pub fn try_transaction<'a>(&'a self) pub fn try_transaction<'a>(&'a self)
-> Result<PostgresTransaction<'a>, PostgresError> { -> Result<PostgresTransaction<'a>, PostgresError> {
check_desync!(self.conn); check_desync!(self.conn);
if_ok!(self.conn.quick_query("SAVEPOINT sp")); try!(self.conn.quick_query("SAVEPOINT sp"));
Ok(PostgresTransaction { Ok(PostgresTransaction {
conn: self.conn, conn: self.conn,
commit: Cell::new(true), commit: Cell::new(true),

140
src/message.rs
View File

@ -125,7 +125,7 @@ trait WriteCStr {
impl<W: Writer> WriteCStr for W { impl<W: Writer> WriteCStr for W {
fn write_cstr(&mut self, s: &str) -> IoResult<()> { fn write_cstr(&mut self, s: &str) -> IoResult<()> {
if_ok!(self.write(s.as_bytes())); try!(self.write(s.as_bytes()));
self.write_u8(0) self.write_u8(0)
} }
} }
@ -144,78 +144,78 @@ impl<W: Writer> WriteMessage for W {
match *message { match *message {
Bind { portal, statement, formats, values, result_formats } => { Bind { portal, statement, formats, values, result_formats } => {
ident = Some('B'); ident = Some('B');
if_ok!(buf.write_cstr(portal)); try!(buf.write_cstr(portal));
if_ok!(buf.write_cstr(statement)); try!(buf.write_cstr(statement));
if_ok!(buf.write_be_i16(formats.len() as i16)); try!(buf.write_be_i16(formats.len() as i16));
for format in formats.iter() { for format in formats.iter() {
if_ok!(buf.write_be_i16(*format)); try!(buf.write_be_i16(*format));
} }
if_ok!(buf.write_be_i16(values.len() as i16)); try!(buf.write_be_i16(values.len() as i16));
for value in values.iter() { for value in values.iter() {
match *value { match *value {
None => { None => {
if_ok!(buf.write_be_i32(-1)); try!(buf.write_be_i32(-1));
} }
Some(ref value) => { Some(ref value) => {
if_ok!(buf.write_be_i32(value.len() as i32)); try!(buf.write_be_i32(value.len() as i32));
if_ok!(buf.write(*value)); try!(buf.write(*value));
} }
} }
} }
if_ok!(buf.write_be_i16(result_formats.len() as i16)); try!(buf.write_be_i16(result_formats.len() as i16));
for format in result_formats.iter() { for format in result_formats.iter() {
if_ok!(buf.write_be_i16(*format)); try!(buf.write_be_i16(*format));
} }
} }
CancelRequest { code, process_id, secret_key } => { CancelRequest { code, process_id, secret_key } => {
if_ok!(buf.write_be_i32(code)); try!(buf.write_be_i32(code));
if_ok!(buf.write_be_i32(process_id)); try!(buf.write_be_i32(process_id));
if_ok!(buf.write_be_i32(secret_key)); try!(buf.write_be_i32(secret_key));
} }
Close { variant, name } => { Close { variant, name } => {
ident = Some('C'); ident = Some('C');
if_ok!(buf.write_u8(variant)); try!(buf.write_u8(variant));
if_ok!(buf.write_cstr(name)); try!(buf.write_cstr(name));
} }
Describe { variant, name } => { Describe { variant, name } => {
ident = Some('D'); ident = Some('D');
if_ok!(buf.write_u8(variant)); try!(buf.write_u8(variant));
if_ok!(buf.write_cstr(name)); try!(buf.write_cstr(name));
} }
Execute { portal, max_rows } => { Execute { portal, max_rows } => {
ident = Some('E'); ident = Some('E');
if_ok!(buf.write_cstr(portal)); try!(buf.write_cstr(portal));
if_ok!(buf.write_be_i32(max_rows)); try!(buf.write_be_i32(max_rows));
} }
Parse { name, query, param_types } => { Parse { name, query, param_types } => {
ident = Some('P'); ident = Some('P');
if_ok!(buf.write_cstr(name)); try!(buf.write_cstr(name));
if_ok!(buf.write_cstr(query)); try!(buf.write_cstr(query));
if_ok!(buf.write_be_i16(param_types.len() as i16)); try!(buf.write_be_i16(param_types.len() as i16));
for ty in param_types.iter() { for ty in param_types.iter() {
if_ok!(buf.write_be_i32(*ty)); try!(buf.write_be_i32(*ty));
} }
} }
PasswordMessage { password } => { PasswordMessage { password } => {
ident = Some('p'); ident = Some('p');
if_ok!(buf.write_cstr(password)); try!(buf.write_cstr(password));
} }
Query { query } => { Query { query } => {
ident = Some('Q'); ident = Some('Q');
if_ok!(buf.write_cstr(query)); try!(buf.write_cstr(query));
} }
StartupMessage { version, parameters } => { StartupMessage { version, parameters } => {
if_ok!(buf.write_be_i32(version)); try!(buf.write_be_i32(version));
for &(ref k, ref v) in parameters.iter() { for &(ref k, ref v) in parameters.iter() {
if_ok!(buf.write_cstr(k.as_slice())); try!(buf.write_cstr(k.as_slice()));
if_ok!(buf.write_cstr(v.as_slice())); try!(buf.write_cstr(v.as_slice()));
} }
if_ok!(buf.write_u8(0)); try!(buf.write_u8(0));
} }
SslRequest { code } => if_ok!(buf.write_be_i32(code)), SslRequest { code } => try!(buf.write_be_i32(code)),
Sync => { Sync => {
ident = Some('S'); ident = Some('S');
} }
@ -225,15 +225,15 @@ impl<W: Writer> WriteMessage for W {
} }
match ident { match ident {
Some(ident) => if_ok!(self.write_u8(ident as u8)), Some(ident) => try!(self.write_u8(ident as u8)),
None => () None => ()
} }
let buf = buf.unwrap(); let buf = buf.unwrap();
// add size of length value // add size of length value
if_ok!(self.write_be_i32((buf.len() + mem::size_of::<i32>()) as i32)); try!(self.write_be_i32((buf.len() + mem::size_of::<i32>()) as i32));
if_ok!(self.write(buf)); try!(self.write(buf));
Ok(()) Ok(())
} }
@ -246,7 +246,7 @@ trait ReadCStr {
impl<R: Buffer> ReadCStr for R { impl<R: Buffer> ReadCStr for R {
fn read_cstr(&mut self) -> IoResult<~str> { fn read_cstr(&mut self) -> IoResult<~str> {
let mut buf = if_ok!(self.read_until(0)); let mut buf = try!(self.read_until(0));
buf.pop(); buf.pop();
Ok(str::from_utf8_owned(buf).unwrap()) Ok(str::from_utf8_owned(buf).unwrap())
} }
@ -261,39 +261,39 @@ impl<R: Reader> ReadMessage for R {
fn read_message(&mut self) -> IoResult<BackendMessage> { fn read_message(&mut self) -> IoResult<BackendMessage> {
debug!("Reading message"); debug!("Reading message");
let ident = if_ok!(self.read_u8()); let ident = try!(self.read_u8());
// subtract size of length value // subtract size of length value
let len = if_ok!(self.read_be_i32()) as uint - mem::size_of::<i32>(); let len = try!(self.read_be_i32()) as uint - mem::size_of::<i32>();
let mut buf = MemReader::new(if_ok!(self.read_bytes(len))); let mut buf = MemReader::new(try!(self.read_bytes(len)));
let ret = match ident as char { let ret = match ident as char {
'1' => ParseComplete, '1' => ParseComplete,
'2' => BindComplete, '2' => BindComplete,
'3' => CloseComplete, '3' => CloseComplete,
'A' => NotificationResponse { 'A' => NotificationResponse {
pid: if_ok!(buf.read_be_i32()), pid: try!(buf.read_be_i32()),
channel: if_ok!(buf.read_cstr()), channel: try!(buf.read_cstr()),
payload: if_ok!(buf.read_cstr()) payload: try!(buf.read_cstr())
}, },
'C' => CommandComplete { tag: if_ok!(buf.read_cstr()) }, 'C' => CommandComplete { tag: try!(buf.read_cstr()) },
'D' => if_ok!(read_data_row(&mut buf)), 'D' => try!(read_data_row(&mut buf)),
'E' => ErrorResponse { fields: if_ok!(read_fields(&mut buf)) }, 'E' => ErrorResponse { fields: try!(read_fields(&mut buf)) },
'I' => EmptyQueryResponse, 'I' => EmptyQueryResponse,
'K' => BackendKeyData { 'K' => BackendKeyData {
process_id: if_ok!(buf.read_be_i32()), process_id: try!(buf.read_be_i32()),
secret_key: if_ok!(buf.read_be_i32()) secret_key: try!(buf.read_be_i32())
}, },
'n' => NoData, 'n' => NoData,
'N' => NoticeResponse { fields: if_ok!(read_fields(&mut buf)) }, 'N' => NoticeResponse { fields: try!(read_fields(&mut buf)) },
'R' => if_ok!(read_auth_message(&mut buf)), 'R' => try!(read_auth_message(&mut buf)),
's' => PortalSuspended, 's' => PortalSuspended,
'S' => ParameterStatus { 'S' => ParameterStatus {
parameter: if_ok!(buf.read_cstr()), parameter: try!(buf.read_cstr()),
value: if_ok!(buf.read_cstr()) value: try!(buf.read_cstr())
}, },
't' => if_ok!(read_parameter_description(&mut buf)), 't' => try!(read_parameter_description(&mut buf)),
'T' => if_ok!(read_row_description(&mut buf)), 'T' => try!(read_row_description(&mut buf)),
'Z' => ReadyForQuery { state: if_ok!(buf.read_u8()) }, 'Z' => ReadyForQuery { state: try!(buf.read_u8()) },
ident => fail!("Unknown message identifier `{}`", ident) ident => fail!("Unknown message identifier `{}`", ident)
}; };
debug!("Read message {:?}", ret); debug!("Read message {:?}", ret);
@ -304,25 +304,25 @@ impl<R: Reader> ReadMessage for R {
fn read_fields(buf: &mut MemReader) -> IoResult<~[(u8, ~str)]> { fn read_fields(buf: &mut MemReader) -> IoResult<~[(u8, ~str)]> {
let mut fields = ~[]; let mut fields = ~[];
loop { loop {
let ty = if_ok!(buf.read_u8()); let ty = try!(buf.read_u8());
if ty == 0 { if ty == 0 {
break; break;
} }
fields.push((ty, if_ok!(buf.read_cstr()))); fields.push((ty, try!(buf.read_cstr())));
} }
Ok(fields) Ok(fields)
} }
fn read_data_row(buf: &mut MemReader) -> IoResult<BackendMessage> { fn read_data_row(buf: &mut MemReader) -> IoResult<BackendMessage> {
let len = if_ok!(buf.read_be_i16()) as uint; let len = try!(buf.read_be_i16()) as uint;
let mut values = vec::with_capacity(len); let mut values = vec::with_capacity(len);
for _ in range(0, len) { for _ in range(0, len) {
let val = match if_ok!(buf.read_be_i32()) { let val = match try!(buf.read_be_i32()) {
-1 => None, -1 => None,
len => Some(if_ok!(buf.read_bytes(len as uint))) len => Some(try!(buf.read_bytes(len as uint)))
}; };
values.push(val); values.push(val);
} }
@ -331,11 +331,11 @@ fn read_data_row(buf: &mut MemReader) -> IoResult<BackendMessage> {
} }
fn read_auth_message(buf: &mut MemReader) -> IoResult<BackendMessage> { fn read_auth_message(buf: &mut MemReader) -> IoResult<BackendMessage> {
Ok(match if_ok!(buf.read_be_i32()) { Ok(match try!(buf.read_be_i32()) {
0 => AuthenticationOk, 0 => AuthenticationOk,
2 => AuthenticationKerberosV5, 2 => AuthenticationKerberosV5,
3 => AuthenticationCleartextPassword, 3 => AuthenticationCleartextPassword,
5 => AuthenticationMD5Password { salt: if_ok!(buf.read_bytes(4)) }, 5 => AuthenticationMD5Password { salt: try!(buf.read_bytes(4)) },
6 => AuthenticationSCMCredential, 6 => AuthenticationSCMCredential,
7 => AuthenticationGSS, 7 => AuthenticationGSS,
9 => AuthenticationSSPI, 9 => AuthenticationSSPI,
@ -344,29 +344,29 @@ fn read_auth_message(buf: &mut MemReader) -> IoResult<BackendMessage> {
} }
fn read_parameter_description(buf: &mut MemReader) -> IoResult<BackendMessage> { fn read_parameter_description(buf: &mut MemReader) -> IoResult<BackendMessage> {
let len = if_ok!(buf.read_be_i16()) as uint; let len = try!(buf.read_be_i16()) as uint;
let mut types = vec::with_capacity(len); let mut types = vec::with_capacity(len);
for _ in range(0, len) { for _ in range(0, len) {
types.push(if_ok!(buf.read_be_u32())); types.push(try!(buf.read_be_u32()));
} }
Ok(ParameterDescription { types: types }) Ok(ParameterDescription { types: types })
} }
fn read_row_description(buf: &mut MemReader) -> IoResult<BackendMessage> { fn read_row_description(buf: &mut MemReader) -> IoResult<BackendMessage> {
let len = if_ok!(buf.read_be_i16()) as uint; let len = try!(buf.read_be_i16()) as uint;
let mut types = vec::with_capacity(len); let mut types = vec::with_capacity(len);
for _ in range(0, len) { for _ in range(0, len) {
types.push(RowDescriptionEntry { types.push(RowDescriptionEntry {
name: if_ok!(buf.read_cstr()), name: try!(buf.read_cstr()),
table_oid: if_ok!(buf.read_be_u32()), table_oid: try!(buf.read_be_u32()),
column_id: if_ok!(buf.read_be_i16()), column_id: try!(buf.read_be_i16()),
type_oid: if_ok!(buf.read_be_u32()), type_oid: try!(buf.read_be_u32()),
type_size: if_ok!(buf.read_be_i16()), type_size: try!(buf.read_be_i16()),
type_modifier: if_ok!(buf.read_be_i32()), type_modifier: try!(buf.read_be_i32()),
format: if_ok!(buf.read_be_i16()) format: try!(buf.read_be_i16())
}); });
} }

18
src/stmt.rs
View File

@ -130,7 +130,7 @@ impl<'conn> NormalPostgresStatement<'conn> {
match if_ok_pg!(self.conn.read_message()) { match if_ok_pg!(self.conn.read_message()) {
ReadyForQuery { .. } => break, ReadyForQuery { .. } => break,
ErrorResponse { fields } => { ErrorResponse { fields } => {
if_ok!(self.conn.wait_for_ready()); try!(self.conn.wait_for_ready());
return Err(PgDbError(PostgresDbError::new(fields))); return Err(PgDbError(PostgresDbError::new(fields)));
} }
_ => {} _ => {}
@ -173,7 +173,7 @@ impl<'conn> NormalPostgresStatement<'conn> {
match if_ok_pg!(self.conn.read_message()) { match if_ok_pg!(self.conn.read_message()) {
BindComplete => Ok(()), BindComplete => Ok(()),
ErrorResponse { fields } => { ErrorResponse { fields } => {
if_ok!(self.conn.wait_for_ready()); try!(self.conn.wait_for_ready());
Err(PgDbError(PostgresDbError::new(fields))) Err(PgDbError(PostgresDbError::new(fields)))
} }
_ => unreachable!() _ => unreachable!()
@ -186,7 +186,7 @@ impl<'conn> NormalPostgresStatement<'conn> {
self.next_portal_id.set(id + 1); self.next_portal_id.set(id + 1);
let portal_name = format!("{}_portal_{}", self.name, id); let portal_name = format!("{}_portal_{}", self.name, id);
if_ok!(self.execute(portal_name, row_limit, params)); try!(self.execute(portal_name, row_limit, params));
let mut result = PostgresResult { let mut result = PostgresResult {
stmt: self, stmt: self,
@ -196,7 +196,7 @@ impl<'conn> NormalPostgresStatement<'conn> {
more_rows: true, more_rows: true,
finished: false, finished: false,
}; };
if_ok!(result.read_rows()) try!(result.read_rows())
Ok(result) Ok(result)
} }
@ -214,14 +214,14 @@ impl<'conn> PostgresStatement for NormalPostgresStatement<'conn> {
fn try_execute(&self, params: &[&ToSql]) fn try_execute(&self, params: &[&ToSql])
-> Result<uint, PostgresError> { -> Result<uint, PostgresError> {
check_desync!(self.conn); check_desync!(self.conn);
if_ok!(self.execute("", 0, params)); try!(self.execute("", 0, params));
let num; let num;
loop { loop {
match if_ok_pg!(self.conn.read_message()) { match if_ok_pg!(self.conn.read_message()) {
DataRow { .. } => {} DataRow { .. } => {}
ErrorResponse { fields } => { ErrorResponse { fields } => {
if_ok!(self.conn.wait_for_ready()); try!(self.conn.wait_for_ready());
return Err(PgDbError(PostgresDbError::new(fields))); return Err(PgDbError(PostgresDbError::new(fields)));
} }
CommandComplete { tag } => { CommandComplete { tag } => {
@ -239,7 +239,7 @@ impl<'conn> PostgresStatement for NormalPostgresStatement<'conn> {
_ => unreachable!() _ => unreachable!()
} }
} }
if_ok!(self.conn.wait_for_ready()); try!(self.conn.wait_for_ready());
Ok(num) Ok(num)
} }
@ -379,7 +379,7 @@ impl<'stmt> PostgresResult<'stmt> {
match if_ok_pg!(self.stmt.conn.read_message()) { match if_ok_pg!(self.stmt.conn.read_message()) {
ReadyForQuery { .. } => break, ReadyForQuery { .. } => break,
ErrorResponse { fields } => { ErrorResponse { fields } => {
if_ok!(self.stmt.conn.wait_for_ready()); try!(self.stmt.conn.wait_for_ready());
return Err(PgDbError(PostgresDbError::new(fields))); return Err(PgDbError(PostgresDbError::new(fields)));
} }
_ => {} _ => {}
@ -433,7 +433,7 @@ impl<'stmt> PostgresResult<'stmt> {
pub fn try_next(&mut self) pub fn try_next(&mut self)
-> Result<Option<PostgresRow<'stmt>>, PostgresError> { -> Result<Option<PostgresRow<'stmt>>, PostgresError> {
if self.data.is_empty() && self.more_rows { if self.data.is_empty() && self.more_rows {
if_ok!(self.execute()); try!(self.execute());
} }
let row = self.data.pop_front().map(|row| { let row = self.data.pop_front().map(|row| {

4
src/test.rs
View File

@ -1,7 +1,7 @@
use sync::DuplexStream; use sync::DuplexStream;
use sync::Future; use sync::Future;
use extra::time; use time;
use extra::time::Timespec; use time::Timespec;
use extra::json; use extra::json;
use uuid::Uuid; use uuid::Uuid;
use openssl::ssl::{SslContext, Sslv3}; use openssl::ssl::{SslContext, Sslv3};

2
src/types/mod.rs
View File

@ -3,7 +3,7 @@
extern crate extra; extern crate extra;
use extra::time::Timespec; use time::Timespec;
use extra::json; use extra::json;
use extra::json::Json; use extra::json::Json;
use uuid::Uuid; use uuid::Uuid;

2
src/types/range.rs
View File

@ -6,7 +6,7 @@ extern crate extra;
use std::cmp; use std::cmp;
use std::i32; use std::i32;
use std::i64; use std::i64;
use extra::time::Timespec; use time::Timespec;
/// The `quote!` macro can make it easier to create ranges. It roughly mirrors /// The `quote!` macro can make it easier to create ranges. It roughly mirrors
/// traditional mathematic range syntax. /// traditional mathematic range syntax.

2
submodules/rust-phf

@ -1 +1 @@
Subproject commit 46e784f82b9a40aa11f0f7e9db5439a481a08e46 Subproject commit dba9fa31e751545706ffe0eecb76d85e41c93a61