You are viewing a plain text version of this content. The canonical link for it is here.
Posted to derby-dev@db.apache.org by "Bryan Pendleton (JIRA)" <de...@db.apache.org> on 2006/02/12 03:39:28 UTC
[jira] Created: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Allow use of DRDA QRYDTA block sizes greater than 32K
-----------------------------------------------------
Key: DERBY-959
URL: http://issues.apache.org/jira/browse/DERBY-959
Project: Derby
Type: Improvement
Components: Network Client, Performance, Network Server
Versions: 10.2.0.0, 10.1.1.0, 10.1.1.1, 10.1.1.2
Reporter: Bryan Pendleton
Priority: Minor
I came across the following statement in the DRDA spec (Volume 1, page 12):
Blocking applies only to the QRYDTA reply objects. Each
query block is a QRYDTA DSS. The maximum query block size
value allowed in the qryblksz parameter is increased from
32K to 10M, thus accomodating the larger data volumes
required by modern, more data-intensive applications.
The importance of larger block sizes depends strong on the application
profile.. For example, many applications perform single-record selects,
and they are not influenced by the block size.
But for some applications, it seems like the ability to use a larger block
size could be quite valuable.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
[jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by "Mike Matrigali (JIRA)" <de...@db.apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-959?page=all ]
Mike Matrigali updated DERBY-959:
---------------------------------
Fix Version: 10.2.0.0
I committed the xxx patch to the trunk:
m1_142:151>svn commit
Sending java\drda\org\apache\derby\impl\drda\CodePoint.java
Sending java\testing\org\apache\derbyTesting\functionTests\master\testProtocol.out
Sending java\testing\org\apache\derbyTesting\functionTests\tests\derbynet\protocol.tests
Sending java\testing\org\apache\derbyTesting\functionTests\tests\derbynet\testProtocol_app.properties
Transmitting file data ....
Committed revision 416485.
> Allow use of DRDA QRYDTA block sizes greater than 32K
> -----------------------------------------------------
>
> Key: DERBY-959
> URL: http://issues.apache.org/jira/browse/DERBY-959
> Project: Derby
> Type: Improvement
> Components: Network Client, Performance, Network Server
> Versions: 10.1.1.0, 10.2.0.0, 10.1.1.1, 10.1.1.2
> Reporter: Bryan Pendleton
> Priority: Minor
> Fix For: 10.2.0.0
> Attachments: 959Notes_v1.html, SmallRows_32kBlkSz.trace, SmallRows_64kBlkSz.trace, derby959.review.diff.txt, derby959.review.stat.txt, odbc_rowgreaterthan64k.trace
>
> Currently, the Network Server and Network Client use a 32K blocksize when
> returning database data in QRYDTA blocks.
> I came across the following statement in the DRDA spec (Volume 1, page 12):
> Blocking applies only to the QRYDTA reply objects. Each
> query block is a QRYDTA DSS. The maximum query block size
> value allowed in the qryblksz parameter is increased from
> 32K to 10M, thus accomodating the larger data volumes
> required by modern, more data-intensive applications.
> The importance of larger block sizes depends strong on the application
> profile.. For example, many applications perform single-record selects,
> and they are not influenced by the block size.
> But for some applications, it seems like the ability to use a larger block
> size could be quite valuable.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
[jira] Commented: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by "Sunitha Kambhampati (JIRA)" <de...@db.apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-959?page=comments#action_12417367 ]
Sunitha Kambhampati commented on DERBY-959:
-------------------------------------------
Discussion happened on this issue on derby-dev. Here is the link to the discussion that happened on derby-dev
http://www.nabble.com/-jira--Created%3A-%28DERBY-959%29-Allow-use-of-DRDA-QRYDTA-block-sizes-greater-than-32K-t1106974.html#a2892273
I have opened two other jira issues for the tasks related to this issue. .
DERBY-1441 - client side changes to support query block size greater than 32k
DERBY-1442- to do performance analysis and come up with a 'good' query block size value for the client to send to the server.
> Allow use of DRDA QRYDTA block sizes greater than 32K
> -----------------------------------------------------
>
> Key: DERBY-959
> URL: http://issues.apache.org/jira/browse/DERBY-959
> Project: Derby
> Type: Improvement
> Components: Network Client, Performance, Network Server
> Versions: 10.1.1.0, 10.2.0.0, 10.1.1.1, 10.1.1.2
> Reporter: Bryan Pendleton
> Priority: Minor
> Attachments: 959Notes_v1.html, SmallRows_32kBlkSz.trace, SmallRows_64kBlkSz.trace, derby959.review.diff.txt, derby959.review.stat.txt, odbc_rowgreaterthan64k.trace
>
> Currently, the Network Server and Network Client use a 32K blocksize when
> returning database data in QRYDTA blocks.
> I came across the following statement in the DRDA spec (Volume 1, page 12):
> Blocking applies only to the QRYDTA reply objects. Each
> query block is a QRYDTA DSS. The maximum query block size
> value allowed in the qryblksz parameter is increased from
> 32K to 10M, thus accomodating the larger data volumes
> required by modern, more data-intensive applications.
> The importance of larger block sizes depends strong on the application
> profile.. For example, many applications perform single-record selects,
> and they are not influenced by the block size.
> But for some applications, it seems like the ability to use a larger block
> size could be quite valuable.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Mike Matrigali <mi...@sbcglobal.net>.
Bryan Pendleton wrote:
>> Please let me know if you need more information to understand these
>> traces. Thanks.
>
>
> The traces look good to me, although of course it is always hard to read
> traces,
> it's just a fact of life.
>
> You mentioned that this is a server-only patch at this point; have you
> started
> to think about what we should do to the client to take advantage of this?
>
> Also, thanks very much for clarifying the 10 Meg maximum from the DRDA
> spec.
>
> Have you thought about what a "good" value might be for the server? It
> seems like
> there might be reasons that a value higher than 32K, but lower than 10
> Meg, turns
> out to offer the best tradeoffs of performance, memory usage, etc. I
> imagine that
> we would want to run some benchmarks to try to investigate the buffering
> behaviors
> and where the interesting points are in the performance of the network
> code. What
> sort of measurements would be revealing?
Sounds like a new jira entry should be created to test and explore
changing the default size. Seems safe to commit this change and then
change default once more work is done to understand the tradeoffs.
>
> thanks,
>
> bryan
>
>
>
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Bryan Pendleton <bp...@amberpoint.com>.
> But my point was to state that - irrespective of what a "good" value
> for the client & server is, the server's max query blocksize should be
> 10M ( which is per the spec). Does that sound reasonable to you ?
Yes, absolutely.
thanks,
bryan
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Sunitha Kambhampati <ks...@gmail.com>.
Kathey Marsden wrote:
> Does the max query blocksize affect the DDMReader buffer size?
Good question. I assume you meant the DDMWriter that has the send
buffer, initial size of 32767.
The max query blocksize is an upper bound on the query block size that
the server will accept. This max value wont influence the send buffer
size, but the query block size (qryblksz) sent by the client will affect
the buffer size.
Here's my understanding of why that is the case:
qryblksz comes into play when returning data to the client. For
LMTBLKPRC, we read one entire row and write out into the "send buffer"
the data. If the "send buffer" cannot hold the data, we expand the
buffer size. ( DDMWriter.ensureLength()). Currently, the server's
algorithm for this is to compute the length of the current row, and to
stop trying to pack more rows into this buffer if another row of that
length would not fit into one query block of qryblksz.
So here are some cases:
Scenario 1 : Client sends 32k qryblksz, Server max qryblksz is 32k
Scenario 2: Client sends 32k qryblksz, Server max qryblksz is 10M
The memory consumption will not change in both these cases.
Scenario 3: Client sends 32k qryblksz, Server max qryblksz is 10M
Scenario 4: Client sends 64k qryblksz, Server max qryblksz is 10M
Scenario 4's buffer size will be greater than in Scenario 3. The fact
that the client sends a larger query block size will affect the buffer
size.
Scenario5: C Client sends 64k qryblksz, Server max qryblksize is 32k
--- Throws a protocol exception
Scenario 6: C client sends 64k qryblksz, Server max qryblksz is 10M ---
works ok.
Hope this helps (?).
Thanks,
Sunitha.
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Kathey Marsden <km...@sbcglobal.net>.
Sunitha Kambhampati wrote:
>
> But my point was to state that - irrespective of what a "good" value
> for the client & server is, the server's max query blocksize should be
> 10M ( which is per the spec).
I am sorry I have not followed this issue and thread closely but was
wondering. Does the max query blocksize affect the DDMReader buffer size?
Kathey
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Sunitha Kambhampati <ks...@gmail.com>.
Bryan Pendleton wrote:
>> So I think -- The server max size for blocksize should be 10M because
>> that is the limit that is allowed by the spec. From my understanding
>> of the spec, the server does not get to choose the blocksize for
>> QRYDTA. It is the client which sends the qryblksz.
>
>
> I agree with your analysis of the spec.
>
> Are you concerned that this may present any sort of denial-of-service
> opportunity for a malicious client? That is, a poorly-written or
> outright-evil client could establish multiple connections, all requesting
> 10 Mb buffers, and starve the server out of memory?
>
No. I am not so much concerned about malicious clients. As you say, it
is pretty unlikely. Also I think, if needed it is possible to prevent
malicious clients from connecting to the server by turning on user
authentication, running with security manager etc. Assumption is
ofcourse that the "trusted" users are trusted enough to not use
malicious clients.
But my point was to state that - irrespective of what a "good" value
for the client & server is, the server's max query blocksize should be
10M ( which is per the spec). Does that sound reasonable to you ?
Thanks,
Sunitha.
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Bryan Pendleton <bp...@amberpoint.com>.
> So I think -- The server max size for blocksize should be 10M because
> that is the limit that is allowed by the spec. From my understanding of
> the spec, the server does not get to choose the blocksize for QRYDTA. It
> is the client which sends the qryblksz.
I agree with your analysis of the spec.
Are you concerned that this may present any sort of denial-of-service
opportunity for a malicious client? That is, a poorly-written or
outright-evil client could establish multiple connections, all requesting
10 Mb buffers, and starve the server out of memory?
I think this is pretty unlikely, but I thought I'd raise the question and
see what your reaction was. 10 Mb per connection is a non-insignificant
amount of memory, particularly for a server with dozens or hundreds of connections.
thanks,
bryan
P.S. I agree with you and Mike that the benchmarking should be separated
out into a separate work item.
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Sunitha Kambhampati <ks...@gmail.com>.
Bryan Pendleton wrote:
> The traces look good to me, although of course it is always hard to
> read traces,
> it's just a fact of life.
True, traces are hard to read. Thanks very much for going through them
Bryan.
> You mentioned that this is a server-only patch at this point; have you
> started
> to think about what we should do to the client to take advantage of this?
I concentrated only at the server changes.
The client has a hardcoded length of the blocksize to DSS max size =
32767. So, I just tried one simple test really quickly. Changed the
length to 65535 and ran a simple select and it went fine. First look at
the trace seemed ok with respect to continuation headers. So maybe the
client changes could also be straighforward, I think lots more testing
is required.
.NetStatementRequest.java:
void buildQRYBLKSZ() throws SqlException {
- writeScalar4Bytes(CodePoint.QRYBLKSZ, DssConstants.MAX_DSS_LEN);
+ writeScalar4Bytes(CodePoint.QRYBLKSZ,65535);
}
>
> Have you thought about what a "good" value might be for the server?
I think another way to put it is , what should be the 'good' value of
qryblksz that the client must send to the server. Do you agree?
So I think -- The server max size for blocksize should be 10M because
that is the limit that is allowed by the spec. From my understanding of
the spec, the server does not get to choose the blocksize for QRYDTA. It
is the client which sends the qryblksz. Any value from 512 to 10M is a
valid query block size value per the spec and I think it is good and
safe to have our server accept those values since the server knows how
to already. That way, drda compliant clients, like the C client that
talks to our server will work OK when sending a valid queryblock size
value ( in this case 65535).
> It seems like
> there might be reasons that a value higher than 32K, but lower than 10
> Meg, turns
> out to offer the best tradeoffs of performance, memory usage, etc. I
> imagine that
> we would want to run some benchmarks to try to investigate the
> buffering behaviors
> and where the interesting points are in the performance of the network
> code. What
> sort of measurements would be revealing?
Good point. Thats right, I agree we need to run some benchmarks to help
us come up with a "good" value of qryblksz. I have not given much
thought to this yet. We need to take care of the memory usage, since
we pack the rows into the in-memory buffer of size of atleast qryblksz.
Also since the DSS max size is 32k always, the bigger the query
blocksize, the more bytes will need to be shifted to add the
continuation headers. So maybe selects with rows that will fill up the
query blocksize would be one test which might show the overhead involved
in shifting/copying large amount of bytes. It will be good to
investigate what other areas in our network code could be improved as
well. Dont know much about the tcp level limits etc and how they will
affect the packet sizes, have to learn. But googling, I found this
http://www.psc.edu/networking/projects/tcptune/
As Mike suggested, I'll open a subtask for perf analysis and the client
side changes for DERBY-959.
I wont be able to spend much time on this currently but hope someone
else may be interested in picking it up.
Thanks,
Sunitha.
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Bryan Pendleton <bp...@amberpoint.com>.
> Please let me know if you need more information to understand these traces. Thanks.
The traces look good to me, although of course it is always hard to read traces,
it's just a fact of life.
You mentioned that this is a server-only patch at this point; have you started
to think about what we should do to the client to take advantage of this?
Also, thanks very much for clarifying the 10 Meg maximum from the DRDA spec.
Have you thought about what a "good" value might be for the server? It seems like
there might be reasons that a value higher than 32K, but lower than 10 Meg, turns
out to offer the best tradeoffs of performance, memory usage, etc. I imagine that
we would want to run some benchmarks to try to investigate the buffering behaviors
and where the interesting points are in the performance of the network code. What
sort of measurements would be revealing?
thanks,
bryan
[jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by "Sunitha Kambhampati (JIRA)" <de...@db.apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-959?page=all ]
Sunitha Kambhampati updated DERBY-959:
--------------------------------------
Attachment: odbc_rowgreaterthan64k.trace
SmallRows_32kBlkSz.trace
SmallRows_64kBlkSz.trace
The new C client that I was testing the server with is sending a qryblksz of 65535 and I gathered server traces with it. I am attaching the trace files here .
odbc_rowgreaterthan64k.trace -- using C client, trace has select of a table with 4 rows each row having more than 64k of data. The table has 341 columns of type char(200).
SmallRows_32kBlkSz.trace - this server trace was gathered when running with the client driver(jdbc). query is a simple select * from tbl. where the table has rows ~ 10k each.
SmallRows_64kBlkSz.trace - this server trace was gathered when running with the C client that sends a qryblksz of 65535. query is a simple select * from tbl. where the table has rows ~ 10k each.
Please let me know if you need more information to understand these traces. Thanks.
> Allow use of DRDA QRYDTA block sizes greater than 32K
> -----------------------------------------------------
>
> Key: DERBY-959
> URL: http://issues.apache.org/jira/browse/DERBY-959
> Project: Derby
> Type: Improvement
> Components: Network Client, Performance, Network Server
> Versions: 10.1.1.0, 10.2.0.0, 10.1.1.1, 10.1.1.2
> Reporter: Bryan Pendleton
> Priority: Minor
> Attachments: 959Notes_v1.html, SmallRows_32kBlkSz.trace, SmallRows_64kBlkSz.trace, derby959.review.diff.txt, derby959.review.stat.txt, odbc_rowgreaterthan64k.trace
>
> Currently, the Network Server and Network Client use a 32K blocksize when
> returning database data in QRYDTA blocks.
> I came across the following statement in the DRDA spec (Volume 1, page 12):
> Blocking applies only to the QRYDTA reply objects. Each
> query block is a QRYDTA DSS. The maximum query block size
> value allowed in the qryblksz parameter is increased from
> 32K to 10M, thus accomodating the larger data volumes
> required by modern, more data-intensive applications.
> The importance of larger block sizes depends strong on the application
> profile.. For example, many applications perform single-record selects,
> and they are not influenced by the block size.
> But for some applications, it seems like the ability to use a larger block
> size could be quite valuable.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Sunitha Kambhampati <ks...@gmail.com>.
Army wrote:
> Bryan Pendleton wrote:
>
>> Why did you pick 10 Meg as the new max value? Was that arbitrary, or
>> does it derive from some other fundamental limit?
>
>
> In the DDM manual that I have (version 3 volume 3, which I think is
> from 2004) the max value for QRYBLKSZ is listed as "MAXVAL 10,485,760
> (10M)". Also, in the DRDA manual for the same year, under the heading
> "Simplified Query Processing Rules", there's the following quote:
>
> "Blocking applies only to the QRYDTA reply objects. Each query block
> is a QRYDTA DSS. The maximum query block size value allowed in the
> qryblksz parameter is increased from 32K to 10M, thus accommodating
> the larger data volumes required by modern, more data-intensive
> applications."
>
> I'm not sure if these are the most recent versions of the manuals, but
> I think this is probably where the 10M limit comes from...
>
Thanks Bryan and Army for looking at this.
Yes, the 10M was picked because it is the maximum query block size
allowed per the spec. The Version 3 specs are the latest specs after
looking at the development history of the spec on the opengroup site.
https://www.opengroup.org/projects/drda/uploads/40/9359/history.htm and
they are from 2004. http://www.opengroup.org/bookstore/catalog/c043.htm
this is the link that I can get to to download the specs and it has
version 3.
I'll also update the notes on the jira.
Thanks,
Sunitha.
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Army <qo...@gmail.com>.
Bryan Pendleton wrote:
> Why did you pick 10 Meg as the new max value? Was that arbitrary, or
> does it derive from some other fundamental limit?
In the DDM manual that I have (version 3 volume 3, which I think is from 2004)
the max value for QRYBLKSZ is listed as "MAXVAL 10,485,760 (10M)". Also, in the
DRDA manual for the same year, under the heading "Simplified Query Processing
Rules", there's the following quote:
"Blocking applies only to the QRYDTA reply objects. Each query block is a
QRYDTA DSS. The maximum query block size value allowed in the qryblksz parameter
is increased from 32K to 10M, thus accommodating the larger data volumes
required by modern, more data-intensive applications."
I'm not sure if these are the most recent versions of the manuals, but I think
this is probably where the 10M limit comes from...
Army
Re: [jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by Bryan Pendleton <bp...@amberpoint.com>.
Sunitha Kambhampati (JIRA) wrote:
> I am attaching a patch 'derby959.review.diff.txt' to get feedback on the server changes
Hi Sunitha, this is great work! It's good to see that this may turn out to be a
straightforward change.
I didn't have time to read the traces yet, just read the notes and the diff. I'll
try to look through it some more soon.
Why did you pick 10 Meg as the new max value? Was that arbitrary, or does it
derive from some other fundamental limit?
thanks,
bryan
[jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by "Sunitha Kambhampati (JIRA)" <de...@db.apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-959?page=all ]
Sunitha Kambhampati updated DERBY-959:
--------------------------------------
Attachment: 959Notes_v1.html
derby959.review.diff.txt
derby959.review.stat.txt
I am attaching a patch 'derby959.review.diff.txt' to get feedback on the server changes to allow for query block size greater than 32k. From the test cases that I tried, it seems to me that the server already knows how to handle sending QRYDTA greater than 32k.
Please see the attached html file 959Notes_v1.html for more notes:
This is a network server only change and I ran the derbynetclientmats and derbynetmats with 1.4.2 sun jvm OK on windows.
I'd appreciate your comments and feedback.
Thanks.
> Allow use of DRDA QRYDTA block sizes greater than 32K
> -----------------------------------------------------
>
> Key: DERBY-959
> URL: http://issues.apache.org/jira/browse/DERBY-959
> Project: Derby
> Type: Improvement
> Components: Network Client, Performance, Network Server
> Versions: 10.2.0.0, 10.1.1.0, 10.1.1.1, 10.1.1.2
> Reporter: Bryan Pendleton
> Priority: Minor
> Attachments: 959Notes_v1.html, derby959.review.diff.txt, derby959.review.stat.txt
>
> Currently, the Network Server and Network Client use a 32K blocksize when
> returning database data in QRYDTA blocks.
> I came across the following statement in the DRDA spec (Volume 1, page 12):
> Blocking applies only to the QRYDTA reply objects. Each
> query block is a QRYDTA DSS. The maximum query block size
> value allowed in the qryblksz parameter is increased from
> 32K to 10M, thus accomodating the larger data volumes
> required by modern, more data-intensive applications.
> The importance of larger block sizes depends strong on the application
> profile.. For example, many applications perform single-record selects,
> and they are not influenced by the block size.
> But for some applications, it seems like the ability to use a larger block
> size could be quite valuable.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
[jira] Closed: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by "Bryan Pendleton (JIRA)" <de...@db.apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-959?page=all ]
Bryan Pendleton closed DERBY-959:
---------------------------------
Thanks Sunitha for addressing this! Fix verified as complete.
> Allow use of DRDA QRYDTA block sizes greater than 32K
> -----------------------------------------------------
>
> Key: DERBY-959
> URL: http://issues.apache.org/jira/browse/DERBY-959
> Project: Derby
> Type: Improvement
> Components: Network Client, Performance, Network Server
> Versions: 10.2.0.0, 10.1.1.0, 10.1.1.1, 10.1.1.2
> Reporter: Bryan Pendleton
> Assignee: Sunitha Kambhampati
> Priority: Minor
> Fix For: 10.2.0.0
> Attachments: 959Notes_v1.html, SmallRows_32kBlkSz.trace, SmallRows_64kBlkSz.trace, derby959.review.diff.txt, derby959.review.stat.txt, odbc_rowgreaterthan64k.trace
>
> Currently, the Network Server and Network Client use a 32K blocksize when
> returning database data in QRYDTA blocks.
> I came across the following statement in the DRDA spec (Volume 1, page 12):
> Blocking applies only to the QRYDTA reply objects. Each
> query block is a QRYDTA DSS. The maximum query block size
> value allowed in the qryblksz parameter is increased from
> 32K to 10M, thus accomodating the larger data volumes
> required by modern, more data-intensive applications.
> The importance of larger block sizes depends strong on the application
> profile.. For example, many applications perform single-record selects,
> and they are not influenced by the block size.
> But for some applications, it seems like the ability to use a larger block
> size could be quite valuable.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
[jira] Resolved: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by "Sunitha Kambhampati (JIRA)" <de...@db.apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-959?page=all ]
Sunitha Kambhampati resolved DERBY-959:
---------------------------------------
Resolution: Fixed
This fix has been code for sometime. I have verified this fix with the odbc client driver.
> Allow use of DRDA QRYDTA block sizes greater than 32K
> -----------------------------------------------------
>
> Key: DERBY-959
> URL: http://issues.apache.org/jira/browse/DERBY-959
> Project: Derby
> Type: Improvement
> Components: Network Client, Performance, Network Server
> Versions: 10.2.0.0, 10.1.1.0, 10.1.1.1, 10.1.1.2
> Reporter: Bryan Pendleton
> Assignee: Sunitha Kambhampati
> Priority: Minor
> Fix For: 10.2.0.0
> Attachments: 959Notes_v1.html, SmallRows_32kBlkSz.trace, SmallRows_64kBlkSz.trace, derby959.review.diff.txt, derby959.review.stat.txt, odbc_rowgreaterthan64k.trace
>
> Currently, the Network Server and Network Client use a 32K blocksize when
> returning database data in QRYDTA blocks.
> I came across the following statement in the DRDA spec (Volume 1, page 12):
> Blocking applies only to the QRYDTA reply objects. Each
> query block is a QRYDTA DSS. The maximum query block size
> value allowed in the qryblksz parameter is increased from
> 32K to 10M, thus accomodating the larger data volumes
> required by modern, more data-intensive applications.
> The importance of larger block sizes depends strong on the application
> profile.. For example, many applications perform single-record selects,
> and they are not influenced by the block size.
> But for some applications, it seems like the ability to use a larger block
> size could be quite valuable.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
[jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by "Dag H. Wanvik (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/DERBY-959?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Dag H. Wanvik updated DERBY-959:
--------------------------------
Derby Categories: [Performance]
> Allow use of DRDA QRYDTA block sizes greater than 32K
> -----------------------------------------------------
>
> Key: DERBY-959
> URL: https://issues.apache.org/jira/browse/DERBY-959
> Project: Derby
> Issue Type: Improvement
> Components: Network Client, Network Server
> Affects Versions: 10.1.1.0, 10.1.2.1, 10.2.1.6
> Reporter: Bryan Pendleton
> Assignee: Sunitha Kambhampati
> Priority: Minor
> Fix For: 10.2.1.6
>
> Attachments: 959Notes_v1.html, derby959.review.diff.txt, derby959.review.stat.txt, odbc_rowgreaterthan64k.trace, SmallRows_32kBlkSz.trace, SmallRows_64kBlkSz.trace
>
>
> Currently, the Network Server and Network Client use a 32K blocksize when
> returning database data in QRYDTA blocks.
> I came across the following statement in the DRDA spec (Volume 1, page 12):
> Blocking applies only to the QRYDTA reply objects. Each
> query block is a QRYDTA DSS. The maximum query block size
> value allowed in the qryblksz parameter is increased from
> 32K to 10M, thus accomodating the larger data volumes
> required by modern, more data-intensive applications.
> The importance of larger block sizes depends strong on the application
> profile.. For example, many applications perform single-record selects,
> and they are not influenced by the block size.
> But for some applications, it seems like the ability to use a larger block
> size could be quite valuable.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by "Mike Matrigali (JIRA)" <de...@db.apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-959?page=all ]
Mike Matrigali updated DERBY-959:
---------------------------------
I missed one file new file in previous commit, here is the svn commit for it:
m1_142:155>svn commit
Adding java\testing\org\apache\derbyTesting\functionTests\tests\derbynet\values64kblksz.inc
Transmitting file data .
Committed revision 416486.
> Allow use of DRDA QRYDTA block sizes greater than 32K
> -----------------------------------------------------
>
> Key: DERBY-959
> URL: http://issues.apache.org/jira/browse/DERBY-959
> Project: Derby
> Type: Improvement
> Components: Network Client, Performance, Network Server
> Versions: 10.1.1.0, 10.2.0.0, 10.1.1.1, 10.1.1.2
> Reporter: Bryan Pendleton
> Priority: Minor
> Fix For: 10.2.0.0
> Attachments: 959Notes_v1.html, SmallRows_32kBlkSz.trace, SmallRows_64kBlkSz.trace, derby959.review.diff.txt, derby959.review.stat.txt, odbc_rowgreaterthan64k.trace
>
> Currently, the Network Server and Network Client use a 32K blocksize when
> returning database data in QRYDTA blocks.
> I came across the following statement in the DRDA spec (Volume 1, page 12):
> Blocking applies only to the QRYDTA reply objects. Each
> query block is a QRYDTA DSS. The maximum query block size
> value allowed in the qryblksz parameter is increased from
> 32K to 10M, thus accomodating the larger data volumes
> required by modern, more data-intensive applications.
> The importance of larger block sizes depends strong on the application
> profile.. For example, many applications perform single-record selects,
> and they are not influenced by the block size.
> But for some applications, it seems like the ability to use a larger block
> size could be quite valuable.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
[jira] Updated: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by "Bryan Pendleton (JIRA)" <de...@db.apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-959?page=all ]
Bryan Pendleton updated DERBY-959:
----------------------------------
Description:
Currently, the Network Server and Network Client use a 32K blocksize when
returning database data in QRYDTA blocks.
I came across the following statement in the DRDA spec (Volume 1, page 12):
Blocking applies only to the QRYDTA reply objects. Each
query block is a QRYDTA DSS. The maximum query block size
value allowed in the qryblksz parameter is increased from
32K to 10M, thus accomodating the larger data volumes
required by modern, more data-intensive applications.
The importance of larger block sizes depends strong on the application
profile.. For example, many applications perform single-record selects,
and they are not influenced by the block size.
But for some applications, it seems like the ability to use a larger block
size could be quite valuable.
was:
I came across the following statement in the DRDA spec (Volume 1, page 12):
Blocking applies only to the QRYDTA reply objects. Each
query block is a QRYDTA DSS. The maximum query block size
value allowed in the qryblksz parameter is increased from
32K to 10M, thus accomodating the larger data volumes
required by modern, more data-intensive applications.
The importance of larger block sizes depends strong on the application
profile.. For example, many applications perform single-record selects,
and they are not influenced by the block size.
But for some applications, it seems like the ability to use a larger block
size could be quite valuable.
> Allow use of DRDA QRYDTA block sizes greater than 32K
> -----------------------------------------------------
>
> Key: DERBY-959
> URL: http://issues.apache.org/jira/browse/DERBY-959
> Project: Derby
> Type: Improvement
> Components: Network Client, Performance, Network Server
> Versions: 10.2.0.0, 10.1.1.0, 10.1.1.1, 10.1.1.2
> Reporter: Bryan Pendleton
> Priority: Minor
>
> Currently, the Network Server and Network Client use a 32K blocksize when
> returning database data in QRYDTA blocks.
> I came across the following statement in the DRDA spec (Volume 1, page 12):
> Blocking applies only to the QRYDTA reply objects. Each
> query block is a QRYDTA DSS. The maximum query block size
> value allowed in the qryblksz parameter is increased from
> 32K to 10M, thus accomodating the larger data volumes
> required by modern, more data-intensive applications.
> The importance of larger block sizes depends strong on the application
> profile.. For example, many applications perform single-record selects,
> and they are not influenced by the block size.
> But for some applications, it seems like the ability to use a larger block
> size could be quite valuable.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira
[jira] Assigned: (DERBY-959) Allow use of DRDA QRYDTA block sizes
greater than 32K
Posted by "Sunitha Kambhampati (JIRA)" <de...@db.apache.org>.
[ http://issues.apache.org/jira/browse/DERBY-959?page=all ]
Sunitha Kambhampati reassigned DERBY-959:
-----------------------------------------
Assign To: Sunitha Kambhampati
> Allow use of DRDA QRYDTA block sizes greater than 32K
> -----------------------------------------------------
>
> Key: DERBY-959
> URL: http://issues.apache.org/jira/browse/DERBY-959
> Project: Derby
> Type: Improvement
> Components: Network Client, Performance, Network Server
> Versions: 10.2.0.0, 10.1.1.0, 10.1.1.1, 10.1.1.2
> Reporter: Bryan Pendleton
> Assignee: Sunitha Kambhampati
> Priority: Minor
> Fix For: 10.2.0.0
> Attachments: 959Notes_v1.html, SmallRows_32kBlkSz.trace, SmallRows_64kBlkSz.trace, derby959.review.diff.txt, derby959.review.stat.txt, odbc_rowgreaterthan64k.trace
>
> Currently, the Network Server and Network Client use a 32K blocksize when
> returning database data in QRYDTA blocks.
> I came across the following statement in the DRDA spec (Volume 1, page 12):
> Blocking applies only to the QRYDTA reply objects. Each
> query block is a QRYDTA DSS. The maximum query block size
> value allowed in the qryblksz parameter is increased from
> 32K to 10M, thus accomodating the larger data volumes
> required by modern, more data-intensive applications.
> The importance of larger block sizes depends strong on the application
> profile.. For example, many applications perform single-record selects,
> and they are not influenced by the block size.
> But for some applications, it seems like the ability to use a larger block
> size could be quite valuable.
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
http://www.atlassian.com/software/jira