text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>
when(ds.getConnection) thenReturn conn
when(conn.prepareStatement(any[String], any[Int], any[Int])) thenReturn stmt
when(stmt.executeQuery()) thenReturn rs
when(conn.getAutoCommit) thenReturn true
// The second call to `setAutoCommit` will fail. This second call is the one that sets b... | fim | zio/zio-quill | scala |
<|fim_suffix|>l(`Ex 7 predicate`))).runSyncUnsafe() mustEqual `Ex 7 expected result`
}
"Example 8 - contains empty" in {
testContext.run(`Ex 8 and 9 contains`(liftQuery(`Ex 8 param`))).runSyncUnsafe() mustEqual `Ex 8 expected result`
}
"Example 9 - contains non empty" in {
testContext.run(`Ex 8 and 9 ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.mysql
import io.getquill.ZioSpec
import io.getquill.context.sql.base.PeopleReturningSpec
class PeopleZioReturningSpec extends PeopleReturningSpec with ZioSpec {
val context: testContext.type = testContext
import testContext._
override def beforeEach(): Unit = {
testContex... | fim | zio/zio-quill | scala |
<|fim_suffix|>redIds(productEntries)).foreach(p => query[Product].insertValue(p))
)
batchInsert(prepareBatchInsert).distinct mustEqual List(false)
extractProducts(prepareQuery) === withOrderedIds(productEntries)
}
}
<|fim_prefix|>package io.getquill.mysql
import java.sql.{Connection, ResultSet}
import i... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.mysql
import io.getquill.ZioSpec
import io.getquill.context.sql.ProductSpec
class Prod<|fim_suffix|>ld (i, ps.head)).runSyncUnsafe()
product.description mustEqual "Window"
product.id mustEqual inserted
}
"Single insert with inlined free variable" in {
val ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.mysql
import io.getquill.ZioSpec
import zio.{ZIO, ZLayer}
class ZioJdbcContextSpec extends ZioSpec {
val context = testContext
import testContext._
"provides transaction support" - {
"success" in {
(for {
_ <- testContext.run(qr1.delete)
_ <- testCon... | fim | zio/zio-quill | scala |
<|fim_suffix|>(Literal, pool) with TestEntities
}
<|fim_prefix|>package io.getquill
import io.getquill.ZioSpec.runLayerUnsafe
import io.getquill.jdbczio.Quill
packag<|fim_middle|>e object mysql {
implicit val pool = runLayerUnsafe(Quill.DataSource.fromPrefix("testMysqlDB"))
object testContext extends Quill.Mysql<... | fim | zio/zio-quill | scala |
package io.getquill.oracle
import io.getquill.PeopleZioSpec
import org.scalatest.matchers.should.Matchers._
class PeopleZioJdbcSpec extends PeopleZioSpec {
val context = testContext
import testContext._
override def beforeAll = {
super.beforeAll()
testContext.transaction {
for {
_ <- tes... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.oracle
import io.getquill.ZioSpec
import io.getquill.context.sql.base.Peo<|fim_suffix|>run(get)
} yield (output mustEqual result(id.head))).runSyncUnsafe()
}
// ignored because not supported
"Ex 2 update.returningMany(_.singleColumn) mod" ignore {
import `Ex 2 update.re... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.oracle
import java.sql.{Connection, ResultSet}
import io.getquill.PrepareZioJdbcSpecBase
import io.getquill.context.qzio.ImplicitSyntax.Implicit
import org.scalatest.BeforeAndAfter
class PrepareJdbcSpec extends PrepareZioJdbcSpecBase with BeforeAndAfter {
val context = testContext... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.oracle
<|fim_suffix|>ById(lift(i)))
} yield (i, ps.head)).runSyncUnsafe()
product.description mustEqual "Window"
product.id mustEqual inserted
}
"Single insert with inlined free variable" in {
val prd = Product(0L, "test1", 1L)
val (inserted, re... | fim | zio/zio-quill | scala |
<|fim_suffix|>{
(for {
_ <- testContext.run(qr1.delete)
_ <- testContext.transaction {
testContext.transaction {
testContext.run(qr1.insert(_.i -> 33))
}
}
r <- testContext.run(qr1)
} yield r).runSyncUnsafe().map(_.i) mustEq... | fim | zio/zio-quill | scala |
<|fim_suffix|>taSource.fromPrefix("testOracleDB"))
object testContext extends Quill.Oracle(Literal, pool) with TestEntities
}
<|fim_prefix|>package io.getq<|fim_middle|>uill
import io.getquill.ZioSpec.runLayerUnsafe
import io.getquill.jdbczio.Quill
package object oracle {
implicit val pool = runLayerUnsafe(Quill.... | fim | zio/zio-quill | scala |
<|fim_suffix|>ct].map(_.id).max.exists(_ == p.id))
}
} yield (result)
}
.map(_.headOption.map(_.id))
.onDataSource
.provide(pool.env)
)
.getOrThrow()
}
Thread.sleep(2000)
result mustEqual Op... | fim | zio/zio-quill | scala |
<|fim_suffix|>unSyncUnsafe()
}
case class DataService(quill: Quill[PostgresDialect, Literal]) {
import quill.{run => qrun, _}
val people = quote(query[Person])
def somePeopleByName = quote((p... | fim | zio/zio-quill | scala |
<|fim_suffix|> expected result`
}
"Example 6 - predicate 0" in {
testContext.run(satisfies(eval(`Ex 6 predicate`))).runSyncUnsafe() mustEqual `Ex 6 expected result`
}
"Example 7 - predicate 1" in {
testContext.run(satisfies(eval(`Ex 7 predicate`))).runSyncUnsafe() mustEqual `Ex 7 expected result`
}
... | fim | zio/zio-quill | scala |
<|fim_suffix|>qual expect.toSet
output <- testContext.run(get)
} yield (output.toSet mustEqual result.toSet)).runSyncUnsafe()
}
}
<|fim_prefix|>package io.getquill.postgres
import io.getquill.ZioSpec
import io.getquill.context.sql.base.PeopleReturningSpec
class PeopleZioReturningSpec extends PeopleRetur... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.postgres
import io.getquill.ZioSpec
import io.getquill.context.sql.ProductSpec
class ProductJdbcSpec extends ProductSpec with ZioSpec {
val context = testContext
import testContext._
override def beforeAll = {
super.beforeAll()
testContext.run(quote(query[Product].del... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.postgres
import io.getquill.ZioSpec
import zio.{ZIO, ZLayer}
class QuillServiceSpec ex<|fim_suffix|> throw new IllegalStateException
}
)
)
}
}.catchSome { case e: Exception =>
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.postgres
import io.getquill.ZioSpec
import zio.{ZIO, ZLayer}
class ZioJdbcContextSpec extends ZioSpec {
val context = testContext
import testContext._
"provides transaction support" - {
"success" in {
(for {
_ <- testContext.run(qr1.delete)
_ <- test... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.ZioSpec.runLayerUnsafe
import io.getquill.jdbczio.Quill
package object postgres {
val pool = runLayerUnsafe(Quill.DataSource.fromPrefix("t<|fim_suffix|>s Quill.Postgres(Literal, pool) with TestEntities
}
<|fim_middle|>estPostgresDB"))
object testContext extend<... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.sqlite
import io.getquill.PeopleZioSpec
import org.scalatest.matchers.should.Matchers._
class PeopleZioJdbcSpec exte<|fim_suffix|>in {
testContext.run(`Ex 8 and 9 contains`(liftQuery(`Ex 8 param`))).runSyncUnsafe() mustEqual `Ex 8 expected result`
}
"Example 9 - contains no... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.sqlite
impor<|fim_suffix|>d)" ignore {
import `Ex 3 delete.returningMany(wholeRecord)`._
(for {
opResult <- testContext.run(op)
_ = opResult.toSet mustEqual expect.toSet
output <- testContext.run(get)
} yield (output.toSet mustEqual result.toSet... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.sqlite
import java.sql.{Connection, ResultSet}
import io.getquill.PrepareZioJdbcSpecBase
import io.getquill.context.qzio.ImplicitSyntax.Implicit
import org.scalatest.BeforeAndAfter
class PrepareJdbcSpec extends PrepareZioJdbcSpecBase with BeforeAndAfter {
val context = testContext... | fim | zio/zio-quill | scala |
<|fim_suffix|>Insert)
ps <- testContext.run(productById(lift(i)))
} yield (i, ps.head)).runSyncUnsafe()
product.description mustEqual "Window"
product.id mustEqual inserted
}
"Single insert with inlined free variable" in {
val prd = Product(0L, "test1", 1L)
val (insert... | fim | zio/zio-quill | scala |
<|fim_suffix|>>
ZIO.attempt(e.getClass.getSimpleName)
}
r <- testContext.run(qr1)
} yield (e, r.isEmpty)).runSyncUnsafe() mustEqual (("IllegalStateException", true))
}
"nested" in {
(for {
_ <- testContext.run(qr1.delete)
_ <- testContext.transacti... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io<|fim_suffix|>quill.ZioSpec.runLayerUnsafe
import io.getquill.jdbczio.Quill
package object sqlite {
val pool = runLayerUnsafe(Quill.DataSource.fromPrefix("testSqliteDB"))
object testContext extends Quill.Sqlite(Literal, pool) with TestEntities
}
<|fim_middle|>.get<|endof... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.sqlserver
import io.getquill.PeopleZioSpec
import org.scalatest.matchers.should.Matchers._
class PeopleZioJdbcSpec extends PeopleZioSpec {
val context = testContext
import testContext._
override def beforeAll = {
super.beforeAll()
testContext.transaction {
for ... | fim | zio/zio-quill | scala |
<|fim_suffix|>xt.run(op)
output <- testContext.run(get)
} yield (output.toSet mustEqual result(id).toSet)).runSyncUnsafe()
}
"Ex 0.5 insert.returning(wholeRecord) mod" in {
import `Ex 0.5 insert.returning(wholeRecord) mod`._
(for {
product <- testContext.run(op)
output <- testContext... | fim | zio/zio-quill | scala |
package io.getquill.sqlserver
import java.sql.{Connection, ResultSet}
import io.getquill.PrepareZioJdbcSpecBase
import io.getquill.context.qzio.ImplicitSyntax.Implicit
import org.scalatest.BeforeAndAfter
class PrepareJdbcSpec extends PrepareZioJdbcSpecBase with BeforeAndAfter {
val context = testContext.underlying... | fim | zio/zio-quill | scala |
<|fim_suffix|>un(productById(lift(i(2))))
} yield (i, ps.head)).runSyncUnsafe()
product.description mustEqual productEntries(2).description
product.id mustEqual inserted(2)
}
"Single insert product" in {
val (inserted, product) =
(for {
i <- testContext.run(product... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.sqlserver
import io.getquill.ZioSpec
import zio.{ZIO, ZLayer}
class ZioJdbcContextSpec extends ZioSpec {
val context = testContext
import testContext._
"provides transaction support" - {
"success" in {
(for {
_ <- testContext.run(qr1.delete)
_ <- tes... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.ZioSpec.runLayerUnsafe
import io.getquill.jdbczio.Q<|fim_suffix|>ce.fromPrefix("testSqlServerDB"))
object testContext extends Quill.SqlServer(Literal, pool) with TestEntities
}
<|fim_middle|>uill
package object sqlserver {
val pool = runLayerUnsafe(Quill.DataSo... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.examples
import io.getquill.{JsonbValue, Literal}
import io.getquill.jdbczio.Quill
import zio.Console.printLine
import zio.json.{DeriveJsonDecoder, DeriveJsonEncoder, JsonDecoder, JsonEncoder}
import zio.{ZIO, ZIOAppDefault, ZLayer}
object IdiomaticAppWithEncoders extends ZIOAppDefau... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.postgres
import io.getquill.{JsonValue, JsonbValue, ZioSpec}
import zio.Chunk
import zio.json.ast.Json
import zio.json.{DeriveJsonDecoder, DeriveJsonEncoder, JsonDecoder, JsonEncoder}
class PostgresJsonSpec extends ZioSpec {
val context = testContext
import testContext._
case ... | fim | zio/zio-quill | scala |
<|fim_suffix|>ef run =
(for {
_ <- App.set()
ent <- App.get()
_ <- printLine(ent)
} yield ()).provide(dsLive, pgLive, appLive)
}
<|fim_prefix|>package io.getquill.examples
import io.getquill.{JsonbValue, Literal}
import io.getquill.jdbczio.Quill
import zio.Console.printLine
import zio.jso... | fim | zio/zio-quill | scala |
<|fim_suffix|>al jsonbAstValue = JsonbAstEntity("JoeEntity", JsonbValue(jsonJoe))
"some json" in {
val value = JsonAstOptEntity("JoeEntity", Some(JsonValue(jsonJoe)))
testContext.run(jsonAstOptQuery.insertValue(lift(value))).runSyncUnsafe()
val inserted = testContext.run(jsonAstOptQuery).runSyncU... | fim | zio/zio-quill | scala |
<|fim_suffix|> config.getString("username")
def password: String = config.getString("password")
}
<|fim_prefix|>package io.getquill
import com.typesafe.config.Config
case class OrientDBContextConfig(config: Config) {
def dbUrl: String = config.getString("dbUrl")
def username: St<|fim_middle|>ring =<|endoftex... | fim | zio/zio-quill | scala |
package io.getquill
import io.getquill.context.orientdb.{OrientDBContext, OrientDBIdiom}
class OrientDBMirrorContext[+Naming <: NamingStrategy](naming: Naming)
extends MirrorContext[OrientDBIdiom, Naming](OrientDBIdiom, naming)
with OrientDBContext[Naming] {
implicit def listDecoder[T]: Decoder[List[T]] ... | fim | zio/zio-quill | scala |
<|fim_suffix|>/34391006/orientdb-passing-an-array-to-a-query-using-in-on-an-otype-linklist-field
val orientInFilterString = s"IN (?)"
val inFilterString = s"IN (${List.fill(noOfLifts)("?").mkString(", ")})"
if (orientQl.contains(inFilterString)) {
orientQl.replace(inFilterString, orientInFilterS... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.orientdb
import java.util.Date
import io.getquill.NamingStrategy
import io.getquill.context.Context
import io.getquill.context.orientdb.dsl.OrientDBDsl
trait OrientDBContext[+Naming <: NamingStrategy] extends Context[OrientDBIdiom, Naming] with OrientDBDsl {
implicit def ... | fim | zio/zio-quill | scala |
<|fim_suffix|> Constant((), _) => stmt"1"
case Constant(v, _) => stmt"${v.toString.token}"
case NullValue => stmt"null"
case Tuple(values) => stmt"${values.token}"
case CaseClass(_, values) => stmt"${values.map(_._2).token}"
}
implicit def infixToken... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.orientdb
import com.orientechnologies.orient.core.db.OPartitionedDatabasePool
import com.orientechnologies.orient.core.record.impl.ODocument
import io.getquill.NamingStrategy
import io.getquill.context.orientdb.encoding.{Decoders, Encoders}
import io.getquill.util.Messages.fai... | fim | zio/zio-quill | scala |
<|fim_suffix|>ntdb.OrientDBContext
trait OrientDBDsl {
this: OrientDBContext[_] =>
implicit final class Like(s1: String) {
def like(s2: String) = quote(sql"$s1 like $s2".as[Boolean])
}
}
<|fim_prefix|>package io.getquill.context.orientdb.d<|fim_middle|>sl
import io.getquill.context.orie<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.orientdb.encoding
import io.getquill.context.orientdb.OrientDBSessionContext
import scala.jdk.CollectionConverters._
import com.orientechnologies.orient.core.db.record.OTrackedSet
trait CollectionDecoders {
this: Ori<|fim_suffix|>(index)).asScala.toList)
implicit def setD... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.orientdb.encoding
import io.getquill.context.orientdb.OrientDBSessionContext
import scala.jdk.CollectionConverters._
trait CollectionEncoders {
this: OrientDBSessionContext[_] =>
implicit def listEncoder[T]: Encoder[List[T]] = encoder { (index, value, row) =>
row.ins... | fim | zio/zio-quill | scala |
<|fim_suffix|>Short](row.fieldNames()(index)))
implicit val byteDecoder: Decoder[Byte] = decoder((index, row, session) => row.field[Byte](row.fieldNames()(index)))
implicit val longDecoder: Decoder[Long] = decoder { (index, row, session) =>
if (row.fieldValues()(index).isInstanceOf[Int]) {
row.field[Int](... | fim | zio/zio-quill | scala |
<|fim_suffix|>d, encoder.encoder))
implicit val stringEncoder: Encoder[String] = encoder { (index, value, row) => row.insert(index, value); row }
implicit val bigDecimalEncoder: Encoder[BigDecimal] = encoder { (index, value, row) =>
row.insert(index, value.bigDecimal); row
}
implicit val booleanEncoder: En... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.orientdb
import io.getquill.base.Spec
import i<|fim_suffix|>indVariablesSpec extends Spec {
"binds lifted values" in {
val mirrorContext = orientdb.mirrorContext
import mirrorContext._
def q(i: Int) =
quote {
query[TestEntity].filter(e => e.i == li... | fim | zio/zio-quill | scala |
package io.getquill.context.orientdb
import io.getquill.base.Spec
class CaseClassQueryOrientSpec extends Spec {
val testSyncDB = orientdb.testSyncDB
import testSyncDB._
case class Contact(id: Int, firstName: String, lastName: String, age: Int, addressFk: Int, extraInfo: String)
case class Address(id: Int, s... | fim | zio/zio-quill | scala |
<|fim_suffix|> }
}
case class DecodeNullTestEntity(id: Int, value: Int)
case class DecodeNullTestWriteEntity(id: Int, value: Option[Int])
val insertValue = DecodeNullTestWriteEntity(0, None)
}
<|fim_prefix|>package io.getquill.context.orientdb
import io.getquill.base.Spec
class DecodeNullSpec extends Sp... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.orientdb
import java.util.Date
import io.getquill.Query
import io.getquill.base.Spec
class EncodingSpec extends Spec {
"encodes and decodes types" - {
"sync" in {
val ctx = orientdb.testSyncDB
import ctx._
ctx.run(query[EncodingTestEntity].delete)
... | fim | zio/zio-quill | scala |
<|fim_suffix|>filter(_.id == 1)).head mustBe e
}
"Blob (Array[Byte]) support" ignore {
val ctx = orientdb.testSyncDB
import ctx._
case class BlobsEntity(id: Int, blobs: List[Array[Byte]])
val e = BlobsEntity(1, List(Array(1.toByte, 2.toByte), Array(2.toByte)))
val q = quote(querySchema[BlobsEnt... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.orientdb
import io.getquill.base.Spec
import java.util.Date
class MapsEncodingSpec extends Spec {
case class MapsEntity(
id: Int,
longDouble: Map[Long, Double],
intDouble: Map[Int, Double],
boolDate: Map[B<|fim_suffix|> .run(
q.filter(p =>
... | fim | zio/zio-quill | scala |
package io.getquill.context.orientdb
import io.getquill.base.Spec
import io.getquill.context.mirror.Row
import io.getquill.{Query, Quoted}
class OrientDBContextMacroSpec extends Spec {
"runs queries" - {
"static" in {
val mirrorContext = orientdb.mirrorContext
import mirrorContext._
val q = q... | fim | zio/zio-quill | scala |
<|fim_suffix|>SyncDB
import ctx._
case class TestEntity(id: Int, s: String, i: Int, l: Long, o: Int)
val update = quote {
query[TestEntity].filter(_.id == lift(1)).update(_.i -> lift(1))
}
ctx.run(update) mustEqual (())
}
"performIO" in {
val ctx = orientdb.testSyncDB
import ctx._... | fim | zio/zio-quill | scala |
<|fim_suffix|> "SELECT s, i, l, o, b FROM TestEntity WHERE s = 'a'"
}
"unit" in {
case class Test(u: Unit)
val q = quote {
query[Test].filter(t => t.u == (())).size
}
ctx.run(q).string mustEqual
"SELECT COUNT(*) FROM Test WHERE u = 1"
}
"int" in {
val q = qu... | fim | zio/zio-quill | scala |
package io.getquill.context.orientdb
import io.getquill.ast.{Action => AstAction, Query => AstQuery, _}
import io.getquill.context.sql._
import io.getquill.idiom.StatementInterpolator._
import io.getquill.idiom.StringToken
import io.getquill.{IdiomContext, Literal, Ord}
import io.getquill.base.Spec
import io.getquill.... | fim | zio/zio-quill | scala |
<|fim_suffix|> { (ids: Query[Int]) =>
query[Person].filter(p => ids.contains(p.id))
}
ctx.run(q(liftQuery(Set.empty[Int]))) mustEqual List.empty[Person]
}
}
}
<|fim_prefix|>package io.getquill.context.orientdb
import io.getquill.Query
import io.getquill.base.Spec
class PeopleOrientDBSpec ext... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.orientdb
import io.getquill.Ord
import io.getquill.base.Spec
class QueryResultTypeOrientDBSync extends Spec {
case class OrderTestEntity(id: Int, i: Int)
val entries = List(
OrderTestEntity(1, 1),
OrderTestEntity(2, 2),
OrderTestEntity(3, 3)
)
override ... | fim | zio/zio-quill | scala |
<|fim_suffix|>oByte)))
val q = quote(querySchema[BlobsEntity]("BlobsEntity"))
ctx.run(q.delete)
ctx.run(q.insertValue(lift(e)))
ctx.run(q.filter(_.id == 1)).head.blobs.map(_.toList) mustBe e.blobs.map(_.toList)
}
"Set in where clause" in {
val ctx = orientdb.testSyncDB
import ctx._
cas... | fim | zio/zio-quill | scala |
<|fim_suffix|>")
getOrCreateClass(schema, "MapsEntity")
getOrCreateClass(schema, "MapFrozen")
getOrCreateClass(schema, "TestEntity")
getOrCreateClass(schema, "TestEntity2")
getOrCreateClass(schema, "TestEntity3")
getOrCreateClass(schema, "Person")
getOrCreateClass(schema, "OrderTestEntity")
... | fim | zio/zio-quill | scala |
<|fim_suffix|>spark: SQLContext) = {
val ds = spark.sql(prepareString(string, prepare))
percolateNullArrays(ds.toDF(CaseAccessors[T](ds.schema): _*).as[T])
}
def executeQuerySingle[T: TypeTag](
string: String,
prepare: Prepare = identityPrepare,
extractor: Extractor[T] = identityExtractor
)(i... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark
import org.apache.spark<|fim_suffix|>rait Binding
case class DatasetBinding[T](ds: Dataset[T]) extends Binding
case class ValueBinding(str: String) extends Binding
<|fim_middle|>.sql.Dataset
sealed t<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.util.Messages
import<|fim_suffix|>[O]
}
<|fim_middle|> io.getquill.QuillSparkContext
trait Decoders {
this: QuillSparkContext =>
type Decoder[T] = BaseDecoder[T]
type ResultRow = Unit
implicit def dummyDecoder[T]: (Index, ResultRow, ResultR... | fim | zio/zio-quill | scala |
<|fim_suffix|>eEncoder: Encoder[Double] = toStringEncoder
}
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.QuillSparkContext
trait Encoders {
this: QuillSparkContext =>
type Encoder[T] = BaseEncoder[T]
type PrepareRow = List[Binding]
def encoder[T](f: T => String): Encoder[T] =
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.ast._
import io.getquill.context.sql._
impor<|fim_suffix|>p.quat.isPrimitive) => true
case i: Infix if (!i.quat.isInstanceOf[Quat.Product]) => true
case l: Lift => true
// idents should not b... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.{IdiomContext, NamingStrategy}
import io.getquill.ast.{Ast, BinaryOperation, CaseClass, Constant, ExternalIdent, Ident, Operation, Property, Query, StringOperator, Tuple, Value}
import io.getquill.context.spark.norm.EscapeQuestionMarks
import io.getqui... | fim | zio/zio-quill | scala |
<|fim_suffix|>per.apply(other)
}
}
<|fim_prefix|>package io.getquill.context.spark.norm
import io.getquill.ast._
import QuestionMarkEscaper._
object EscapeQuestionMarks extends StatelessTransformer {
override def apply(ast: Ast): Ast =
ast match {
case Constant(value, _) =>
Constant.auto(if (... | fim | zio/zio-quill | scala |
<|fim_suffix|>\\?", "?")
def pluginValueSafe(str: String, value: String) =
str.replaceFirst("(?<!\\\\)\\?", Matcher.quoteReplacement(escape(value)))
}
<|fim_prefix|>package io.getquill.context.spark.norm
import java.util.regex.Matcher
object QuestionMarkEscaper {
def escape(<|fim_middle|>str: String) = str... | fim | zio/zio-quill | scala |
<|fim_suffix|>ntext.run(q).collect.toList mustEqual
List((1, 1))
}
}
}
}
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.base.Spec
case class Test(i: Int, j: Int, s: String)
class AliasNestedQueryColumnsSpec extends Spec {
import testContext._
import sqlContext.implicits... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.base.Spec
import org.apache.spark.sql.Dataset
import org.scalatest.matchers.should.Matchers._
case class Contact(firstName: String, lastName: String, age: Int, addressFk: Int, extraInfo: String)
case class Address(id: Int, street: String, zip: Int, ot... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.Query
import io.getquill.base.Spec
case class Department(dpt: String)
case class Employee(emp: String, dpt: String)
case class Task(emp: String, tsk: String)
class DepartmentsSparkSpec extends Spec {
import testContext._
import sqlContext.implic... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.base.Spec
case class EncodingTestEntity(
v1: String,
v2: BigDecimal,
v3: Boolean,
v4: Byte,
v5: Short,
v6: Int,
v7: Long,
v8: Double,
v9: Array[Byte],
o1: Option[String],
o2: Option[BigDecimal],
o3: Option[Boolean],
o4: Optio... | fim | zio/zio-quill | scala |
<|fim_suffix|>split(" "))
.join(testsR.concatMap(t => t.s.split(" ")))
.on { case (a, b) => a == b }
)
testContext.run(q).collect.toList mustEqual
List(("r", "r"))
}
}
"map to CC after GroupBy" in {
val originals = liftQuery {
Seq(
Original(1, "Joe", 0, ... | fim | zio/zio-quill | scala |
package io.getquill.context.spark
import io.getquill.base.Spec
import io.getquill.{Query, Quoted}
case class Person(name: String, age: Int)
case class Couple(her: String, him: String)
class PeopleJdbcSpec extends Spec {
val context = io.getquill.context.sql.testContext
import testContext._
import sqlContext.... | fim | zio/zio-quill | scala |
<|fim_suffix|>&& p.firstName == lift("Alex")
} yield p
}
testContext.run(q).collect() should contain theSameElementsAs Seq(peopleList(0))
}
"infix usage must work" in {
val q = quote {
for {
p <- liftQuery(peopleList.toDS()) if p.extraInfo == sql"'?'".as[String] && p.firstName == li... | fim | zio/zio-quill | scala |
<|fim_suffix|> d(0, {}, ())
}
}
}
"query single" in {
val q = quote {
liftQuery(entities.toDS).map(t => t.i).max
}
testContext.run(q).collect.toList mustEqual
List(Some(1))
}
}
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.base.Spec
import io.getquill.{T... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.{IdiomContext, Literal}
import io.getquill.base.Spec
import io.getquill.context.ExecutionType
import io.getquill.norm.SheathLeafClausesApply
import io.getquill.quat.Quat
import io.getquill.util.TraceConfig
class SparkDialectSpec extends Spec {
impo... | fim | zio/zio-quill | scala |
<|fim_suffix|>))
testContext.run(q.nested.nested).collect().toList mustEqual List(
(Data.parent, Data.child.name, Data.grandChild.name)
)
}
}
}
}
<|fim_prefix|>package io.getquill.context.spark
import io.getquill.base.Spec
import io.getquill.util.Messages.QuatTrace
import org.apa... | fim | zio/zio-quill | scala |
package io.getquill.context.spark
import io.getquill.Query
import io.getquill.base.Spec
case class American(firstName: String, lastName: String, addressId: Int)
case class Address1(id: Int, street: String, city: String)
case class HumanoidLivingSomewhere(called: String, alsoCalled: String, whereHeLives_id: Int)
clas... | fim | zio/zio-quill | scala |
<|fim_suffix|> (repo, list) =>
(repo.name, list.size)
}
.sortBy { case (repoName, size) =>
size
}(Ord.desc)
}
println(run(topStargazers).show())
println(run(topProjects).show())
}
<|fim_prefix|>package io.getquill.context.spark.examples
import java.io.File
import java.net.URL
i... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark
import language.postfixOps
import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.DataFrame
import org.apache.spark.sql.functions.{count => fcount, _}
import io.getquill.QuillSparkContext._
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.Datase... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark.norm
import io.getquill.base.Spec
import io.getquill.context.spark.{sqlContext, testContext}
case class Test(i: Int, j: Int, s: String)
case class TestHolder(ta: Test, tb: Test)
case class TestHolderOtherData(ta: Test, otherData: String)
case class TestHolderHolder(tha:... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.spark.norm
import QuestionMarkEscaper._
import io.getquill.base.Spec
class QuestionMarkEscaperSpec extends Spec {
"should escape strings with question marks and even ones with slashes already" in {
escape("foo ? bar \\? baz \\\\?") must equal("foo \\? bar \\\\? baz \\\... | fim | zio/zio-quill | scala |
<|fim_suffix|> .getOrCreate()
sparkSession.sparkContext.setLogLevel("WARN")
implicit val sqlContext = sparkSession.sqlContext
val testContext = QuillSparkContext
}
<|fim_prefix|>package io.getquill.context
import org.apache.spark.sql.SparkSession
import io.getquill.QuillSparkContext
package object spark ... | fim | zio/zio-quill | scala |
<|fim_suffix|><: BaseIdiom, +Naming <: NamingStrategy](idiom: Idiom, naming: Naming)
extends MirrorContext(idiom, naming)
with SqlContext[Idiom, Naming]
with ArrayMirrorEncoding
<|fim_prefix|>package io.getquill
import io.getquill.idiom.{Idiom => BaseIdiom}
import io.getquill.context.sql.SqlContext
import ... | fim | zio/zio-quill | scala |
<|fim_suffix|>licit val localDateDecoder: Decoder[LocalDate]
implicit val uuidDecoder: Decoder[UUID]
implicit val stringEncoder: Encoder[String]
implicit val bigDecimalEncoder: Encoder[BigDecimal]
implicit val booleanEncoder: Encoder[Boolean]
implicit val byteEncoder: Encoder[Byte]
implicit val shortEncode... | fim | zio/zio-quill | scala |
package io.getquill.context.sql.dsl
import io.getquill.Query
import io.getquill.context.sql.SqlContext
//noinspection TypeAnnotation
trait SqlDsl {
this: SqlContext[_, _] =>
implicit final class Like(s1: String) {
def like(s2: String) = quote(sql"$s1 like $s2".pure.asCondition)
}
implicit final class Fo... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.sql.encoding
import java.time.LocalDate
import java.util.Date
import io.getquill.context.sql.SqlContext
import scala.collection.compat._
import scala.language.higherKinds
trait ArrayEncoding {
self: SqlContext[_, _] =>
type CBF[T, Col] = Factory[T, Col]
implicit def... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.sql.encoding.mirror
import java.time.LocalDate
import java.util.Date
import io.getquill.SqlMirrorContext
import io.getquill.context.sql.encoding.ArrayEncoding
trait ArrayMirrorEncoding extends ArrayEncoding {
this: SqlMirrorContext[_, _] =>
implicit def arrayStringEncod... | fim | zio/zio-quill | scala |
<|fim_suffix|>P BY p.name"
}
"work in a for-comprehension" in { // //
case class Address(id: Int, owner: Int, street: String)
case class Furniture(owner: Int, location: Int)
case class PersonInfo(id: Int, maxAge: Int)
import extras._
ctx.run {
for {
a <- query[A... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.base.Spec
import io.getquill.context.ExecutionType
class BatchActionMultiTest extends Spec {
// Need to fully type this otherwise scala compiler thinks it's still just 'Context' from the super-class
// and the extensions (m: MirrorContext[_, _]#BatchActionMirro... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.sql
import io.getquill.context.ExecutionType.Unknown
import io.getquill.context.sql.base.BatchUpdateValuesSpec
import io.getquill.{Literal, PostgresDialect, SnakeCase, SqlMirrorContext}
import io.getquill.context.sql.u<|fim_suffix|>=>
contacts.filter(p => p.firstName =... | fim | zio/zio-quill | scala |
package io.getquill.context.sql
import io.getquill.base.Spec
import io.getquill.context.mirror.Row
import io.getquill.context.sql.testContext._
class BindVariablesSpec extends Spec {
"binds values according to the sql terms order" - {
"drop.take" in {
val q =
quote {
query[TestEntity].d... | fim | zio/zio-quill | scala |
<|fim_suffix|>`Ex 9 DistinctOn With Sort` = quote {
query[Person].map(p => (p.name, p.age % 2)).distinctOn(_._2).sortBy(_._2)(Ord.desc)
}
val `Ex 9 DistinctOn With Sort Result` =
List(("A", 1), ("B", 0))
val `Ex 10 DistinctOn With Applicative Join` = quote {
query[Person]
.join(query[Couple])
... | fim | zio/zio-quill | scala |
package io.getquill.context.sql
import io.getquill._
import io.getquill.base.Spec
class EmbeddedSpec extends Spec {
val ctx = new SqlMirrorContext(MirrorSqlDialect, Literal) with TestEntities
import ctx._
"queries with embedded entities should" - {
"function property inside of nested distinct queries" in ... | fim | zio/zio-quill | scala |
package io.getquill.context.sql
import io.getquill.base.Spec
import java.time
import java.time.{Instant, LocalDate, LocalDateTime, LocalTime, OffsetDateTime, OffsetTime, ZoneId, ZoneOffset, ZonedDateTime}
import java.util.{Date, UUID}
case class EncodingTestType(value: String)
case class Number(value: String) exten... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.sql
import io.getquill.context.sql.testContext._
import io.getquill.Literal
import io.getquill.base.Spec
import io.getquill.context.sql.util.StringOps._
class GroupBySpec extends Spec {
implicit val naming: Literal = new Literal {}
import io.getquill.norm.{DisablePhase, ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import io.getquill.{Literal, MirrorSqlDialect, Query, Sql<|fim_suffix|>S _3 FROM (SELECT p.name AS _1, p.id AS _2_1, foo(p.other, p.other2) AS _2_2, p.other AS _2_3 FROM Person p) AS p"
}
"distinct-on infix example" in {
val q = quote {
query[Per... | fim | zio/zio-quill | scala |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.