jade-sql 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06d76c59dbdec2e461a437690981df433898e1366503d665d2b10778fa504d48
-  data.tar.gz: 2c608f51a766507d5f9f13df7acce793177d6241e742edf05968eacff8482525
+  metadata.gz: 203373e2a0789908e800cda5e81acee5883edb436205ec016f281549451218cd
+  data.tar.gz: 3338e7d2e8132fdf4ed4de0e8b53658d8a2cce64ee8f13394cc7dca53413906c
 SHA512:
-  metadata.gz: f87fac54b24c1a530fa20ee750168654ec6c7a20d60dc5f09afb556862a132ae71e3a8c5e1683e041ccd749ca6fd51db3615a04ac6bfc631c03e61fc533fba68
-  data.tar.gz: 8e6fe0954616823a3cf8b44da971562a4cf8fbefa50cad20d66604e77c8c016a6b0c12a5c8e3bbfb5e5c72afe10961db4a4b996bf1b08d22ae4a4b4682068faf
+  metadata.gz: f5e68d85a8d74169946d1368aa91ef46fe99c05a6b3250a5f11b44cc0ee13f75c66b3e1a3bbe59febb9c63ebee3f32ea419396444dffb699fa239a211f943821
+  data.tar.gz: 4ad41bf4b0b780a78b599bba48bd90f7b14a35dfd2564a38b8153bbeec8dd8a7abd77a08d6c43db9888df49096429702aa31d2a6ceebd606446023d729988dd7

data/docs/building.md

@@ -28,22 +28,18 @@ bundle exec rake jade:schema \
 ```
 
 Type map: `bigint`/`integer`/`smallint` → `Int`, `numeric`/`decimal` →
-`Decimal` (from `Sql.Decimal`), `double precision`/`real` → `Float`,
-`varchar`/`text`/`char` → `String`, `boolean` → `Bool`, `jsonb`/`json` →
-`Decode.Value`, `date` → `Calendar.Date`, `timestamp` → `Clock.Instant`,
-`uuid` → `Uuid` (from `Sql.Uuid`). Unknown types fail loudly with the
-table+column name.
-
-`numeric`/`decimal` map to `Sql.Decimal` — an exact base-10 value
-(`mantissa * 10^exponent`), never `Float`, so no precision is lost. Genuine
-floating-point columns (`double precision`/`real`) map to `Float`. `bytea`
-isn't mapped yet, though jade's `Bytes` is the natural target.
-
-`Sql.Decimal` implements `Numeric`, so `+`/`-`/`*` work and stay exact.
-Mirroring `BigDecimal`, `/` can't represent a repeating quotient, so it
-rounds half-up to a default scale (use `div(a, b, scale)` for explicit
-control, `round(d, scale)` to round); division by zero raises. `to_i`
-truncates toward zero and `to_float` converts (lossily, on purpose).
+`Decimal` (jade's stdlib exact decimal), `double precision`/`real` →
+`Float`, `varchar`/`text`/`char` → `String`, `boolean` → `Bool`,
+`jsonb`/`json` → `Decode.Value`, `date` → `Calendar.Date`, `timestamp` →
+`Clock.Instant`, `uuid` → `Uuid` (from `Sql.Uuid`). Unknown types fail
+loudly with the table+column name.
+
+`numeric`/`decimal` map to the stdlib `Decimal` — an exact base-10 value
+(`coefficient * 10^exponent`), never `Float`, so no precision is lost.
+Genuine floating-point columns (`double precision`/`real`) map to `Float`.
+`bytea` isn't mapped yet, though jade's `Bytes` is the natural target. See
+jade-lang's `Decimal` for the full API (`of`/`scaled`/`parse`, arithmetic,
+`round`, `to_i`/`to_float`).
 
 For each table, the generator emits:
 

data/lib/jade-sql/bin/generate_schema.rb

@@ -53,7 +53,7 @@ module JadeSql
       "Clock.Instant" => "import Clock",
       "Decode.Value"  => "import Decode",
       "Uuid"          => "import Sql.Uuid exposing(Uuid)",
-      "Decimal"       => "import Sql.Decimal exposing(Decimal)",
+      "Decimal"       => "import Decimal exposing(Decimal)",
     }.freeze
 
     # Column names that collide with Jade keywords get a trailing underscore

data/lib/jade-sql/runtime.rb

@@ -82,8 +82,8 @@ module JadeSql
     # other List(a) column.
     #
     # numeric/decimal columns come back as ::BigDecimal; the schema generator
-    # maps them to Sql.Decimal, whose decoder reads the exact
-    # "<mantissa>e<exponent>" wire form. Float would lose precision, so don't.
+    # maps them to jade's stdlib Decimal, whose decoder reads the exact
+    # "<coefficient>e<exponent>" wire form. Float would lose precision, so don't.
     def self.coerce_row(row)
       row.transform_values { |v| coerce_value(v) }
     end
@@ -99,19 +99,19 @@ module JadeSql
       end
     end
 
-    # ::BigDecimal -> "<mantissa>e<exponent>" with value = mantissa * 10^exp,
+    # ::BigDecimal -> "<coefficient>e<exponent>" with value = coeff * 10^exp,
     # exactly (BigDecimal#split gives sign, significant digits, and a base-10
-    # exponent). Matches the wire form Sql.Decimal's decoder parses.
+    # exponent). Matches the wire form jade's stdlib Decimal decoder parses.
     #
-    # 'NaN'/'Infinity'::numeric are legal Postgres values that Sql.Decimal
-    # can't represent; fail loudly rather than silently decode them as 0.
+    # 'NaN'/'Infinity'::numeric are legal Postgres values that Decimal can't
+    # represent; fail loudly rather than silently decode them as 0.
     def self.decimal_wire(v)
       raise ArgumentError, "non-finite numeric: #{v}" unless v.finite?
 
       sign, digits, _base, exp = v.split
-      mantissa = sign * digits.to_i
+      coefficient = sign * digits.to_i
       exponent = exp - digits.length
-      "#{mantissa}e#{exponent}"
+      "#{coefficient}e#{exponent}"
     end
 
     # PG arrays render as `{}`, `{a,b,c}`, `{"a,b","c"}`, with NULL as

data/lib/jade-sql/version.rb

@@ -1,3 +1,3 @@
 module JadeSql
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jade-sql
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - agustin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.2.0
 description: Query and mutation builders, schema generation from db/structure.sql,
   and an ActiveRecord-backed runtime for the Jade language. Renders typed queries
   to (String, List(Value)) and decodes rows into Jade structs.
@@ -42,7 +42,6 @@ files:
 - lib/jade-sql/bin/generate_schema.rb
 - lib/jade-sql/runtime.rb
 - lib/jade-sql/sql.jd
-- lib/jade-sql/sql/decimal.jd
 - lib/jade-sql/sql/loader.jd
 - lib/jade-sql/sql/mutation.jd
 - lib/jade-sql/sql/query.jd

data/lib/jade-sql/sql/decimal.jd

@@ -1,193 +0,0 @@
-module Sql.Decimal exposing (
-  Decimal,
-  decimal,
-  div,
-  exponent,
-  mantissa,
-  parse,
-  round,
-  to_float,
-  to_i,
-)
-
-import Decode exposing (Decodable, Decoder)
-import Encode exposing (Encodable)
-
-
-# An exact base-10 decimal: value = mantissa * 10 ^ exponent. Lossless for
-# Postgres numeric/decimal — no Float rounding. The wire form is
-# "<mantissa>e<exponent>" (e.g. "175e-3"), which Postgres casts to numeric
-# exactly and which decodes back without parsing a decimal point.
-type Decimal = Decimal(Int, Int)
-
-
-def decimal(m: Int, e: Int) -> Decimal
-  Decimal(m, e)
-end
-
-
-def mantissa(d: Decimal) -> Int
-  Decimal(m, _) = d
-
-  m
-end
-
-
-def exponent(d: Decimal) -> Int
-  Decimal(_, e) = d
-
-  e
-end
-
-
-def pow10(n: Int) -> Int
-  n <= 0 ? 1 : 10 * pow10(n - 1)
-end
-
-
-def abs(x: Int) -> Int
-  x < 0 ? 0 - x : x
-end
-
-
-# Integer division, rounding ties half away from zero — i.e. Java's HALF_UP
-# and Ruby BigDecimal's default mode (2.5 -> 3, -2.5 -> -3). Rounds the
-# magnitude, then re-applies the sign. A zero `den` raises through Int `/`.
-def round_div(num: Int, den: Int) -> Int
-  negative = not ((num < 0) == (den < 0))
-  n = abs(num)
-  d = abs(den)
-  q = n / d
-  r = n - q * d
-  rounded = (2 * r) >= d ? q + 1 : q
-
-  negative ? 0 - rounded : rounded
-end
-
-
-def trunc_div(num: Int, den: Int) -> Int
-  q = abs(num) / abs(den)
-
-  num < 0 ? 0 - q : q
-end
-
-
-# `+` `-` `*` are exact. `+`/`-` line the operands up on the smaller exponent
-# first; `*` adds exponents.
-def add(a: Decimal, b: Decimal) -> Decimal
-  Decimal(ma, ea) = a
-  Decimal(mb, eb) = b
-  e = ea < eb ? ea : eb
-
-  Decimal((ma * pow10(ea - e)) + (mb * pow10(eb - e)), e)
-end
-
-
-def sub(a: Decimal, b: Decimal) -> Decimal
-  Decimal(ma, ea) = a
-  Decimal(mb, eb) = b
-  e = ea < eb ? ea : eb
-
-  Decimal((ma * pow10(ea - e)) - (mb * pow10(eb - e)), e)
-end
-
-
-def mul(a: Decimal, b: Decimal) -> Decimal
-  Decimal(ma, ea) = a
-  Decimal(mb, eb) = b
-
-  Decimal(ma * mb, ea + eb)
-end
-
-
-# a / b rounded half-up to `scale` decimal places — like Java's
-# BigDecimal.divide(divisor, scale, HALF_UP). Division by zero raises.
-def div(a: Decimal, b: Decimal, scale: Int) -> Decimal
-  Decimal(ma, ea) = a
-  Decimal(mb, eb) = b
-  k = (ea - eb) + scale
-  num = k >= 0 ? ma * pow10(k) : ma
-  den = k >= 0 ? mb : mb * pow10(0 - k)
-
-  Decimal(round_div(num, den), 0 - scale)
-end
-
-
-# The Numeric `/`: like Ruby's BigDecimal `/`, it can't be exact for a
-# repeating quotient (1/3), so it rounds half-up to a generous default scale.
-def divide(a: Decimal, b: Decimal) -> Decimal
-  div(a, b, 32)
-end
-
-
-implements Numeric(Decimal) with
-  (+): add,
-  (-): sub,
-  (*): mul,
-  (/): divide
-end
-
-
-# Round to `scale` decimal places, half-up. Fewer places than the value
-# already has are left untouched.
-def round(d: Decimal, scale: Int) -> Decimal
-  Decimal(m, e) = d
-  shift = e + scale
-
-  shift >= 0 ? d : Decimal(round_div(m, pow10(0 - shift)), 0 - scale)
-end
-
-
-# Truncates toward zero (drops the fractional part).
-def to_i(d: Decimal) -> Int
-  Decimal(m, e) = d
-
-  e >= 0 ? m * pow10(e) : trunc_div(m, pow10(0 - e))
-end
-
-
-def to_float(d: Decimal) -> Float
-  Decimal(m, e) = d
-
-  e >= 0
-    ? Basics.to_float(m * pow10(e))
-    : Basics.to_float(m) / Basics.to_float(pow10(0 - e))
-end
-
-
-def to_wire(d: Decimal) -> String
-  Decimal(m, e) = d
-
-  String.from_int(m) ++ "e" ++ String.from_int(e)
-end
-
-
-def parse(s: String) -> Maybe(Decimal)
-  case String.split(s, "e")
-  in [m, e]
-    String.to_int(m)
-      |> Maybe.and_then((mi) -> {
-        String.to_int(e) |> Maybe.map((ei) -> { Decimal(mi, ei) })
-      })
-
-  else Nothing
-  end
-end
-
-
-def decimal_decoder(s: String) -> Decoder(Decimal)
-  case parse(s)
-  in Just(d) then Decode.succeed(d)
-  in Nothing then Decode.fail("invalid decimal: " ++ s)
-  end
-end
-
-
-implements Decodable(Decimal) with
-  decoder: -> { Decode.string |> Decode.and_then(decimal_decoder) }
-end
-
-
-implements Encodable(Decimal) with
-  encoder: (d) -> { Encode.string(to_wire(d)) }
-end