alopecosa/iproto/
request.rs

1/*!
2  This module contains structs for requests.
3*/
4
5use std::io::Write;
6
7use super::{
8  constants::{Field, RequestType, Iterator},
9  types::Error,
10};
11use num_traits::ToPrimitive;
12use rmp::encode::{
13  write_array_len, write_map_len, write_sint,
14  write_str, write_str_len, write_uint,
15};
16
17macro_rules! req_func {
18  ( $func:ident, $body:ident ) => {
19    #[allow(dead_code)]
20    pub fn $func(body: $body) -> Request {
21      Request::new(RequestType::$body, body)
22    }
23  };
24}
25
26req_func!(auth, Auth);
27req_func!(select, Select);
28req_func!(call, Call);
29req_func!(insert, Insert);
30req_func!(replace, Replace);
31req_func!(update, Update);
32req_func!(delete, Delete);
33req_func!(eval, Eval);
34req_func!(upsert, Upsert);
35req_func!(prepare, Prepare);
36req_func!(execute, Execute);
37
38#[allow(dead_code)]
39pub fn ping() -> Request {
40  Request {
41    header: Header::new(RequestType::Ping),
42    body: Box::new(Ping),
43  }
44}
45
46/**
47  This trait represents tarantool query body.
48
49  If you want to make custom request body, you should implement it.
50*/
51pub trait Body: std::fmt::Debug + Send {
52  fn pack(&self) -> Result<Vec<u8>, Error>;
53}
54
55/**
56  This is representation of request.
57*/
58#[derive(Debug)]
59pub struct Request {
60  pub header: Header,
61  body: Box<dyn Body>,
62}
63
64#[allow(dead_code)]
65impl Request {
66
67  /// Allows you to construct request.
68  pub fn new<B: Body + 'static>(request: RequestType, body: B) -> Request {
69    Request {
70      header: Header::new(request),
71      body: Box::new(body),
72    }
73  }
74
75  /// Allows you to pack request.
76  pub fn pack<W>(&self, w: &mut W) -> Result<(), Error>
77    where W: Write
78  {
79
80    let header = self.header.pack()?;
81    let body = self.body.pack()?;
82
83    let size = header.len() + body.len();
84
85    rmp::encode::write_uint(w, size as u64)?;
86
87    w.write_all(header.as_slice())?;
88    w.write_all(body.as_slice())?;
89
90    Ok(())
91  }
92}
93
94/// This represents header of request.
95#[derive(Debug, Clone)]
96pub struct Header {
97  pub request: RequestType,
98  pub sync: u64,
99}
100
101#[allow(dead_code)]
102impl Header {
103  /// Allows you to construct header.
104  fn new(request: RequestType) -> Header {
105    Header { request, sync: 0 }
106  }
107
108  /// Allows you to pack header.
109  fn pack(&self) -> Result<Vec<u8>, Error> {
110    // think that request will be u32 and sync u64
111    let mut buf: Vec<u8> = Vec::with_capacity(18);
112
113    write_map_len(&mut buf, 2)?;
114
115    write_uint(&mut buf, Field::RequestType.to_u64().unwrap())?;
116    write_uint(&mut buf, self.request.to_u64().unwrap())?;
117
118    write_uint(&mut buf, Field::Sync.to_u64().unwrap())?;
119    write_uint(&mut buf, self.sync)?;
120
121    Ok(buf)
122  }
123}
124
125/**
126  This represents types allowed in tuple.
127
128  It implementst From for std types.
129*/
130#[allow(dead_code)]
131#[derive(Debug, Clone)]
132pub enum Value {
133  Int(i64), UInt(u64),
134  F32(f32), F64(f64),
135  Bool(bool), Null,
136  Str(String), Bin(Vec<u8>),
137  Array(Vec<Value>),
138}
139
140macro_rules! impl_value_from_as {
141  ($value:ident, $type:ident, $as:ident) => {
142    impl From<$type> for Value {
143      fn from(value: $type) -> Self {
144        Value::$value(value as $as)
145      }
146    }
147  };
148}
149
150impl_value_from_as!(UInt, u64, u64);
151impl_value_from_as!(UInt, usize, u64);
152impl_value_from_as!(UInt, u32, u64);
153impl_value_from_as!(UInt, u16, u64);
154
155impl_value_from_as!(Int, i64, i64);
156impl_value_from_as!(Int, isize, i64);
157impl_value_from_as!(Int, i32, i64);
158impl_value_from_as!(Int, i16, i64);
159impl_value_from_as!(Int, i8, i64);
160
161impl_value_from_as!(F32, f32, f32);
162impl_value_from_as!(F64, f64, f64);
163
164impl From<bool> for Value {
165  fn from(value: bool) -> Self {
166    Value::Bool(value)
167  }
168}
169
170impl From<String> for Value {
171  fn from(value: String) -> Self {
172    Value::Str(value)
173  }
174}
175
176impl From<&str> for Value {
177  fn from(value: &str) -> Self {
178    Value::Str(value.into())
179  }
180}
181
182impl From<Vec<u8>> for Value {
183  fn from(value: Vec<u8>) -> Self {
184    Value::Bin(value)
185  }
186}
187
188impl From<&[u8]> for Value {
189  fn from(value: &[u8]) -> Self {
190    Value::Bin(value.into())
191  }
192}
193
194impl<T: Into<Value>> From<Option<T>> for Value {
195  fn from(value: Option<T>) -> Self {
196    match value {
197      Some(value) => value.into(),
198      None => Value::Null,
199    }
200  }
201}
202
203impl<T: Into<Value>> From<Vec<T>> for Value {
204  fn from(mut value: Vec<T>) -> Self {
205    let mut new_vec = Vec::with_capacity(value.len());
206    for i in 0..value.len() {
207      new_vec.push(value.remove(i).into());
208    }
209    Value::Array(new_vec)
210  }
211}
212
213impl<T> From<&[T]> for Value
214  where T: Into<Value> + Clone
215{
216  fn from(value: &[T]) -> Self {
217    Value::Array(value.iter()
218      .map(|v| v.clone().into())
219      .collect()
220    )
221  }
222}
223
224/**
225  This trait provides shortcuts for Vec<Value>.
226
227  instead of
228  ```rust
229    vec![ Value::Int(1), Value::Str("test") ]
230  ```
231  you can use
232  ```rust
233    ( 1, "test" ).to_tuple()
234  ```
235
236  It works for slice, vec, and tuples with up to 10 elements.
237*/
238pub trait IntoTuple {
239  fn into_tuple(self) -> Vec<Value>;
240}
241
242impl<T> IntoTuple for Vec<T> where T: Into<Value> {
243  fn into_tuple(mut self) -> Vec<Value> {
244    let mut new_vec = Vec::with_capacity(self.len());
245    for i in 0..self.len() {
246      new_vec.push(self.remove(i).into());
247    }
248    new_vec
249  }
250}
251
252impl<T> IntoTuple for &[T]
253  where T: Into<Value> + Clone
254{
255  fn into_tuple(self) -> Vec<Value> {
256    self.iter().map(|v| v.clone().into()).collect()
257  }
258}
259
260impl IntoTuple for ()
261{
262  fn into_tuple(self) -> Vec<Value> {
263    Vec::new()
264  }
265}
266
267impl<T1> IntoTuple for (T1,)
268  where T1: Into<Value>
269{
270  fn into_tuple(self) -> Vec<Value> {
271    vec![ self.0.into() ]
272  }
273}
274
275impl<T1, T2> IntoTuple for (T1, T2)
276  where
277    T1: Into<Value>,
278    T2: Into<Value>,
279{
280  fn into_tuple(self) -> Vec<Value> {
281    vec![ self.0.into(), self.1.into() ]
282  }
283}
284
285impl<T1, T2, T3> IntoTuple for (T1, T2, T3)
286  where
287    T1: Into<Value>,
288    T2: Into<Value>,
289    T3: Into<Value>,
290{
291  fn into_tuple(self) -> Vec<Value> {
292    vec![ self.0.into(), self.1.into(), self.2.into() ]
293  }
294}
295
296impl<T1, T2, T3, T4> IntoTuple for (T1, T2, T3, T4)
297  where
298    T1: Into<Value>,
299    T2: Into<Value>,
300    T3: Into<Value>,
301    T4: Into<Value>,
302{
303  fn into_tuple(self) -> Vec<Value> {
304    vec![
305      self.0.into(),
306      self.1.into(),
307      self.2.into(),
308      self.3.into(),
309    ]
310  }
311}
312
313
314impl<T1, T2, T3, T4, T5> IntoTuple for (T1, T2, T3, T4, T5)
315  where
316    T1: Into<Value>,
317    T2: Into<Value>,
318    T3: Into<Value>,
319    T4: Into<Value>,
320    T5: Into<Value>,
321{
322  fn into_tuple(self) -> Vec<Value> {
323    vec![
324      self.0.into(),
325      self.1.into(),
326      self.2.into(),
327      self.3.into(),
328      self.4.into(),
329    ]
330  }
331}
332
333impl<T1, T2, T3, T4, T5, T6> IntoTuple for (T1, T2, T3, T4, T5, T6)
334  where
335    T1: Into<Value>,
336    T2: Into<Value>,
337    T3: Into<Value>,
338    T4: Into<Value>,
339    T5: Into<Value>,
340    T6: Into<Value>,
341{
342  fn into_tuple(self) -> Vec<Value> {
343    vec![
344      self.0.into(),
345      self.1.into(),
346      self.2.into(),
347      self.3.into(),
348      self.4.into(),
349      self.5.into(),
350    ]
351  }
352}
353
354impl<T1, T2, T3, T4, T5, T6, T7> IntoTuple for (T1, T2, T3, T4, T5, T6, T7)
355  where
356    T1: Into<Value>,
357    T2: Into<Value>,
358    T3: Into<Value>,
359    T4: Into<Value>,
360    T5: Into<Value>,
361    T6: Into<Value>,
362    T7: Into<Value>,
363{
364  fn into_tuple(self) -> Vec<Value> {
365    vec![
366      self.0.into(),
367      self.1.into(),
368      self.2.into(),
369      self.3.into(),
370      self.4.into(),
371      self.5.into(),
372      self.6.into(),
373    ]
374  }
375}
376
377impl<T1, T2, T3, T4, T5, T6, T7, T8> IntoTuple for (T1, T2, T3, T4, T5, T6, T7, T8)
378  where
379    T1: Into<Value>,
380    T2: Into<Value>,
381    T3: Into<Value>,
382    T4: Into<Value>,
383    T5: Into<Value>,
384    T6: Into<Value>,
385    T7: Into<Value>,
386    T8: Into<Value>,
387{
388  fn into_tuple(self) -> Vec<Value> {
389    vec![
390      self.0.into(),
391      self.1.into(),
392      self.2.into(),
393      self.3.into(),
394      self.4.into(),
395      self.5.into(),
396      self.6.into(),
397      self.7.into(),
398    ]
399  }
400}
401
402impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> IntoTuple for (T1, T2, T3, T4, T5, T6, T7, T8, T9)
403  where
404    T1: Into<Value>,
405    T2: Into<Value>,
406    T3: Into<Value>,
407    T4: Into<Value>,
408    T5: Into<Value>,
409    T6: Into<Value>,
410    T7: Into<Value>,
411    T8: Into<Value>,
412    T9: Into<Value>,
413{
414  fn into_tuple(self) -> Vec<Value> {
415    vec![
416      self.0.into(),
417      self.1.into(),
418      self.2.into(),
419      self.3.into(),
420      self.4.into(),
421      self.5.into(),
422      self.6.into(),
423      self.7.into(),
424      self.8.into(),
425    ]
426  }
427}
428
429impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IntoTuple for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
430  where
431    T1: Into<Value>,
432    T2: Into<Value>,
433    T3: Into<Value>,
434    T4: Into<Value>,
435    T5: Into<Value>,
436    T6: Into<Value>,
437    T7: Into<Value>,
438    T8: Into<Value>,
439    T9: Into<Value>,
440    T10: Into<Value>,
441{
442  fn into_tuple(self) -> Vec<Value> {
443    vec![
444      self.0.into(),
445      self.1.into(),
446      self.2.into(),
447      self.3.into(),
448      self.4.into(),
449      self.5.into(),
450      self.6.into(),
451      self.7.into(),
452      self.8.into(),
453      self.9.into(),
454    ]
455  }
456}
457
458impl Value {
459  fn pack<W>(&self, w: &mut W) -> Result<(), Error>
460    where W: Write,
461  {
462    match self {
463      &Value::Int(val) => { rmp::encode::write_sint(w, val)?; },
464      &Value::UInt(val) => { rmp::encode::write_uint(w, val)?; },
465      &Value::F32(val) => { rmp::encode::write_f32(w, val)?; },
466      &Value::F64(val) => { rmp::encode::write_f64(w, val)?; },
467      &Value::Bool(val) => { rmp::encode::write_bool(w, val)?; },
468      Value::Null => { rmp::encode::write_nil(w)?; },
469      Value::Str(val) => { rmp::encode::write_str(w, val.as_str())?; },
470      Value::Bin(val) => { rmp::encode::write_bin(w, val.as_slice())?; },
471      Value::Array(vals) => {
472        rmp::encode::write_array_len(w, vals.len() as u32)?;
473        for val in vals.iter() { val.pack(w)?; }
474      },
475    };
476
477    Ok(())
478  }
479}
480
481#[derive(Debug, Clone)]
482pub struct Select {
483  pub space_id: u64,
484  pub index_id: u64,
485  pub limit: u32,
486  pub offset: u32,
487  pub iterator: Iterator,
488  pub keys: Vec<Value>,
489}
490
491impl Body for Select {
492  fn pack(&self) -> Result<Vec<u8>, Error> {
493    let mut data: Vec<u8> = Vec::with_capacity(
494      1 + 6 + (5 * 5) +
495      (1 + self.keys.len() * 5)
496    );
497    let buf = &mut data;
498
499    write_map_len(buf, 6)?;
500
501    write_uint(buf, Field::SpaceID.to_u64().unwrap())?;
502    write_uint(buf, self.space_id)?;
503
504    write_uint(buf, Field::IndexID.to_u64().unwrap())?;
505    write_uint(buf, self.index_id)?;
506
507    write_uint(buf, Field::Limit.to_u64().unwrap())?;
508    write_uint(buf, self.limit as u64)?;
509
510    write_uint(buf, Field::Offset.to_u64().unwrap())?;
511    write_uint(buf, self.offset as u64)?;
512
513    write_uint(buf, Field::Iterator.to_u64().unwrap())?;
514    write_uint(buf, self.iterator.to_u64().unwrap())?;
515
516    write_uint(buf, Field::Key.to_u64().unwrap())?;
517    write_array_len(buf, self.keys.len() as u32)?;
518    for key in self.keys.iter() { key.pack(buf)?; }
519
520    Ok(data)
521  }
522}
523
524#[derive(Debug, Clone)]
525pub struct Call {
526  pub function: String,
527  pub args: Vec<Value>,
528}
529
530impl Body for Call {
531  fn pack(&self) -> Result<Vec<u8>, Error> {
532    let mut data: Vec<u8> = Vec::with_capacity(
533      1 + 2 +
534      (1 + self.function.len()) +
535      (1 + self.args.len() * 5)
536    );
537    let buf = &mut data;
538
539    write_map_len(buf, 2)?;
540
541    write_uint(buf, Field::FunctionName.to_u64().unwrap())?;
542    write_str(buf, self.function.as_str())?;
543
544    write_uint(buf, Field::Tuple.to_u64().unwrap())?;
545    write_array_len(buf, self.args.len() as u32)?;
546    for arg in self.args.iter() { arg.pack(buf)?; }
547
548    Ok(data)
549  }
550}
551
552#[derive(Debug, Clone)]
553pub struct Auth {
554  pub user: String,
555  pub scramble: Vec<u8>,
556}
557
558impl Body for Auth {
559  fn pack(&self) -> Result<Vec<u8>, Error> {
560    let mut data: Vec<u8> = Vec::with_capacity(
561      1 + 2 +
562      (1 + self.user.len()) +
563      (1 + self.scramble.len())
564    );
565    let buf = &mut data;
566
567    write_map_len(buf, 2)?;
568
569    write_uint(buf, Field::UserName.to_u64().unwrap())?;
570    write_str(buf, self.user.as_str())?;
571
572    write_uint(buf, Field::Tuple.to_u64().unwrap())?;
573    write_array_len(buf, 2)?;
574    write_str(buf, "chap-sha1")?;
575    write_str_len(buf, self.scramble.len() as u32)?;
576    data.extend_from_slice(&self.scramble);
577
578    Ok(data)
579  }
580}
581
582#[derive(Debug, Clone)]
583pub struct Insert {
584  pub space_id: u64,
585  pub tuple: Vec<Value>,
586}
587
588impl Body for Insert {
589  fn pack(&self) -> Result<Vec<u8>, Error> {
590    let mut data: Vec<u8> = Vec::with_capacity(
591      1 + 2 + 5 +
592      (1 + self.tuple.len() * 5)
593    );
594    let buf = &mut data;
595
596    write_map_len(buf, 2)?;
597
598    write_uint(buf, Field::SpaceID.to_u64().unwrap())?;
599    write_uint(buf, self.space_id)?;
600
601    write_uint(buf, Field::Tuple.to_u64().unwrap())?;
602    write_array_len(buf, self.tuple.len() as u32)?;
603    for v in self.tuple.iter() { v.pack(buf)?; }
604
605    Ok(data)
606  }
607}
608
609#[allow(dead_code)]
610pub type Replace = Insert;
611
612#[derive(Debug, Clone)]
613pub struct Update {
614  pub space_id: u64,
615  pub index_id: u64,
616  pub key: Vec<Value>,
617  pub tuple: Vec<Vec<Value>>,
618}
619
620impl Body for Update {
621  fn pack(&self) -> Result<Vec<u8>, Error> {
622    let mut data: Vec<u8> = Vec::with_capacity(
623      1 + 4 + (5 * 2) +
624      (1 + self.key.len() * 5) +
625      (1 + self.tuple.len() * (1 + 5 * 3))
626    );
627    let buf = &mut data;
628
629    write_map_len(buf, 4)?;
630
631    write_uint(buf, Field::SpaceID.to_u64().unwrap())?;
632    write_uint(buf, self.space_id)?;
633
634    write_uint(buf, Field::IndexID.to_u64().unwrap())?;
635    write_uint(buf, self.index_id)?;
636
637    write_uint(buf, Field::Key.to_u64().unwrap())?;
638    write_array_len(buf, self.key.len() as u32)?;
639    for v in self.key.iter() { v.pack(buf)?; }
640
641    write_uint(buf, Field::Tuple.to_u64().unwrap())?;
642    write_array_len(buf, self.tuple.len() as u32)?;
643    for update in self.tuple.iter() {
644      write_array_len(buf, update.len() as u32)?;
645      for v in update.iter() { v.pack(buf)?; }
646    }
647
648    Ok(data)
649  }
650}
651
652#[derive(Debug, Clone)]
653pub struct Delete {
654  pub space_id: u64,
655  pub index_id: u64,
656  pub key: Vec<Value>,
657}
658
659impl Body for Delete {
660  fn pack(&self) -> Result<Vec<u8>, Error> {
661    let mut data: Vec<u8> = Vec::with_capacity(
662      1 + 3 + (5 * 2) + (1 + self.key.len() * 5)
663    );
664    let buf = &mut data;
665
666    write_map_len(buf, 3)?;
667
668    write_uint(buf, Field::SpaceID.to_u64().unwrap())?;
669    write_uint(buf, self.space_id)?;
670
671    write_uint(buf, Field::IndexID.to_u64().unwrap())?;
672    write_uint(buf, self.index_id)?;
673
674    write_uint(buf, Field::Key.to_u64().unwrap())?;
675    write_array_len(buf, self.key.len() as u32)?;
676    for v in self.key.iter() { v.pack(buf)?; }
677
678    Ok(data)
679  }
680}
681
682#[derive(Debug, Clone)]
683pub struct Eval {
684  pub expr: String,
685  pub args: Vec<Value>,
686}
687
688impl Body for Eval {
689  fn pack(&self) -> Result<Vec<u8>, Error> {
690    let mut data: Vec<u8> = Vec::with_capacity(
691      1 + 2 +
692      (1 + self.expr.len()) +
693      (1 + self.args.len() * 5)
694    );
695    let buf = &mut data;
696
697    write_map_len(buf, 2)?;
698
699    write_uint(buf, Field::Expr.to_u64().unwrap())?;
700    write_str(buf, &self.expr)?;
701
702    write_uint(buf, Field::Tuple.to_u64().unwrap())?;
703    write_array_len(buf, self.args.len() as u32)?;
704    for v in self.args.iter() { v.pack(buf)?; }
705
706    Ok(data)
707  }
708}
709
710#[derive(Debug, Clone)]
711pub struct Upsert {
712  pub space_id: u64,
713  pub index_base: u64,
714  pub ops: Vec<Vec<Value>>,
715  pub tuple: Vec<Value>,
716}
717
718impl Body for Upsert {
719  fn pack(&self) -> Result<Vec<u8>, Error> {
720    let mut data: Vec<u8> = Vec::with_capacity(
721      1 + 4 +
722      (1 + self.tuple.len() * 5) +
723      (1 + self.ops.len() * (1 + 5 * 3))
724    );
725    let buf = &mut data;
726
727    write_map_len(buf, 4)?;
728
729    write_uint(buf, Field::SpaceID.to_u64().unwrap())?;
730    write_uint(buf, self.space_id)?;
731
732    write_uint(buf, Field::IndexBase.to_u64().unwrap())?;
733    write_uint(buf, self.index_base)?;
734
735    write_uint(buf, Field::Ops.to_u64().unwrap())?;
736    write_array_len(buf, self.ops.len() as u32)?;
737    for update in self.ops.iter() {
738      write_array_len(buf, update.len() as u32)?;
739      for v in update.iter() { v.pack(buf)?; }
740    }
741
742    write_uint(buf, Field::Tuple.to_u64().unwrap())?;
743    write_array_len(buf, self.tuple.len() as u32)?;
744    for v in self.tuple.iter() { v.pack(buf)?; }
745
746    Ok(data)
747  }
748}
749
750#[derive(Debug, Clone)]
751pub struct Ping;
752
753impl Body for Ping {
754  fn pack(&self) -> Result<Vec<u8>, Error> {
755    Ok(Vec::new())
756  }
757}
758
759
760#[allow(dead_code)]
761#[derive(Debug, Clone)]
762pub enum Prepare {
763  StatementID(i64),
764  SQL(String),
765}
766
767impl Prepare {
768  fn pack_pair<W>(&self, w: &mut W) -> Result<(), Error>
769    where W: Write
770  {
771    match self {
772      &Self::StatementID(id) => {
773        write_uint(w, Field::StmtID.to_u64().unwrap())?;
774        write_sint(w, id)?;
775      },
776      Self::SQL(stmt) => {
777        write_uint(w, Field::SqlText.to_u64().unwrap())?;
778        write_str(w, &stmt)?;
779      },
780    };
781
782    Ok(())
783  }
784
785  fn pair_size_hint(&self) -> usize {
786    match self {
787      &Self::StatementID(_) => 1 + 5,
788      Self::SQL(stmt) => 1 + (1 + stmt.len()),
789    }
790  }
791}
792
793impl Body for Prepare {
794  fn pack(&self) -> Result<Vec<u8>, Error> {
795    let mut data: Vec<u8> = Vec::with_capacity(1 + self.pair_size_hint());
796
797    let buf = &mut data;
798
799    write_map_len(buf, 1)?;
800
801    self.pack_pair(buf)?;
802
803    Ok(data)
804  }
805}
806
807#[derive(Debug, Clone)]
808pub struct Execute {
809  pub expr: Prepare,
810  pub sql_bind: Vec<Value>,
811  pub options: Vec<Value>,
812}
813
814impl Body for Execute {
815  fn pack(&self) -> Result<Vec<u8>, Error> {
816    let mut data: Vec<u8> = Vec::with_capacity(
817      1 + self.expr.pair_size_hint() +
818      (1 + 1 + 5 * self.sql_bind.len()) +
819      (1 + 1 + 5 * self.options.len())
820    );
821
822    let buf = &mut data;
823
824    write_map_len(buf, 3)?;
825
826    self.expr.pack_pair(buf)?;
827
828    write_uint(buf, Field::SqlBind.to_u64().unwrap())?;
829    write_array_len(buf, self.sql_bind.len() as u32)?;
830    for v in self.sql_bind.iter() { v.pack(buf)?; }
831
832    write_uint(buf, Field::Options.to_u64().unwrap())?;
833    write_array_len(buf, self.options.len() as u32)?;
834    for v in self.options.iter() { v.pack(buf)?; }
835
836    Ok(data)
837  }
838}
839
840#[cfg(test)]
841mod tests {
842  use super::*;
843
844  #[test]
845  fn test_select() {
846    let mut req = select(Select {
847        space_id: 512,
848        index_id: 0,
849        limit: 123,
850        offset: 0,
851        iterator: Iterator::Eq,
852        keys: vec![Value::UInt(1)],
853    });
854
855    req.header.sync = u32::MAX as u64 + 100;
856
857    let mut buf: Vec<u8> = Vec::new();
858
859    req.pack(&mut buf).expect("pack error");
860
861    assert_eq!(
862      &buf,
863      &[
864        29, 130, 0, 1, 1, 207, 0, 0, 0, 1, 0, 0, 0,
865        99, 134, 16, 205, 2, 0, 17, 0, 18, 123, 19,
866        0, 20, 0, 32, 145, 1,
867      ],
868    );
869
870  }
871
872  #[test]
873  fn test_call() {
874    let mut req = call(Call {
875      function: "test".into(),
876      args: vec![ Value::UInt(123) ],
877    });
878
879    req.header.sync = u32::MAX as u64 + 100;
880
881    let mut buf: Vec<u8> = Vec::new();
882
883    req.pack(&mut buf).unwrap();
884
885    assert_eq!(
886      &buf,
887      &[
888        23, 130, 0, 10, 1, 207, 0, 0, 0, 1, 0, 0, 0, 99,
889        130, 34, 164, 116, 101, 115, 116, 33, 145, 123,
890      ],
891    )
892  }
893
894  #[test]
895  fn test_insert() {
896    let req = insert(Insert {
897      space_id: 512,
898      tuple: vec![ Value::UInt(2) ],
899    });
900
901    let mut buf: Vec<u8> = Vec::new();
902
903    req.pack(&mut buf).unwrap();
904
905    assert_eq!(&buf, &[13, 130, 0, 2, 1, 0, 130, 16, 205, 2, 0, 33, 145, 2]);
906  }
907
908}
alopecosa/iproto/request.rs

alopecosa/iproto/
request.rs
