Support unsigned integer #618

mehmetgunturkun · 2017-05-11T19:58:27Z

Problem

finagle-mysql does not support unsigned integers. If an integer field is with unsigned attribute, it has larger maximum limit (4294967295) than signed integer. Since there is no support for unsigned integer in Java, if the value is higher than Integer.MAX_VALUE (2147483647), it is interpreted as IntValue(-1)

Solution

In order to understand the field is unsigned or not, I added bit masks for type attributes and a function to Field class. Bit masks for attributes are listed in the source code of mysql (https://github.com/mysql/mysql-server/blob/5.7/include/mysql_com.h). During field decoding, if the field is unsigned, I created a LongValue and used readUnsignedIntLE function from MysqlBufReader.

Additionally, added an integration test case into com.twitter.finagle.mysql.integration.TypeTest.NumericTypeTest. Added unsigned int field, inserted an integer value higher than Integer.MAX_VALUE, and expected to be parsed as LongValue.

mosesn

Thanks for the PR! Looks great so far.

mosesn · 2017-05-11T20:16:54Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Result.scala

@@ -146,6 +146,23 @@ object EOF extends Decoder[EOF] {
 case class EOF(warnings: Short, serverStatus: ServerStatus) extends Result

 /**
+* These bit masks are to understand whether corresponding attribute


these should be styled like:

/** * */

mosesn · 2017-05-11T20:23:05Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Row.scala

+          case Type.Tiny                        => ByteValue(str.toByte)
+          case Type.Short                       => ShortValue(str.toShort)
+          case Type.Int24                       => IntValue(str.toInt)
+          case Type.Long if field.isUnsigned()  => LongValue(str.toLong)


this won't work for longs bigger than 2^63, right? should we add a field to LongValue that we're encoding an unsigned long in a signed long? or add a new type, UnsignedLong?

I didn't get. Longs bigger than 2^63 has Type.LongLong instead of Type.Long. Should we use isUnsigned check for Type.LongLongs too?

well, unsigned longs have the same number of bits as signed longs, they're just encoded differently, so we could conceivably encode them as signed longs in scala. it's just a design decision. I don't think it would make sense to make them LongLongs, since we know it can't be most of the numbers in LongLongs. yeah, it would be nice to use isUnsigned for all of the types that could be unsigned.

ok then, just to clarify. I am using isUnsigned for Type.LongLong too and add another test case for that, right?

not exactly. suppose mysql wants to return an unsigned long of 9223372036854775808 (as we talked about below). "9223372036854775808".toLong fails. How do we do this properly? Note that mysql will consider it a long, not a longlong.

Yeah and if the data type of the column in MySQL, is unsigned long then the type of the field in finagle side is Type.LongLong.

BTW by saying

The column should be able to be unsigned long

You mean BIGINT UNSIGNED, right. Is there a data type long n MySQL?

yes, there's a Long type, that's the field that we match on in this code. although reading more, I think it's actually 4 bytes, not 8 bytes. but I'm really starting to think that all of the numeric values that we get out of mysql, we should annotate whether they're unsigned or not.

I think so too because the unsigned logic applies to all numeric values.

Think about smallint if it is unsigned it can go until 65535 in MySQL side, but we are converting it to Short which has 32767 as a MaxValue.

Hey @mosesn, should I write and send the new version that includes all numerical fields with isUnsigned check?

sounds good to me!

mosesn · 2017-05-11T20:23:29Z

finagle-mysql/src/test/scala/com/twitter/finagle/mysql/integration/TypeTest.scala

@@ -111,6 +112,13 @@ class NumericTypeTest extends FunSuite with IntegrationClient {
        case v => fail("expected a RawValue but got %s".format(v))
      }
    }
+
+    test("extract %s from %s".format("unsigned", rowType)) {


can we add a test for a long that's bigger than what scala can fit into a long?

sth like: 9223372036854775808 (BigInt(Long.MaxValue) + 1)?

that would be perfect =)

mosesn

sorry for the delay, I was sick over the weekend. I'm not sure how much I love this API, but since unsigned stuff is probably not the common case (and is difficult to represent in scala), and we can always change it if we have to, it's probably OK. let me get some more eyes on this but I think this should be good to go modulo a few small changes.

mosesn · 2017-05-16T20:58:02Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Row.scala

-          case Type.Float      => FloatValue(str.toFloat)
-          case Type.Double     => DoubleValue(str.toDouble)
-          case Type.Year       => ShortValue(str.toShort)
+          case Type.Tiny if field.isSigned()      => ByteValue(str.toByte)


can we add a comment as to why we're doing this?

I assumed that you're talking about isSigned logic, right? If it is, should I write comments for BinaryEncodedRow too?

that would be rad, but I think if you add the helper method you described, that will document it well enough.

That helper method might need implicit parameters, is that OK? Some project might have rules likes "do not use implicits" so I want to ask.

mosesn · 2017-05-16T20:58:22Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Row.scala

+          case Type.Tiny                          => ShortValue(str.toShort)
+          case Type.Short if field.isSigned()     => ShortValue(str.toShort)
+          case Type.Short                         => IntValue(str.toInt)
+          case Type.Int24 if field.isSigned()     => IntValue(str.toInt)


we can merge ones where it doesn't matter if it's signed or not

Ok, I thought it might be good to see all cases in discrete.

I like them explicit too, tbh.

mehmetgunturkun · 2017-05-16T21:10:03Z

Hi @mosesn, get well soon.

Yeah, I do not like checking isSigned in each case too. I though maybe adding this kind of function might help but couldn't be sure:

val value = getValueForField[Int, Long](str, field)
val value = getValueForField[Int, Long](reader, field)

so that isUnsigned check would be only in that function.

mosesn · 2017-05-16T21:58:39Z

@mehmetgunturkun I like that,

mehmetgunturkun · 2017-05-16T22:01:30Z

Cool, let me change this code into that. Awesome!

vkostyukov · 2017-05-16T22:27:07Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/transport/MysqlBuf.scala

+
+  private val unsignedLongMaxValue: BigInt = BigInt("18446744073709551615")
+
+  def readUnsignedLongLE(): BigInt = {


Both of these seem generally useful. Maybe we should move them under ByteReader, where we have O(1) get?

Sure, it is under twitter/util repo, right?

Yup: https://github.com/twitter/util/blob/develop/util-core/src/main/scala/com/twitter/io/ByteReader.scala

roanta

lgtm, thanks for patch!

roanta · 2017-05-19T17:42:18Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Type.scala

+  /**
+   * Retrieves string of the given code.
+   */
+  private[mysql] def getCodeString(code: Short): String = code match {


is this unused?

I have added for debugging actually but left as is, it might be helpful.

roanta · 2017-05-19T17:44:41Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Row.scala

+          case Type.Tiny                          => ShortValue(str.toShort)
+          case Type.Short if field.isSigned()     => ShortValue(str.toShort)
+          case Type.Short                         => IntValue(str.toInt)
+          case Type.Int24 if field.isSigned()     => IntValue(str.toInt)


I like them explicit too, tbh.

mehmetgunturkun · 2017-05-23T10:26:28Z

Hi @mosesn I tried to do that with the helper function I mentioned
val value = getValueForField[Int, Long](str, field)

It gets too complicated due to the implicit classes, so I guess this is a more clear way to do that, but if you want to see that version I can create another branch for you to review.

@vkostyukov I added this part of the code to ByteReader, but how should I merge that to this? One idea is to wait for twitter/util to release a new version then upgrade its version in twitter/finagle and remove the duplicated part.

mosesn · 2017-05-23T13:38:35Z

@mehmetgunturkun no need for a full review, but do you mind posting your work in a gist? I'm a bit curious.

mehmetgunturkun · 2017-05-23T18:17:34Z

Hi @mosesn here is the link for gist:

https://gist.github.com/mehmetgunturkun/e3f7974819a29bc6cd048eb4366707cc

Check StringValueConverter and BinaryValueConverter

mosesn · 2017-05-23T21:40:26Z

@mehmetgunturkun ah, I see what you mean. LGTM then.

mehmetgunturkun · 2017-05-23T21:43:42Z

@mosesn What about the merge with twitter/util? Are we going to wait for twitter/util to publish changes in ByteReader?

ryanoneill · 2017-05-23T22:34:43Z

@mehmetgunturkun FYI, I've put up that change for review internally. It required some additional changes to finagle/finagle-netty4 but should be (hopefully) shipped later today.

mosesn · 2017-05-26T17:28:24Z

@mehmetgunturkun this was merged in util twitter/util@94ab01f, so you should be able to take advantage of it now. thanks for your patience!

mehmetgunturkun · 2017-05-31T20:55:04Z

Hi @mosesn Should I wait for new release of twitter/util (probably 6.44.0) to move on to this issue, or is there a quicker way to use develop branch of twitter/util?

nepthar · 2017-05-31T21:00:07Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Result.scala

@@ -207,6 +223,9 @@ case class Field(
 ) extends Result {
  def id: String = if (name.isEmpty) origName else name
  override val toString = "Field(%s)".format(id)
+
+  def isUnsigned(): Boolean = (flags & FieldAttributes.UnsignedBitMask) > 0


Some style nits for ya that I missed earlier:

We typically leave parens off of these types of methods (both defining and calling) unless they mutate in some way. Since this doesn't, please omit here and in isSigned

…tate.

mosesn · 2017-05-31T21:25:49Z

@mehmetgunturkun you don't have to wait for the new release. the instructions in CONTRIBUTING are for using the tip of util develop branch.

nepthar

Thanks!

mehmetgunturkun · 2017-05-31T22:05:22Z

@ryanoneill Was the change, you mentioned, related to CopyingByteBufByteReader.scala?

ryanoneill · 2017-05-31T22:10:17Z

@mehmetgunturkun yes, via AbstractByteBufByteReader. e62c326

codecov-io · 2017-05-31T22:54:57Z

Codecov Report

Merging #618 into develop will decrease coverage by 0.17%.
The diff coverage is 2.63%.

@@             Coverage Diff             @@
##           develop     #618      +/-   ##
===========================================
- Coverage     68.2%   68.03%   -0.18%     
===========================================
  Files          634      634              
  Lines        21101    21161      +60     
  Branches      1567     1578      +11     
===========================================
+ Hits         14392    14396       +4     
- Misses        6709     6765      +56

Impacted Files	Coverage Δ
...c/main/scala/com/twitter/finagle/mysql/Value.scala	`70.29% <ø> (ø)`	⬆️
.../main/scala/com/twitter/finagle/mysql/Result.scala	`83.96% <0%> (-8.75%)`	⬇️
...rc/main/scala/com/twitter/finagle/mysql/Type.scala	`34.61% <0%> (-18.33%)`	⬇️
...src/main/scala/com/twitter/finagle/mysql/Row.scala	`24.59% <3.57%> (-5.41%)`	⬇️
...ala/com/twitter/finagle/mysql/CanBeParameter.scala	`70.83% <9.09%> (-8%)`	⬇️
...c/main/scala/com/twitter/finagle/http/Method.scala	`83.33% <0%> (-4.17%)`	⬇️
...agle/http2/transport/Http2UpgradingTransport.scala	`88.88% <0%> (-3.71%)`	⬇️
...nagle/http2/transport/MultiplexedTransporter.scala	`82.65% <0%> (+0.57%)`	⬆️
.../main/scala/com/twitter/finagle/mysql/Client.scala	`60.46% <0%> (+0.94%)`	⬆️
...ain/scala/com/twitter/finagle/tracing/Tracer.scala	`71.25% <0%> (+1.25%)`	⬆️
... and 1 more

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 1e23d08...5eb03e5. Read the comment docs.

mehmetgunturkun · 2017-06-01T15:24:17Z

@mosesn I guess I broke something. I just merged develop -> Support_Unsigned_Integer and removed these unnecessary functions, but coverage is decreased. I did sth. wrong?

bryce-anderson · 2017-06-01T23:55:04Z

@mehmetgunturkun, I have some bad news: we have a few problems. First one is simple: we need a CanBeParameter instance for BigInt.

Second one is not so simple, but not too hard. With your change, most int *Value types are now widened if the DB schema is an unsigned integer type. For example what was a LongValue may be now represented as a BigIntValue if the DB schema says the column is an unsigned long long. This causes things like below to fail:

// Will result in a MatchError
// terrible idea, but it happens and only fails at runtime. :(
val LongValue(foo) = row("foo").get

A workaround for this is to make consideration of signedness configurable with a default of off. In my minds eye you just need to add a flag to the Row implementations and in the match statements do something like this:

field.fieldType match {
...
case Type.Long if considerSign && field.isSigned => 
...

What do you think?

mehmetgunturkun · 2017-06-05T20:15:16Z

@bryce-anderson, I got it, I'm adding that flag.

For CanbeParameter what should be the typeCode for BigIntValue, is Type.LongLong ok:
def typeCode(param: BigInt) = Type.LongLong

bryce-anderson · 2017-06-06T15:52:58Z

@mehmetgunturkun I think Type.LongLong is correct.

mehmetgunturkun · 2017-06-29T09:32:01Z

Hi @bryce-anderson, sorry for long delay. I have added considerSign flag to Row and take as a parameter in constructors of BinaryEncodedRow and StringEncodedRow, but I am not sure who is going to set this flags.

BTW, if it is not clear, I can push the current version for you to check.

bryce-anderson · 2017-07-05T20:54:22Z

@mehmetgunturkun, it would be great to see the code. Ultimately this will probably be something that gets set during client construction with a stack Param.

nepthar

This approach works for me. Thanks!

nepthar · 2017-07-10T17:10:20Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Row.scala

@@ -20,6 +20,14 @@ trait Row {
  /** The values for this Row. */
  val values: IndexedSeq[Value]

+  /**/


Looks like an unfinished comment.

Fun side note, this broke github's syntax highlighting

nepthar · 2017-07-10T17:11:02Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Row.scala

@@ -70,16 +78,17 @@ class StringEncodedRow(rawRow: Buf, val fields: IndexedSeq[Field], indexMap: Map
        RawValue(field.fieldType, field.charset, false, bytes)
      else {
        val str = new String(bytes, Charset(charset))
+        println(field, str)


stray print

nepthar · 2017-07-10T17:11:28Z

finagle-mysql/src/test/scala/com/twitter/finagle/mysql/integration/TypeTest.scala

+    val signedTextEncodedQuery = """SELECT `tinyint`, `smallint`, `mediumint`, `int`, `bigint`, `float`, `double`,`decimal`, `bit` FROM `numeric` """
+    runTest(c, signedTextEncodedQuery)(testRow)
+
+    // TODO Comment out after ignoreUnsigned = true


You mean remove TODO part (Line 51) or remove comments for unsigned test cases?

nepthar · 2017-07-10T17:12:58Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/CanBeParameter.scala

+    new CanBeParameter[BigInt] {
+      def sizeOf(param: BigInt) = 8
+      def typeCode(param: BigInt) = Type.LongLong
+      def write(writer: MysqlBufWriter, param: BigInt) = writer.writeBytes(param.toByteArray)


Assert that the BigInt being written can indeed fit in 8 bytes. (Unless this is verified somewhere else that I can't see)

Are you suggesting checking the size of the array, to be sure that it is shorter than or equal to 8?

Yeah, since (AFAICT) BigInt could store values that would be larger than 8 bytes.

what if it is larger than 8, take first 8 bytes or throw an exception?

I think throwing is the way to go. I'd rather have that then write invalid data.
@bryce-anderson what say you?

I agree with @nepthar: I think a throw is fine in this case, although I don't know where that exception will surface off hand. Also, I think you need to make sure you write exactly 8 bytes and right now you will write less in the majority of cases:

scala> BigInt(10).toByteArray res1: Array[Byte] = Array(10) // only one byte!

I can create an array of bytes in size of 8 and fill it in little endian order, is that ok?

Sure, that or just pad with 0's via .writeByte(0x0).

nepthar · 2017-07-10T20:45:53Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Row.scala

@@ -20,7 +20,7 @@ trait Row {
  /** The values for this Row. */
  val values: IndexedSeq[Value]

-  /**/
+  /** The value is to consider unsigned flag of field or not */


haha awesome commit message :)

Sorry, I didn't mean to suggest that a comment was necessary here, only that there was a stray "/**/"

Sorry, I miswrote that, message should have been "a sane comment" :)

nepthar

This looks great, I think we've got all of the basis covered one you switch to a named exception. It'll help stack traces make sense.

nepthar · 2017-07-14T17:50:10Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/CanBeParameter.scala

+        val lengthOfByteArray: Int = byteArray.length
+
+        if (lengthOfByteArray > 8) {
+          throw new Exception(s"The length of BigInt is larger than 8 bytes: $lengthOfByteArray > 8")


Can you create a new named exception for this (can define it somehwere in the file here). I suggest something like:
class BigIntTooLongException(size: Int) extends Exception(s"BigInt is stored as an unsigned long and thus cannot be grater than 8 bytes. Size: $size"

mehmetgunturkun · 2017-07-15T20:52:19Z

@bryce-anderson I am trying to merge develop branch into Support_Unsigned_Integer. However, I cannot pass all tests in develop branch. NumericTypeTest.scala fails and when I change readMediumLE to readIntLE, it passes, do you have any idea, why?

bryce-anderson · 2017-07-17T17:00:20Z

@mehmetgunturkun hard to say for sure without more details, but I don't understand why you would be changing readMediumLE to readIntLE. From the looks of things, there are a few place in this PR where we satisfy an Int24 with readIntLE which seems wrong: won't that consume 4 bytes when we only want to consume 3?

bryce-anderson

I don't know if this is what you had concerns with regarding merging master, so maybe its already addressed.

bryce-anderson · 2017-07-17T20:46:12Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Row.scala

+        case Type.Tiny                        => ShortValue(reader.readUnsignedByte())
+        case Type.Short if isSigned(field)    => ShortValue(reader.readShortLE())
+        case Type.Short                       => IntValue(reader.readUnsignedShortLE())
+        case Type.Int24 if isSigned(field)    => IntValue(reader.readIntLE())


Type.Int24 and TypeInt24 if signed need to call reader.readMediumLE() and reader.readUnsignedMediumLE(), respectively.

# Conflicts: # finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Row.scala

mehmetgunturkun · 2017-07-17T21:58:25Z

@bryce-anderson merged develop to this branch, everything seems to be fine.

bryce-anderson · 2017-07-18T00:22:31Z

finagle-mysql/src/main/scala/com/twitter/finagle/mysql/CanBeParameter.scala

+        }
+
+        for (i <- 0 until lengthOfByteArray) {
+          writer.writeByte(byteArray(i))


I think we need to reverse the order of the bytes we read out of byteArray: the BigInt.toByteArray method returns the bytes in big-endian order.

Yeah, sorry I should have checked that - sending the fix.

nepthar · 2017-07-18T18:23:45Z

finagle-mysql/src/test/scala/com/twitter/finagle/mysql/integration/TypeTest.scala

+    val signedTextEncodedQuery = """SELECT `tinyint`, `smallint`, `mediumint`, `int`, `bigint`, `float`, `double`,`decimal`, `bit` FROM `numeric` """
+    runTest(c, signedTextEncodedQuery)(testRow)
+
+    // TODO Comment out after ignoreUnsigned = true


Is this ready to be uncommented now?

Honestly, not sure how to set ignoreUnsigned flag for StringEncodedRow and BinaryEncodedRow.

class StringEncodedRow(rawRow: Buf, val fields: IndexedSeq[Field], indexMap: Map[String, Int], val ignoreUnsigned: Boolean = true) extends Row

class BinaryEncodedRow(rawRow: Buf, val fields: IndexedSeq[Field], indexMap: Map[String, Int], val ignoreUnsigned: Boolean = true)

As you see I set it to true in the constructor, how to set it to false explicitly, especially in a test?

You're going to need to make an way to configure the Client to operate in 'support unsigned' mode. This will entail making a Stack.Param and threading the boolean all the way through. Which will be a bit of a pain, but it is what it is. I'd remove the default argument for the Row constructors since you're always going to have to pass it up from a higher level anyway.

Stack.Params can be a little convoluted at times (all times, really), so look at the HTTP implementation for an example here. The basic idea is to put typed 'params' (Stack.Param[T]) into a map where the stored items are typed based on the key (the T) and all params have a default.
It can then be configured using the pattern:

client.configured(SupportUnsignedInts(true)) .whatever(..) .newService(..)

bryce-anderson · 2017-07-31T15:05:47Z

@mehmetgunturkun, hows it going on this?

bryce-anderson · 2017-08-14T21:47:11Z

@mehmetgunturkun this has been merged internally and we're just waiting for the github sync process to publish it. Good news is that it should also make it out into pending finagle release.

Summary: This reverts commit ba1438af3971129c7e6c80080efdf669a7fde4e3. This commit is based on a Github PR, #618, and the authorship wasn't merged correctly so this will revert the work, then a follow up will revert-the-revert to fix the authorship. Differential Revision: https://phabricator.twitter.biz/D80814

bryce-anderson · 2017-08-15T21:32:27Z

Closed by 598acc5. Thanks again, @mehmetgunturkun.

mehmetgunturkun · 2017-08-16T09:10:18Z

Hey, @bryce-anderson that's great news.
Sorry for my inconvenience, I couldn't pay enough attention to the PR these days but it is awesome that it is merged now.

Thanks for your support too.

Summary: This reverts commit ba1438af3971129c7e6c80080efdf669a7fde4e3. This commit is based on a Github PR, twitter#618, and the authorship wasn't merged correctly so this will revert the work, then a follow up will revert-the-revert to fix the authorship. Differential Revision: https://phabricator.twitter.biz/D80814

mehmetgunturkun added 2 commits May 11, 2017 22:34

Added unsigned int support to finagle-mysql

a08e174

Added short description for attribute bit masks

ae2f56a

mosesn suggested changes May 11, 2017

View reviewed changes

mehmetgunturkun added 2 commits May 13, 2017 13:03

Added getCodeString to Type for debugging

8fecffb

Added unsigned support for all numerical integer field types

9d69d8e

mosesn suggested changes May 16, 2017

View reviewed changes

vkostyukov suggested changes May 16, 2017

View reviewed changes

roanta approved these changes May 19, 2017

View reviewed changes

mosesn approved these changes May 23, 2017

View reviewed changes

nepthar reviewed May 31, 2017

View reviewed changes

Removed parenthesis from isSigned and isUnsigned since they do not mu…

e938863

…tate.

nepthar approved these changes May 31, 2017

View reviewed changes

mehmetgunturkun added 2 commits June 1, 2017 01:14

Removed readUnsignedLongBE and readUnsignedLongLE from MysqlBufReader

c4d1470

Merge branch 'develop' into Support_Unsigned_Integer

27c385e

bryce-anderson removed the Ship It label Jun 1, 2017

Added ignoreUnsigned flag for Row

aacf93b

nepthar suggested changes Jul 10, 2017

View reviewed changes

Removed println and wrote an insane comment for ignoreUnsigned

1ed3e45

nepthar reviewed Jul 10, 2017

View reviewed changes

Fixed CanBeParameter for BigInt to be sure that we always write 8 bytes.

d6aed81

nepthar reviewed Jul 14, 2017

View reviewed changes

Introduced a named exception for too long BigInts.

e219ad1

bryce-anderson suggested changes Jul 17, 2017

View reviewed changes

Merge branch 'develop' into Support_Unsigned_Integer

f296c6b

# Conflicts: # finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Row.scala

bryce-anderson reviewed Jul 18, 2017

View reviewed changes

Reverse the order of byte array, big endian to little endian

5eb03e5

nepthar reviewed Jul 18, 2017

View reviewed changes

bryce-anderson added the Merged Internally label Aug 14, 2017

bryce-anderson closed this Aug 15, 2017


		private val unsignedLongMaxValue: BigInt = BigInt("18446744073709551615")

		def readUnsignedLongLE(): BigInt = {

Support unsigned integer #618

Support unsigned integer #618

Conversation

mehmetgunturkun commented May 11, 2017

mosesn left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mehmetgunturkun May 11, 2017 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mehmetgunturkun May 11, 2017 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mosesn left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mehmetgunturkun commented May 16, 2017

mosesn commented May 16, 2017

mehmetgunturkun commented May 16, 2017

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

roanta left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mehmetgunturkun commented May 23, 2017 • edited

mosesn commented May 23, 2017

mehmetgunturkun commented May 23, 2017

mosesn commented May 23, 2017

mehmetgunturkun commented May 23, 2017

ryanoneill commented May 23, 2017

mosesn commented May 26, 2017

mehmetgunturkun commented May 31, 2017

Choose a reason for hiding this comment

mosesn commented May 31, 2017

nepthar left a comment

Choose a reason for hiding this comment

mehmetgunturkun commented May 31, 2017

ryanoneill commented May 31, 2017

codecov-io commented May 31, 2017 • edited

Codecov Report

mehmetgunturkun commented Jun 1, 2017

bryce-anderson commented Jun 1, 2017

mehmetgunturkun commented Jun 5, 2017 • edited

bryce-anderson commented Jun 6, 2017

mehmetgunturkun commented Jun 29, 2017

bryce-anderson commented Jul 5, 2017

nepthar left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

bryce-anderson Jul 10, 2017 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mehmetgunturkun May 11, 2017 •

edited

mehmetgunturkun May 11, 2017 •

edited

mehmetgunturkun commented May 23, 2017 •

edited

codecov-io commented May 31, 2017 •

edited

mehmetgunturkun commented Jun 5, 2017 •

edited

bryce-anderson Jul 10, 2017 •

edited

mehmetgunturkun Jul 10, 2017 •

edited

bryce-anderson Jul 17, 2017 •

edited

mehmetgunturkun Jul 18, 2017 •

edited