add some groupdb code. but not complete.

src/driver/driver_db_grpc_server/grpcdb.grpc.pb.cc

@@ -25,6 +25,7 @@ namespace db {
 static const char* dbservice_method_names[] = {
   "/iv.db.dbservice/querylist",
   "/iv.db.dbservice/querydata",
+  "/iv.db.dbservice/downdbfile",
 };
 
 std::unique_ptr< dbservice::Stub> dbservice::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
@@ -36,6 +37,7 @@ std::unique_ptr< dbservice::Stub> dbservice::NewStub(const std::shared_ptr< ::gr
 dbservice::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel)
   : channel_(channel), rpcmethod_querylist_(dbservice_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
   , rpcmethod_querydata_(dbservice_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_downdbfile_(dbservice_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
   {}
 
 ::grpc::Status dbservice::Stub::querylist(::grpc::ClientContext* context, const ::iv::db::listRequest& request, ::iv::db::listReply* response) {
@@ -84,6 +86,29 @@ void dbservice::Stub::experimental_async::querydata(::grpc::ClientContext* conte
   return result;
 }
 
+::grpc::Status dbservice::Stub::downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::iv::db::FiledbReply* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::iv::db::Filedbreq, ::iv::db::FiledbReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_downdbfile_, context, request, response);
+}
+
+void dbservice::Stub::experimental_async::downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::iv::db::Filedbreq, ::iv::db::FiledbReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_downdbfile_, context, request, response, std::move(f));
+}
+
+void dbservice::Stub::experimental_async::downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_downdbfile_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::iv::db::FiledbReply>* dbservice::Stub::PrepareAsyncdowndbfileRaw(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::iv::db::FiledbReply, ::iv::db::Filedbreq, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_downdbfile_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::iv::db::FiledbReply>* dbservice::Stub::AsyncdowndbfileRaw(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncdowndbfileRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
 dbservice::Service::Service() {
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       dbservice_method_names[0],
@@ -105,6 +130,16 @@ dbservice::Service::Service() {
              ::iv::db::dataReply* resp) {
                return service->querydata(ctx, req, resp);
              }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      dbservice_method_names[2],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< dbservice::Service, ::iv::db::Filedbreq, ::iv::db::FiledbReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](dbservice::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::iv::db::Filedbreq* req,
+             ::iv::db::FiledbReply* resp) {
+               return service->downdbfile(ctx, req, resp);
+             }, this)));
 }
 
 dbservice::Service::~Service() {
@@ -124,6 +159,13 @@ dbservice::Service::~Service() {
   return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
 }
 
+::grpc::Status dbservice::Service::downdbfile(::grpc::ServerContext* context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
 
 }  // namespace iv
 }  // namespace db

src/driver/driver_db_grpc_server/grpcdb.grpc.pb.h

@@ -66,6 +66,13 @@ class dbservice final {
     std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::dataReply>> PrepareAsyncquerydata(::grpc::ClientContext* context, const ::iv::db::dataRequest& request, ::grpc::CompletionQueue* cq) {
       return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::dataReply>>(PrepareAsyncquerydataRaw(context, request, cq));
     }
+    virtual ::grpc::Status downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::iv::db::FiledbReply* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::FiledbReply>> Asyncdowndbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::FiledbReply>>(AsyncdowndbfileRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::FiledbReply>> PrepareAsyncdowndbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::FiledbReply>>(PrepareAsyncdowndbfileRaw(context, request, cq));
+    }
     class experimental_async_interface {
      public:
       virtual ~experimental_async_interface() {}
@@ -81,6 +88,12 @@ class dbservice final {
       #else
       virtual void querydata(::grpc::ClientContext* context, const ::iv::db::dataRequest* request, ::iv::db::dataReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
       #endif
+      virtual void downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response, std::function<void(::grpc::Status)>) = 0;
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      virtual void downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      #else
+      virtual void downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      #endif
     };
     #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
     typedef class experimental_async_interface async_interface;
@@ -94,6 +107,8 @@ class dbservice final {
     virtual ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::listReply>* PrepareAsyncquerylistRaw(::grpc::ClientContext* context, const ::iv::db::listRequest& request, ::grpc::CompletionQueue* cq) = 0;
     virtual ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::dataReply>* AsyncquerydataRaw(::grpc::ClientContext* context, const ::iv::db::dataRequest& request, ::grpc::CompletionQueue* cq) = 0;
     virtual ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::dataReply>* PrepareAsyncquerydataRaw(::grpc::ClientContext* context, const ::iv::db::dataRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::FiledbReply>* AsyncdowndbfileRaw(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::iv::db::FiledbReply>* PrepareAsyncdowndbfileRaw(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::grpc::CompletionQueue* cq) = 0;
   };
   class Stub final : public StubInterface {
    public:
@@ -112,6 +127,13 @@ class dbservice final {
     std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::db::dataReply>> PrepareAsyncquerydata(::grpc::ClientContext* context, const ::iv::db::dataRequest& request, ::grpc::CompletionQueue* cq) {
       return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::db::dataReply>>(PrepareAsyncquerydataRaw(context, request, cq));
     }
+    ::grpc::Status downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::iv::db::FiledbReply* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::db::FiledbReply>> Asyncdowndbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::db::FiledbReply>>(AsyncdowndbfileRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::db::FiledbReply>> PrepareAsyncdowndbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::db::FiledbReply>>(PrepareAsyncdowndbfileRaw(context, request, cq));
+    }
     class experimental_async final :
       public StubInterface::experimental_async_interface {
      public:
@@ -127,6 +149,12 @@ class dbservice final {
       #else
       void querydata(::grpc::ClientContext* context, const ::iv::db::dataRequest* request, ::iv::db::dataReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
       #endif
+      void downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response, std::function<void(::grpc::Status)>) override;
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      void downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response, ::grpc::ClientUnaryReactor* reactor) override;
+      #else
+      void downdbfile(::grpc::ClientContext* context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      #endif
      private:
       friend class Stub;
       explicit experimental_async(Stub* stub): stub_(stub) { }
@@ -142,8 +170,11 @@ class dbservice final {
     ::grpc::ClientAsyncResponseReader< ::iv::db::listReply>* PrepareAsyncquerylistRaw(::grpc::ClientContext* context, const ::iv::db::listRequest& request, ::grpc::CompletionQueue* cq) override;
     ::grpc::ClientAsyncResponseReader< ::iv::db::dataReply>* AsyncquerydataRaw(::grpc::ClientContext* context, const ::iv::db::dataRequest& request, ::grpc::CompletionQueue* cq) override;
     ::grpc::ClientAsyncResponseReader< ::iv::db::dataReply>* PrepareAsyncquerydataRaw(::grpc::ClientContext* context, const ::iv::db::dataRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::iv::db::FiledbReply>* AsyncdowndbfileRaw(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::iv::db::FiledbReply>* PrepareAsyncdowndbfileRaw(::grpc::ClientContext* context, const ::iv::db::Filedbreq& request, ::grpc::CompletionQueue* cq) override;
     const ::grpc::internal::RpcMethod rpcmethod_querylist_;
     const ::grpc::internal::RpcMethod rpcmethod_querydata_;
+    const ::grpc::internal::RpcMethod rpcmethod_downdbfile_;
   };
   static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
 
@@ -153,6 +184,7 @@ class dbservice final {
     virtual ~Service();
     virtual ::grpc::Status querylist(::grpc::ServerContext* context, const ::iv::db::listRequest* request, ::iv::db::listReply* response);
     virtual ::grpc::Status querydata(::grpc::ServerContext* context, const ::iv::db::dataRequest* request, ::iv::db::dataReply* response);
+    virtual ::grpc::Status downdbfile(::grpc::ServerContext* context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response);
   };
   template <class BaseClass>
   class WithAsyncMethod_querylist : public BaseClass {
@@ -194,7 +226,27 @@ class dbservice final {
       ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
     }
   };
-  typedef WithAsyncMethod_querylist<WithAsyncMethod_querydata<Service > > AsyncService;
+  template <class BaseClass>
+  class WithAsyncMethod_downdbfile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_downdbfile() {
+      ::grpc::Service::MarkMethodAsync(2);
+    }
+    ~WithAsyncMethod_downdbfile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status downdbfile(::grpc::ServerContext* /*context*/, const ::iv::db::Filedbreq* /*request*/, ::iv::db::FiledbReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void Requestdowndbfile(::grpc::ServerContext* context, ::iv::db::Filedbreq* request, ::grpc::ServerAsyncResponseWriter< ::iv::db::FiledbReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  typedef WithAsyncMethod_querylist<WithAsyncMethod_querydata<WithAsyncMethod_downdbfile<Service > > > AsyncService;
   template <class BaseClass>
   class ExperimentalWithCallbackMethod_querylist : public BaseClass {
    private:
@@ -289,11 +341,58 @@ class dbservice final {
     #endif
       { return nullptr; }
   };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_downdbfile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithCallbackMethod_downdbfile() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodCallback(2,
+          new ::grpc::internal::CallbackUnaryHandler< ::iv::db::Filedbreq, ::iv::db::FiledbReply>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context, const ::iv::db::Filedbreq* request, ::iv::db::FiledbReply* response) { return this->downdbfile(context, request, response); }));}
+    void SetMessageAllocatorFor_downdbfile(
+        ::grpc::experimental::MessageAllocator< ::iv::db::Filedbreq, ::iv::db::FiledbReply>* allocator) {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(2);
+    #else
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::experimental().GetHandler(2);
+    #endif
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::iv::db::Filedbreq, ::iv::db::FiledbReply>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_downdbfile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status downdbfile(::grpc::ServerContext* /*context*/, const ::iv::db::Filedbreq* /*request*/, ::iv::db::FiledbReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerUnaryReactor* downdbfile(
+      ::grpc::CallbackServerContext* /*context*/, const ::iv::db::Filedbreq* /*request*/, ::iv::db::FiledbReply* /*response*/)
+    #else
+    virtual ::grpc::experimental::ServerUnaryReactor* downdbfile(
+      ::grpc::experimental::CallbackServerContext* /*context*/, const ::iv::db::Filedbreq* /*request*/, ::iv::db::FiledbReply* /*response*/)
+    #endif
+      { return nullptr; }
+  };
   #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
-  typedef ExperimentalWithCallbackMethod_querylist<ExperimentalWithCallbackMethod_querydata<Service > > CallbackService;
+  typedef ExperimentalWithCallbackMethod_querylist<ExperimentalWithCallbackMethod_querydata<ExperimentalWithCallbackMethod_downdbfile<Service > > > CallbackService;
   #endif
 
-  typedef ExperimentalWithCallbackMethod_querylist<ExperimentalWithCallbackMethod_querydata<Service > > ExperimentalCallbackService;
+  typedef ExperimentalWithCallbackMethod_querylist<ExperimentalWithCallbackMethod_querydata<ExperimentalWithCallbackMethod_downdbfile<Service > > > ExperimentalCallbackService;
   template <class BaseClass>
   class WithGenericMethod_querylist : public BaseClass {
    private:
@@ -329,6 +428,23 @@ class dbservice final {
     }
   };
   template <class BaseClass>
+  class WithGenericMethod_downdbfile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_downdbfile() {
+      ::grpc::Service::MarkMethodGeneric(2);
+    }
+    ~WithGenericMethod_downdbfile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status downdbfile(::grpc::ServerContext* /*context*/, const ::iv::db::Filedbreq* /*request*/, ::iv::db::FiledbReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
   class WithRawMethod_querylist : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
@@ -369,6 +485,26 @@ class dbservice final {
     }
   };
   template <class BaseClass>
+  class WithRawMethod_downdbfile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_downdbfile() {
+      ::grpc::Service::MarkMethodRaw(2);
+    }
+    ~WithRawMethod_downdbfile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status downdbfile(::grpc::ServerContext* /*context*/, const ::iv::db::Filedbreq* /*request*/, ::iv::db::FiledbReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void Requestdowndbfile(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
   class ExperimentalWithRawCallbackMethod_querylist : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
@@ -445,6 +581,44 @@ class dbservice final {
       { return nullptr; }
   };
   template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_downdbfile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithRawCallbackMethod_downdbfile() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodRawCallback(2,
+          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->downdbfile(context, request, response); }));
+    }
+    ~ExperimentalWithRawCallbackMethod_downdbfile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status downdbfile(::grpc::ServerContext* /*context*/, const ::iv::db::Filedbreq* /*request*/, ::iv::db::FiledbReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerUnaryReactor* downdbfile(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)
+    #else
+    virtual ::grpc::experimental::ServerUnaryReactor* downdbfile(
+      ::grpc::experimental::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)
+    #endif
+      { return nullptr; }
+  };
+  template <class BaseClass>
   class WithStreamedUnaryMethod_querylist : public BaseClass {
    private:
     void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
@@ -498,9 +672,36 @@ class dbservice final {
     // replace default version of method with streamed unary
     virtual ::grpc::Status Streamedquerydata(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::iv::db::dataRequest,::iv::db::dataReply>* server_unary_streamer) = 0;
   };
-  typedef WithStreamedUnaryMethod_querylist<WithStreamedUnaryMethod_querydata<Service > > StreamedUnaryService;
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_downdbfile : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_downdbfile() {
+      ::grpc::Service::MarkMethodStreamed(2,
+        new ::grpc::internal::StreamedUnaryHandler<
+          ::iv::db::Filedbreq, ::iv::db::FiledbReply>(
+            [this](::grpc::ServerContext* context,
+                   ::grpc::ServerUnaryStreamer<
+                     ::iv::db::Filedbreq, ::iv::db::FiledbReply>* streamer) {
+                       return this->Streameddowndbfile(context,
+                         streamer);
+                  }));
+    }
+    ~WithStreamedUnaryMethod_downdbfile() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status downdbfile(::grpc::ServerContext* /*context*/, const ::iv::db::Filedbreq* /*request*/, ::iv::db::FiledbReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status Streameddowndbfile(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::iv::db::Filedbreq,::iv::db::FiledbReply>* server_unary_streamer) = 0;
+  };
+  typedef WithStreamedUnaryMethod_querylist<WithStreamedUnaryMethod_querydata<WithStreamedUnaryMethod_downdbfile<Service > > > StreamedUnaryService;
   typedef Service SplitStreamedService;
-  typedef WithStreamedUnaryMethod_querylist<WithStreamedUnaryMethod_querydata<Service > > StreamedService;
+  typedef WithStreamedUnaryMethod_querylist<WithStreamedUnaryMethod_querydata<WithStreamedUnaryMethod_downdbfile<Service > > > StreamedService;
 };
 
 }  // namespace db

src/driver/driver_group_grpc_server/driver_group_grpc_server.pro

@@ -6,6 +6,7 @@ CONFIG += c++11 console
 CONFIG -= app_bundle
 
 
+system(protoc -I=./../../include/proto3 --cpp_out=./../../include/msgtype   ./../../include/proto3/grpcdb.proto)
 system(protoc -I=./../../include/proto3 --cpp_out=./../../include/msgtype   ./../../include/proto3/grpcgroup.proto)
 # The following define makes your compiler emit warnings if you use
 # any Qt feature that has been marked deprecated (the exact warnings

src/driver/driver_group_grpc_server/groupdb.cpp

@@ -216,7 +216,23 @@ void groupdb::run()
         }
         else
         {
-            msleep(50);
+            mqueryWaitMutex.lock();
+            mwc_query.wait(&mqueryWaitMutex,50);
+            mqueryWaitMutex.unlock();
+
+//            msleep(50);
+        }
+
+        if(mql_bUpdate)
+        {
+            ExecQueryList();
+            mql_wc.wakeAll();
+        }
+
+        if(mqd_bUpdate)
+        {
+            ExecQueryData();
+            mqd_wc.wakeAll();
         }
 //        msleep(1000);
 
@@ -316,52 +332,158 @@ void groupdb::CheckRecID()
     mMutexrec.unlock();
 }
 
-int groupdb::getlist(qint64 xfrom,qint64 xto,std::string &strvehid, std::vector<qint64> &xvectorrecordtime)
+void groupdb::ExecQueryList()
 {
-
-    QSqlDatabase xdatabase ;
-
-//    if(QSqlDatabase::contains("sqliteadc"))
-//        xdatabase = QSqlDatabase::database("sqliteadc");
-//    else
-        xdatabase = QSqlDatabase::addDatabase("QSQLITE","sqliteadc");
-
-    xdatabase.setDatabaseName(mstrdbpath.data());
-    if (!xdatabase.open())
+    QTime xTime;
+    xTime.start();
+    mql_Mutexdata.lock();
+    QSqlQuery query(mdatabase);
+    char strsen[1000];
+    snprintf(strsen,1000,"select * from recorddata where((recorddata.recordid >= %lld) &(recorddata.recordid <= %lld) &(recorddata.vehid = \"%s\"))",
+             mql_xfrom,mql_xto,mql_strvehid.data());
+    query.exec(strsen);
+    mql_xvectorrecordtime.clear();
+    if(!query.exec(strsen))
     {
-        qDebug("Error: Failed to connect database. error is %s ",xdatabase.lastError());
-        return -1;
+        qDebug()<<query.lastError();
     }
     else
     {
+        while(query.next())
+        {
+            int id = query.value(0).toInt();
+            qint64 recordid = query.value(1).toLongLong();
+            mql_xvectorrecordtime.push_back(recordid);
+            std::string strvehid = query.value(3).toString().toStdString();
 
- //       qDebug("Succeed to connect database.");
+        }
     }
+    mql_bUpdate = false;
+    mql_bUpdateRes = true;
+    mql_Mutexdata.unlock();
+    qDebug("Exec query time is : %d ",xTime.elapsed());
+}
 
-    QSqlQuery query(xdatabase);
-
+void groupdb::ExecQueryData()
+{
+    QTime xTime;
+    xTime.start();
+    mqd_Mutexdata.lock();
+    QSqlQuery query(mdatabase);
     char strsen[1000];
-    snprintf(strsen,1000,"select * from recorddata");
+    snprintf(strsen,1000,"select * from groupdata where((groupdata.recordid = %lld)  &(groupdata.vehid = \"%s\"))",
+             mqd_nrecordid,mqd_strvehid.data());
     query.exec(strsen);
     if(!query.exec(strsen))
     {
         qDebug()<<query.lastError();
+        mqd_bUpdateRes = false;
     }
     else
     {
         while(query.next())
         {
-            int id = query.value(0).toInt();
-            qint64 recordid = query.value(1).toLongLong();
-            std::string strvehid = query.value(3).toString().toStdString();
+//            int id = query.value(0).toInt();
+//            qint64 recordid = query.value(1).toLongLong();
+//            mql_xvectorrecordtime.push_back(recordid);
+//            std::string strvehid = query.value(3).toString().toStdString();
 
         }
+
+        mqd_filename = "temp";
+        mqd_filesize = 0;
+
+        mqd_bUpdateRes = true;
     }
+    mqd_bUpdate = false;
+
+    mqd_Mutexdata.unlock();
+    qDebug("Exec querydata time is : %d ",xTime.elapsed());
+}
 
-    xdatabase.close();
+int groupdb::getlist(qint64 xfrom,qint64 xto,std::string &strvehid, std::vector<qint64> &xvectorrecordtime)
+{
+    if(mbSQL == false)
+    {
+        return -1;
+    }
+
+    int nres = 0;
+
+    mql_Mutex.lock();
+    mql_Mutexdata.lock();
+    mql_xfrom = xfrom;
+    mql_xto = xto;
+    mql_bUpdateRes = false;
+    mql_bUpdate = true;
+    mql_strvehid = strvehid;
+    mql_Mutexdata.unlock();
+
+    mwc_query.wakeAll();
+    QTime xTime;
+    xTime.start();
+    mql_waitmutex.lock();
+    mql_wc.wait(&mql_waitmutex,300);
+    mql_waitmutex.unlock();
+    qDebug("query time is %d ",xTime.elapsed());
+
+    if(mql_bUpdateRes == false)
+    {
+        nres = -2;
+    }
+    else
+    {
+        mql_Mutexdata.lock();
+        xvectorrecordtime = mql_xvectorrecordtime;
+        mql_bUpdateRes = false;
+        mql_Mutexdata.unlock();
+    }
 
-    qDebug("query suc.");
+    mql_Mutex.unlock();
 
+    return nres;
+
+}
+
+int groupdb::getfilepath(qint64 nrecordid, std::string strvehid,std::string & strfilename,int & nfilesize)
+{
+    if(mbSQL == false)
+    {
+        return -1;
+    }
+
+    int nres = 0;
+
+    mqd_Mutex.lock();
+    mqd_Mutexdata.lock();
+    mqd_nrecordid = nrecordid;
+    mqd_strvehid = strvehid;
+    mqd_bUpdateRes = false;
+    mqd_bUpdate = true;
+    mqd_Mutexdata.unlock();
+
+    mwc_query.wakeAll();
+    QTime xTime;
+    xTime.start();
+    mqd_waitmutex.lock();
+    mqd_wc.wait(&mqd_waitmutex,1000);
+    mqd_waitmutex.unlock();
+    qDebug("query time is %d ",xTime.elapsed());
+
+    if(mqd_bUpdateRes == false)
+    {
+        nres = -2;
+    }
+    else
+    {
+        mqd_Mutexdata.lock();
+        mqd_bUpdateRes = false;
+        strfilename = mqd_filename;
+        nfilesize = mqd_filesize;
+        mqd_Mutexdata.unlock();
+    }
 
+    mqd_Mutex.unlock();
 
+    return nres;
 }

src/driver/driver_group_grpc_server/groupdb.h

@@ -9,6 +9,7 @@
 #include <QFile>
 #include <QThread>
 #include <QMutex>
+#include <QWaitCondition>
 
 #include <vector>
 
@@ -52,12 +53,46 @@ public:
 
     int getlist(qint64 xfrom,qint64 xto,std::string & strvehid, std::vector<qint64> & xvectorrecordtime);
 
+    int getfilepath(qint64 nrecordid,std::string strvehid,std::string & strfilename,int & nfilesize);
+
 private:
     std::vector<iv::groupdbmsg> mvectordbmsg;
     QMutex mMutexmsg;
     std::vector<iv::recid> mvectorrecid;
     QMutex mMutexrec;
 
+private:
+    qint64 mql_xfrom;
+    qint64 mql_xto;
+    std::string mql_strvehid;
+    std::vector<qint64> mql_xvectorrecordtime;
+    QMutex mql_Mutex;
+    QMutex mql_Mutexdata;
+    bool mql_bUpdate = false;
+    bool mql_bUpdateRes = false;
+    QMutex mql_waitmutex;
+    QWaitCondition mql_wc;
+
+private:
+    qint64 mqd_nrecordid;
+    std::string mqd_strvehid;
+    std::string mqd_filename;
+    int mqd_filesize = 0;
+    QMutex mqd_Mutex;
+    QMutex mqd_Mutexdata;
+    bool mqd_bUpdate = false;
+    bool mqd_bUpdateRes = false;
+    QMutex mqd_waitmutex;
+    QWaitCondition mqd_wc;
+
+private:
+    void ExecQueryList();
+    void ExecQueryData();
+
+private:
+    QMutex mqueryWaitMutex;
+    QWaitCondition mwc_query;
+
 private:
     void run();
 

src/driver/driver_group_grpc_server/groupmsgbuf.cpp

@@ -141,5 +141,37 @@ int groupmsgbuf::ProcDBListMsg(const iv::db::listRequest *preq, iv::db::listRepl
     std::string strvehid = preq->strvehid();
     xfrom = preq->fromtime();
     xto = preq->totime();
-    mpgroupdb->getlist(xfrom,xto,strvehid,xvectorrecord);
+    int nres = mpgroupdb->getlist(xfrom,xto,strvehid,xvectorrecord);
+    preply->set_strvehid(strvehid);
+
+    if(nres == 0)
+    {
+        preply->set_nres(nres);
+        if(xvectorrecord.size() > 0)
+        {
+            unsigned int i;
+            for(i=0;i<xvectorrecord.size();i++)
+            {
+                preply->add_recodetime(xvectorrecord[i]);
+            }
+        }
+    }
+    return 0;
+
+}
+
+int groupmsgbuf::ProcDBFileReqMsg(const iv::db::dataRequest *preq, iv::db::dataReply *preply)
+{
+    std::string strvehid = preq->strvehid();
+    qint64 nrecordid = preq->recodetime();
+    std::string strfilepath;
+    int nfilesize = 0;
+    int nres = mpgroupdb->getfilepath(nrecordid,strvehid,strfilepath,nfilesize);
+    preply->set_nres(nres);
+    if(nres == 0)
+    {
+        preply->set_strfilename(strfilepath);
+        preply->set_nfilesize(nfilesize);
+    }
+    return 0;
 }

src/driver/driver_group_grpc_server/groupmsgbuf.h

@@ -31,6 +31,7 @@ public:
     int ProcQueryMsg(const iv::group::groupRequest * preq,iv::group::groupReply* reply);
 
     int ProcDBListMsg(const iv::db::listRequest * preq,iv::db::listReply * preply);
+    int ProcDBFileReqMsg(const iv::db::dataRequest * preq,iv::db::dataReply * preply);
 
 private:
     std::vector<iv::groupmsgunit> mvectorgroupmsg;

src/driver/driver_group_grpc_server/main.cpp

@@ -77,6 +77,7 @@ class DBServiceImpl final : public iv::db::dbservice::Service{
                     iv::db::dataReply * reply) override {
 
  //     gpmsgbuf->ProcGroupMsg(request,reply);
+        gpmsgbuf->ProcDBFileReqMsg(request,reply);
 
       return Status::OK;
     }

src/include/proto3/grpcdb.proto

@@ -26,6 +26,7 @@ service dbservice {
 
   rpc querylist (listRequest) returns (listReply) {}
   rpc querydata (dataRequest) returns (dataReply) {}
+  rpc downdbfile(Filedbreq) returns (FiledbReply) {}
   
 }
 
@@ -40,6 +41,7 @@ message listRequest {
 message listReply {
   repeated int64 recodetime = 1;  
   string strvehid = 2; 
+  int32  nres = 3; //-2 query fail  -1 database not open 0 success
 }
 
 message dataRequest {
@@ -48,15 +50,26 @@ message dataRequest {
     int64  recodetime = 2;   //数据标识码
 }
 
-message datainfo
+
+message dataReply {
+
+    string strfilename = 1;   //车辆识别码
+    int32  nfilesize = 2;  //File Size
+    int32  nres = 3; //  -3 file save fail-2 query fail  -1 database not open 0 success
+}
+
+message Filedbreq
 {
-  int64 recvtime = 1;
-  int64 msgtime = 2;
-  bytes xdata = 3;
+  string strfilename = 1;
+  int64 nPos = 2;
+  int64 nSize = 3;
 }
 
-message dataReply {
+message FiledbReply {
+
+  int64 nfilesize = 1;
+  bytes xdata = 2;
+  int64 nSize = 3;
+  bool bLastPac = 4;
 
-    string strvehid = 1;   //车辆识别码
-    repeated datainfo mdata= 2;   //数据标识码
 }

src/tool/tool_grpcdb_query/grpcdbclient.cpp

@@ -44,6 +44,7 @@ void grpcdbclient::run()
             Status status = stub_->querylist(&context, xlistreq, &xlistreply);
             if (status.ok()) {
              std::cout<<"get list ok"<<std::endl;
+             mlistreply.CopyFrom(xlistreply);
              emit reqres(0);
             } else {
               std::cout << status.error_code() << ": " << status.error_message()
@@ -77,3 +78,9 @@ void grpcdbclient::requestlist(qint64 timefrom, qint64 timeto, std::string strve
     mblistrequpdate = true;
     mMutexReq.unlock();
 }
+
+int grpcdbclient::getlistreply(iv::db::listReply & xlistreply)
+{
+    xlistreply.CopyFrom(mlistreply);
+    return 0;
+}

src/tool/tool_grpcdb_query/grpcdbclient.h

@@ -25,6 +25,7 @@ private:
     std::string mstrserverport = "31011";
 
     iv::db::listRequest mlistreq;
+    iv::db::listReply mlistreply;
     bool mblistrequpdate = false;
     QMutex mMutexReq;
 
@@ -36,6 +37,7 @@ private:
 
 public:
     void requestlist(qint64 timefrom, qint64 timeto,std::string strvehid);
+    int getlistreply(iv::db::listReply & xlistreply);
 };
 
 #endif // GRPCDBCLIENT_H

src/tool/tool_grpcdb_query/mainwindow.cpp

@@ -15,6 +15,10 @@ MainWindow::MainWindow(QWidget *parent)
     mpdbclient->start();
     connect(mpdbclient,SIGNAL(reqres(int)),this,SLOT(onreqres(int)));
 
+    mpitemmodel = new QStandardItemModel(this);
+
+    ui->listView->setModel(mpitemmodel);
+
     setWindowTitle("Query grpcdb");
 }
 
@@ -50,6 +54,7 @@ void MainWindow::on_pushButton_setend_clicked()
 
 void MainWindow::on_pushButton_query_clicked()
 {
+    mpitemmodel->clear();
     QString strbegin = ui->lineEdit_begin->text();
     if(strbegin == "")
     {
@@ -115,4 +120,42 @@ void MainWindow::onreqres(int nres)
         QMessageBox::warning(this,"Warning","Connect to Server Fail.",QMessageBox::YesAll);
         return;
     }
+    iv::db::listReply xlistreply;
+    mpdbclient->getlistreply(xlistreply);
+    if(xlistreply.nres() == 0)
+    {
+        unsigned int i;
+        for(i=0;i<xlistreply.recodetime_size();i++)
+        {
+            qint64 timex = xlistreply.recodetime(i);
+            QDateTime dt = QDateTime::fromMSecsSinceEpoch(timex);
+            QStandardItem * item = new QStandardItem(dt.toString("yyyy/MM/dd hh:mm:ss:zzz"));
+            mpitemmodel->appendRow(item);
+        }
+        QMessageBox::information(this,"Info","Query List Successfully.",QMessageBox::YesAll);
+
+    }
+    else
+    {
+        if(xlistreply.nres() == -1)
+        {
+            QMessageBox::warning(this,"Warning","Server Open DataBase Fail.",QMessageBox::YesAll);
+        }
+        if(xlistreply.nres() == -2)
+        {
+            QMessageBox::warning(this,"Waring","Server Database Busy.",QMessageBox::YesAll);
+        }
+    }
+}
+
+void MainWindow::on_pushButton_DownLoad_clicked()
+{
+    QString strrecord = ui->listView->currentIndex().data().toString();
+    qDebug(strrecord.toLatin1().data());
+
+    if(strrecord == "")
+    {
+        QMessageBox::warning(this,"Warning","No Select.",QMessageBox::YesAll);
+        return;
+    }
 }

src/tool/tool_grpcdb_query/mainwindow.h

@@ -3,6 +3,8 @@
 
 #include <QMainWindow>
 
+#include <QStandardItemModel>
+
 #include "grpcdbclient.h"
 
 QT_BEGIN_NAMESPACE
@@ -26,9 +28,13 @@ private slots:
 
     void onreqres(int nres);
 
+    void on_pushButton_DownLoad_clicked();
+
 private:
     Ui::MainWindow *ui;
 
     grpcdbclient * mpdbclient;
+
+    QStandardItemModel * mpitemmodel;
 };
 #endif // MAINWINDOW_H