You are viewing a plain text version of this content. The canonical link for it is here.
Posted to user@ignite.apache.org by Igor Sapego <is...@apache.org> on 2017/11/16 10:20:37 UTC
Re: Ignite ODBC Driver v/s Ignite C++ driver
Hi,
Ignite C++ indeed starts JVM process, but it is not just client,
it is basically ordinary Ignite node, that can be client or server
and can do in cluster almost anything, that Java Ignite node can,
although, C++ still does not have all the features that Java API
has. So, basically, C++ allows you to do much more than just
SQL.
On the other hand, our ODBC driver is the classic thin ODBC
driver, that uses TCP for connection to nodes, and only allows
you to run SQL queries.
If you only need client that will allow you to run SQL queries over
the grid, then Ignite C++ indeed has some overhead compared to
ODBC driver, though it is not that much about performance as
about memory consumption and startup time. You also need to
"warm up" C++ client to get good performance as it has significant
JVM part.
So if the only thing you need is DML and selects I'd
suggest you to go with the ODBC. But you also have mentioned
transactions, and currently, Ignite does not support transactional
SQL, though it supports transactions for cache operations by a
separate Transactions API. It is supported by Ignite C++, but you
obviously can not use it through ODBC.
Can you tell a little more what you need?
Best Regards,
Igor
On Thu, Nov 16, 2017 at 9:31 AM, kotamrajuyashasvi <
kotamrajuyashasvi@gmail.com> wrote:
> Hi
>
> I have a C++ Application that needs to perform query operations(DML and
> Select) and transactions on Ignite Server. Whats the best way to achieve
> this ? There are two choices: 1. Ignite ODBC driver and 2. Ignite C++
> Driver.
>
> I would like to what would be right choice to use from the point of
> scalability and performance.
>
> From the docs its mentioned that Ignite ODBC used TCP to communicate to
> Ignite server. On the other hand Ignite C++ Driver starts the JVM in the
> same process and communicates with it via JNI and this JVM process
> communicates with the Ignite Server. So Ignite C++ Driver has an additional
> JNI/JVM hop before communicating to the Ignite Server. Does this affect
> performance ? What are pros and cons of using each of the above choices
> available ? Apart from above two choices are there any better choices?
>
>
>
> --
> Sent from: http://apache-ignite-users.70518.x6.nabble.com/
>
Re: Ignite ODBC Driver v/s Ignite C++ driver
Posted by Igor Sapego <is...@apache.org>.
That's right. You can watch it for update notifications.
Best Regards,
Igor
On Fri, Nov 17, 2017 at 2:37 PM, kotamrajuyashasvi <
kotamrajuyashasvi@gmail.com> wrote:
> Hi
>
> Yes.. around 100-150 C++ processes or may be threads will be running on a
> machine, but each process/thread requires to use a separate transaction. I
> found out that along with sql transactions feature ticket, a separate
> ticket
> is present to implement transactions support for ODBC. Hope it will be
> implemented soon.
> https://issues.apache.org/jira/browse/IGNITE-4193
>
>
>
> --
> Sent from: http://apache-ignite-users.70518.x6.nabble.com/
>
Re: Ignite ODBC Driver v/s Ignite C++ driver
Posted by kotamrajuyashasvi <ko...@gmail.com>.
Hi
Yes.. around 100-150 C++ processes or may be threads will be running on a
machine, but each process/thread requires to use a separate transaction. I
found out that along with sql transactions feature ticket, a separate ticket
is present to implement transactions support for ODBC. Hope it will be
implemented soon.
https://issues.apache.org/jira/browse/IGNITE-4193
--
Sent from: http://apache-ignite-users.70518.x6.nabble.com/
Re: Ignite ODBC Driver v/s Ignite C++ driver
Posted by Igor Sapego <is...@apache.org>.
Well, the only solution for you now is to use Ignite client, since Ignite
do not support transactional SQL just yet. It is in plans though, to
implement transactions support for SQL in the next year.
Do you need to start a lot of parallel processes on a single machine?
Best Regards,
Igor
On Thu, Nov 16, 2017 at 4:40 PM, kotamrajuyashasvi <
kotamrajuyashasvi@gmail.com> wrote:
> Hi
>
> Thanks for your response. Actually I'm working on a C++ project where
> multiple C++ processes run in parallel. Each process should connect to
> Ignite Server initially and start a transaction. Cassandra is used as
> persistent store(The main reason to use ignite on top of Cassandra is for
> the purpose of transactions, since Cassandra does not support
> transactions).Then data will be extracted by the process from the server,
> process the data, update/delete/insert data into Ignite server and later
> some more data might be required to be extracted and processed or data
> might
> be updated/deleted/insert randomly depending upon the data that is
> received/extracted by the process. In between the transaction might be
> required to be rolled back depending upon business logic or
> errors/exceptions. Finally the transaction is commited if everything went
> fine with in a process. Then it can start another transaction. So I'm
> looking for a way to perform the operations on Ignite from my C++ process.
>
> Number of processes running in parallel can be around 150-200 max. The data
> processed by each process is not very large. It can be at max 50-70 Mb per
> transaction. I need to use a separate transaction context on each process.
> So I need to use a separate C++ Ignite client with additional logic of
> converting queries to get,put operations and perform transactions. But
> Ignite C++ is not light weight hence starting a separate Ignite C++
> instance
> for each of my C++ process might have impact on memory and performance. But
> If ODBC supported transactions it would not have much impact, since ODBC is
> a light weight client. I want to use Ignite server just like a RDBMS server
> and connect to it using thin client.
>
> can u suggest any solution
>
>
>
>
>
> --
> Sent from: http://apache-ignite-users.70518.x6.nabble.com/
>
Re: Ignite ODBC Driver v/s Ignite C++ driver
Posted by kotamrajuyashasvi <ko...@gmail.com>.
Hi
Thanks for your response. Actually I'm working on a C++ project where
multiple C++ processes run in parallel. Each process should connect to
Ignite Server initially and start a transaction. Cassandra is used as
persistent store(The main reason to use ignite on top of Cassandra is for
the purpose of transactions, since Cassandra does not support
transactions).Then data will be extracted by the process from the server,
process the data, update/delete/insert data into Ignite server and later
some more data might be required to be extracted and processed or data might
be updated/deleted/insert randomly depending upon the data that is
received/extracted by the process. In between the transaction might be
required to be rolled back depending upon business logic or
errors/exceptions. Finally the transaction is commited if everything went
fine with in a process. Then it can start another transaction. So I'm
looking for a way to perform the operations on Ignite from my C++ process.
Number of processes running in parallel can be around 150-200 max. The data
processed by each process is not very large. It can be at max 50-70 Mb per
transaction. I need to use a separate transaction context on each process.
So I need to use a separate C++ Ignite client with additional logic of
converting queries to get,put operations and perform transactions. But
Ignite C++ is not light weight hence starting a separate Ignite C++ instance
for each of my C++ process might have impact on memory and performance. But
If ODBC supported transactions it would not have much impact, since ODBC is
a light weight client. I want to use Ignite server just like a RDBMS server
and connect to it using thin client.
can u suggest any solution
--
Sent from: http://apache-ignite-users.70518.x6.nabble.com/