text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>package io.getquill.context.cassandra.encoding
import com.datastax.oss.driver.api.core.data.UdtValue
import io.getquill.util.MacroContextExt._
import io.getquill.util.OptionalTypecheck
import scala.collection.mutable.ListBuffer
import scala.reflect.macros.blackbox.{Context => MacroContext}
class UdtEnc... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.contex<|fim_suffix|>t[A], cls: Class[A]) =
udt.setSet(name, v.asJava, cls)
def setScalaMap[K, V](name: String, v: Map[K, V], kcls: Class[K], vcls: Class[V]) =
udt.setMap(name, v.asJava, kcls, vcls)
}
object UdtValueOps {
def apply(udt: UdtValue) = new UdtValueOps(udt)
}
<... | fim | zio/zio-quill | scala |
<|fim_suffix|>import scala.reflect.ClassTag
object ClassTagConversions {
def asClassOf[T](implicit tag: ClassTag[T]): Class[T] = tag.runtimeClass.asInstanceOf[Class[T]]
}
<|fim_prefix|>package io.getquill.context<|fim_middle|>.cassandra.util
<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.util
import com.datastax.oss.driver.shaded.guava.common.util.concurrent.ListenableFuture
import java.util.concurrent.Exe<|fim_suffix|>al {
def asScala(implicit ec: ExecutionContext): Future[A] = {
val promise = Promise[A]()
lf.addListener(
ne... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.util
import io.getquill.util.Messages
object UdtMetaUtils {
/**
* Extracts udt name and keyspace from given path
*
* @param path
* udt path
* @return
* (name, keyspace)
*/
def parse(path: String): (String, Option[String]) = {
val ar... | fim | zio/zio-quill | scala |
<|fim_suffix|>reRow mustEqual Row(2)
}
}
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill.base.Spec
import io.getquill.context.mirror.Row
import io.getquill.context.cassandra.mirrorContext._
class BindVariablesSpec extends Spec {
"binds lifted values" in {
def q(i: Int) =
quote {
... | fim | zio/zio-quill | scala |
package io.getquill.context.cassandra
import io.getquill.base.Spec
class CaseClassQueryCassandraSpec extends Spec {
import testSyncDB._
case class Contact(id: Int, firstName: String, lastName: String, age: Int, addressFk: Int, extraInfo: String)
case class Address(id: Int, street: String, zip: Int, otherExtra... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra
import com.typesafe.config.ConfigFactory
import io.getquill.<|fim_suffix|>aContextConfigSpec extends Spec {
"load default preparedStatementCacheSize if not found in configs" in {
CassandraContextConfig(ConfigFactory.empty()).preparedStatementCacheSize mustBe 10... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill._
import io.getquill.base.Spec
import io.getquill.context.mirror.Row
class CassandraContextMacroSpe<|fim_suffix|>RE i = ?"
mirror.prepareRow mustEqual Row(1)
}
}
"probes queries" in {
val ctx = new CassandraMirrorContextWithQuer... | fim | zio/zio-quill | scala |
<|fim_suffix|>tionReturning("", p, e, "")(ExecutionInfo.unknown, ())).getMessage mustBe
intercept[IllegalStateException](executeBatchActionReturning(Nil, e)(ExecutionInfo.unknown, ())).getMessage
}
"probe" in {
testSyncDB.probe("SELECT * FROM TestEntity") mustBe Success(())
}
"return failed future o... | fim | zio/zio-quill | scala |
<|fim_suffix|>id: Set[Int])
val setFroz = quote(query[SetFrozen])
case class ListFrozen(id: List[Int])
val listFroz = quote(query[ListFrozen])
}
<|fim_prefix|>package <|fim_middle|>io.getquill.context.cassandra
import io.getquill.TestEntities
trait CassandraTestEntities extends TestEntities {
this: Cassandra... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill.MappedEncoding
import io.getquill.base.Spec
import org.scalatest.BeforeAndAfterEach
trait CollectionsSpec extends Spec with BeforeAndAfterEach {
case class StrWrap(x: String)
implicit val encode<|fim_suffix|>ap = MappedEncoding[IntWrap, Int](_... | fim | zio/zio-quill | scala |
<|fim_suffix|>eck here
"external ident sanity check" in {
val t = implicitly[Tokenizer[ExternalIdent]]
t.token(ExternalIdent("TestIdent", Quat.Value)) mustBe StringToken("TestIdent")
}
}
}
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill._
im<|fim_middle|>port io.getquill.id... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill._
import io.getquill.base.Spec
class CqlQuerySpec extends Spec {
import mirrorContext._
"map" - {
"property" in {
val q = quote {
qr1.map(t => t.i)
}
mirrorContext.run(q).string mustEqual
"SELECT i FROM ... | fim | zio/zio-quill | scala |
<|fim_suffix|>syncDB.run(query[DecodeNullTestEntity])
} yield {
result
}
intercept[IllegalStateException] {
await {
result
}
}
}
}
case class DecodeNullTestEntity(id: Int, value: Int)
case class DecodeNullTestWriteEntity(id: Int, value: Option[... | fim | zio/zio-quill | scala |
<|fim_suffix|> for {
_ <- testAsyncDB.run(query[EncodingTestEntity].delete)
_ <- testAsyncDB.run(liftQuery(insertValues).foreach(e => query[EncodingTestEntity].insertValue(e)))
result <- testAsyncDB.run(query[EncodingTestEntity])
} yield {
verify(result)
... | fim | zio/zio-quill | scala |
<|fim_suffix|>o9 = None,
o10 = None
)
)
}
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill.base.Spec
import java.util.{Date, UUID}
import java.time.{Instant, LocalDate}
abstract class EncodingSpecHelper extends Spec {
protected def verify(result: List[EncodingTestEntity]): U... | fim | zio/zio-quill | scala |
<|fim_suffix|>[TestEntity]].map(t => t.i)
}
val n = quote {
sql"${qr1.map(t => t.i)} ALLOW FILTERING".as[Query[TestEntity]]
}
ExpandMappedInfixCassandra(q.ast: Ast) mustEqual n.ast
}
}
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill._
import io.getquill.ast.Ast
import io... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra
import java.time.{Instant, LocalDate}
import java.util.UUID
class ListsEncodingSpec extends CollectionsSpec {
val ctx = testSyncDB
import ctx._
case class ListsEntity(
id: Int,
texts: List[String],
decimals: List[BigDecimal],
bools: List[Boole... | fim | zio/zio-quill | scala |
<|fim_suffix|>Be List(e)
ctx.run(mapFroz.filter(_.id.containsValue(false)).allowFiltering) mustBe Nil
}
override protected def beforeEach(): Unit = {
ctx.run(q.delete)
ctx.run(mapFroz.delete)
}
}
<|fim_prefix|>package io.getquill.context.cassandra
import java.time.temporal.ChronoUnit
import java.tim... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill._
import io.getquill.base.Spec
class PeopleCassandraSpec extends Spec {
import testSyncDB._
case class Person(id: <|fim_suffix|> val entries = List(
Person(1, "Bob", 30),
Person(2, "Gus", 40),
Person(3, "Pet", 20),
... | fim | zio/zio-quill | scala |
package io.getquill.context.cassandra
import scala.concurrent.ExecutionContext.Implicits.global
class QueryResultTypeCassandraAsyncSpec extends QueryResultTypeCassandraSpec {
val context = testAsyncDB
import context._
override def beforeAll = {
await(context.run(deleteAll))
await(context.run(liftQuer... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill.context.cassandra.encoding.Encoders
import io.getquill.context.cassandra.encoding.Decoders
import io.getquill.Ord
import io.getquill.base.Spec
trait QueryResultTypeCassandraSpec extends Spec {
val context: CassandraContext[_] with Encoders with... | fim | zio/zio-quill | scala |
<|fim_suffix|> "take" in {
context.run(take) must contain theSameElementsAs (entries)
}
}
"return single result" - {
"size" in {
context.run(entitySize) mustEqual entries.size
}
"paramlize size" in {
context.run(parametrizedSize(lift(10000))) mustEqual 0
}
}
"io monad" ... | fim | zio/zio-quill | scala |
<|fim_suffix|>= SetsEntity(
1,
Set("c"),
Set(BigDecimal(1.33)),
Set(true),
Set(1, 2),
Set(2, 3),
Set(1f, 3f),
Set(5d),
Set(LocalDate.now()),
Set(Instant.now().truncatedTo(ChronoUnit.MILLIS)), // See https://stackoverflow.com/a/74781779/2431728
Set(UUID.randomUUID())
)
val... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.cluster
import com.datastax.oss.driver.api.core.CqlIdentifier
import com.typesafe.config.ConfigFactory
import io.getquill.base.Spec
import java.util
import scala.jdk.CollectionConverters._
class SessionBuilderSpec extends Spec {
def envAddress = sys.env.get("CAS... | fim | zio/zio-quill | scala |
<|fim_suffix|> e.sortBy(t => t.l).map(t => t.s)
}
mirrorContext.run(q).string mustEqual
"SELECT field_s FROM test_entity ORDER BY l ASC"
}
}
}
}
<|fim_prefix|>package io.getquill.context.cassandra.norm
import io.getquill._
import io.getquill.base.Spec
import io.getquill.cont... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.ops
import io.getquill._
import io.getquill.base.Spec
import io.getquill.context.cassandra.mirrorContext
class CassandraOpsSpec extends Spec {
import mirrorContext._
"query" - {
"allowFiltering" in {
val q = quote {
query[TestEntity].filter(t... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import<|fim_suffix|>DB") with CassandraTestEntities
lazy val testAsyncDB = new CassandraAsyncContext(Literal, "testAsyncDB") with CassandraTestEntities
def await[T](f: Future[T]): T = Await.result(f, Duration.Inf)
}
<|fim_middle|> scala.concurrent.Await
import scala.conc... | fim | zio/zio-quill | scala |
package io.getquill.context.cassandra.udt
import io.getquill.context.cassandra.mirrorContext
class UdtEncodingMirrorContextSpec extends UdtSpec {
import mirrorContext._
"Provide implicit decoders/encoders" - {
"UDT raw columns" in {
implicitly[Decoder[Name]]
implicitly[Encoder[Name]]
}
... | fim | zio/zio-quill | scala |
<|fim_suffix|>e.getKeyspace mustBe CqlIdentifier.fromCql("quill_test_2")
}
"could not find UDT with given name" in {
intercept[IllegalStateException](ctx0.udtValueOf("Whatever")).getMessage mustBe
"Could not find UDT `Whatever` in any keyspace"
}
}
"return udt if it's found in another key... | fim | zio/zio-quill | scala |
<|fim_suffix|>.alias("lastName") mustBe Some("last")
}
}
<|fim_prefix|>package io.getquill.context.cassandra.udt
import io.getquill.context.cassandra.mirrorContext._
class UdtMetaDslSpec extends UdtSpec {
"name" in {
udtMeta[Name]("my_name").name mustBe "my_name"
// allows dynamic renaming
val x: Str... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.udt
import io.getquill.Udt
import io.getquill.base.Spec
trait UdtSpec extends Spec {
case class Name(f<|fim_suffix|> List[String],
sets: Set[Int],
map: Map[Int, String]
) extends Udt
}
<|fim_middle|>irstName: String, lastName: Option[String]) extends Udt... | fim | zio/zio-quill | scala |
<|fim_suffix|>ec: ExecutionContext): Result[T] = {
if (transactional) logger.underlying.warn("Cassandra doesn't support transactions, ignoring `io.transactional`")
super.performIO(io)
}
def streamQuery[T](
fetchSize: Option[Int],
cql: String,
prepare: Prepare = identityPrepare,
extractor: E... | fim | zio/zio-quill | scala |
<|fim_suffix|> }
val `Ex 3 Inline Record Usage expected result` = List(
new Contact(1, "Alex", "Jones", 60, 2, "foo")
)
override def beforeAll = {
await {
testDB.run(query[Contact].delete)
}
await {
testDB.run(query[Address].delete)
}
await {
testDB.run(liftQuery(people... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.pekko
import org.apache.pekko.Done
import io.getquill.context.ExecutionInfo
import scala.util.Try
class CassandraContextSpec extends CassandraPekkoSpec {
import testDB._
"run non-batched action" in {
case class TestEntity(id: Int, s: String, i: Int, l: Long... | fim | zio/zio-quill | scala |
<|fim_suffix|>ssandraTestEntities
override def afterAll(): Unit = {
pekkoSession.close(actorSystem.dispatcher)
TestKit.shutdownActorSystem(actorSystem)
}
}
<|fim_prefix|>package io.getquill.context.cassandra.pekko
import org.apache.pekko.actor.ActorSystem
import org.apache.pekko.stream.Materializer
impor... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.pekko
class DecodeNullSpec extends<|fim_suffix|>on] {
await {
result
}
}
}
case class DecodeNullTestEntity(id: Int, value: Int)
case class DecodeNullTestWriteEntity(id: Int, value: Option[Int])
val insertValue = DecodeNullTestWriteE... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.pekko
import <|fim_suffix|> implicitly[Encoder[LocalDate]]
implicitly[Decoder[LocalDate]]
implicitly[Encoder[Instant]]
implicitly[Decoder[Instant]]
implicitly[Encoder[ZonedDateTime]]
implicitly[Decoder[ZonedDateTime]]
}
"ses... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.pekko
import io.getquill.context.cassandra.CollectionsSpec
import java.time.{Instant, LocalDate}
import java.util.UUID
class ListsEncodingSpec extends CollectionsSpec with CassandraPekkoSpec {
val ctx = testDB
import ctx._
case class ListsEntity(
id: Int... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.pekko
import io.getquill.context.cassandra.CollectionsSpec
import java.time.temporal.ChronoUnit
import java.time.{Instant, LocalDate}
import java.util.UUID
class MapsEncodingSpec extends CollectionsSpec with CassandraPekkoSpec {
val ctx = testDB
import ctx._
... | fim | zio/zio-quill | scala |
package io.getquill.context.cassandra.pekko
import org.apache.pekko.stream.scaladsl.Sink
import io.getquill._
class PeopleCassandraSpec extends CassandraPekkoSpec {
import testDB._
case class Person(id: Int, name: String, age: Int)
val entries = List(
Person(1, "Bob", 30),
Person(2, "Gus", 40),
P... | fim | zio/zio-quill | scala |
<|fim_suffix|>ontain theSameElementsAs (entries)
}
"map" in {
await(context.stream(map).runWith(Sink.seq)) must contain theSameElementsAs (entries.map(_.id))
}
"filter" in {
await(context.stream(filter).runWith(Sink.seq)) mustEqual entries.take(1)
}
"withFilter" in {
await(cont... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.pekko
import io.getquill.context.cassandra.CollectionsSpec
import java.time.temporal.ChronoUnit
import java.time.{Instant, LocalDate}
import java.util.UUID
class SetsEncodingSpec extends CollectionsSpec with CassandraPekkoSpec {
val ctx = testDB
import ctx._
... | fim | zio/zio-quill | scala |
<|fim_suffix|>rstName = MappedEncoding[String, FirstName](FirstName)
implicitly[Encoder[MyName]]
implicitly[Decoder[MyName]]
implicitly[Encoder[List[MyName]]]
implicitly[Decoder[List[MyName]]]
}
}
"Complete examples" - {
import ctx1._
"without meta" in {
case class WithEv... | fim | zio/zio-quill | scala |
<|fim_suffix|>lete and described here:
// https://docs.datastax.com/en/dse/6.0/cql/cql/cql_reference/cql_commands/cqlBatch.html
def executeBatchAction(groups: List[BatchGroup])(info: ExecutionInfo, dc: Runner): CIO[Unit] = simpleBlocking {
for {
env <- ZIO.service[CassandraZioSession]
_ <- {
... | fim | zio/zio-quill | scala |
<|fim_suffix|> )
} yield session)
}
def fromContextConfig(config: CassandraContextConfig): ZLayer[Any, Throwable, CassandraZioSession] =
ZLayer.succeed(config) >>> live
def fromConfig(config: Config) = fromContextConfig(CassandraContextConfig(config))
// Call the by-name constructor for the con... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.cassandrazio
import io.getquill.CassandraZioSession
import scala.util.Try
trait Probing {
def probingSession: Option[CassandraZioSessio<|fim_suffix|>) =>
Try(csession.prepare(statement))
case None =>
Try(())
}
}
<|fim_middle|>n] = None
def probe(statem... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.cassandrazio
import com.datastax.oss.driver.api.core.cql.{BoundStatement, Row}
import io.getquill.context.cassandra.{CassandraRowContext, CqlIdiom}
import io.getquill.context.qzio.ZioContext
import io.getquill.context.{Context, ExecutionInfo}
import io.getquill.util.ContextLogger
impo... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.zio
class DecodeNullSpec extends ZioCassandraSpec {
"no default values when reading null" - {
"stream" in {
import testZioDB._
val writeEntities = quote(querySchema[DecodeNullTestWriteEntity]("DecodeNullTestEntity"))
val ret =
for {
... | fim | zio/zio-quill | scala |
<|fim_suffix|>y(insertValues).foreach(e => query[EncodingTestEntity].insertValue(e)))
result <- testZioDB.run(query[EncodingTestEntity])
} yield {
result
}
val f = result(ret)
verify(f)
}
}
"encodes collections" - {
"stream" in {
import testZioDB._
... | fim | zio/zio-quill | scala |
package io.getquill.context.cassandra.zio
import io.getquill.context.cassandra.QueryResultTypeCassandraSpec
class QueryResultTypeCassandraZioSpec extends ZioCassandraSpec with QueryResultTypeCassandraSpec {
val context = testZioDB
import context._
override def beforeAll = {
super.beforeAll()
result(c... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.zio
import io.getquill.context.cassandra.QueryResultTypeCassandraSpec
import org.scalatest.BeforeAndAfter
class StreamingWithFetchSpec extends ZioCassandraSpec with QueryResultTypeCassandraSpec with BeforeAndAfter {
val context =<|fim_suffix|>B
import context.... | fim | zio/zio-quill | scala |
package io.getquill.context.cassandra.zio
import io.getquill.context.cassandra.udt.UdtSpec
import io.getquill.Udt
class UdtEncodingSessionContextSpec extends UdtSpec with ZioCassandraSpec {
val ctx = testZioDB
"Provide encoding for UDT" - {
import ctx._
"raw" in {
implicitly[Decoder[Name]]
i... | fim | zio/zio-quill | scala |
<|fim_suffix|>Throwable, T]): T =
Unsafe.unsafe { implicit u =>
Runtime.default.unsafe.run(qzio.provideEnvironment(ZEnvironment(pool))).getOrThrow()
}
implicit class ZStreamTestExt[T](stream: ZStream[Any, Throwable, T]) {
def runSyncUnsafe() = result[T](stream)
}
implicit class ZioTestExt[T](q... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.zio.examples
import io.getquill._
import io.getquill.cassandrazio.Quill
import zio.Console.printLine
import zio.{ZIO, ZIOAppDefault, ZLayer}
object IdiomaticApp extends ZIOAppDe<|fim_suffix|>eopleByName("Joe")
_ <- printLine(s"Joes: ${joes}")
} yield ... | fim | zio/zio-quill | scala |
<|fim_suffix|>ote {
query[Person]
}
MyZioPostgresContext
.run(people)
.tap(result => printLine(result.toString))
.provide(zioSessionLayer)
.exitCode
}
}
<|fim_prefix|>package io.getquill.context.cassandra.zio.examples.other
import io.getquill.{CassandraZioContext, _}
import zio.... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra.zio.examples.other
import io.getquill._
import io.getquill.context.qzio.ImplicitSyntax.Implicit
import zio.{ZIO, ZIOAppDefault}
import zio.Console.printLine
import io.getquill.context.qzio.ImplicitSyntax._
object ExampleAppImplicitEnv extends ZIOAppDefault {
obje... | fim | zio/zio-quill | scala |
package io.getquill.context.cassandra.zio.examples.other
import io.getquill.{CassandraZioContext, _}
import zio.{Runtime, Unsafe}
import zio.Console.printLine
object PlainApp {
object MyZioPostgresContext extends CassandraZioContext(Literal)
import MyZioPostgresContext._
case class Person(name: String, age: I... | fim | zio/zio-quill | scala |
<|fim_suffix|>ZioDB = new Quill.Cassandra(Literal, pool) with CassandraTestEntities
}
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill.Literal
import io.getquill.cassandrazio.Quill
import io.getquill.context.cassandra.zio.ZioCassandraSpec.runLayerUnsafe
package object zio {
val pool =... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.dag
import com.typesafe.scalalogging.Logger
import io.getquill.codegen.dag.dag.ClassAncestry
import io.getquill.codegen.util.MapExtensions._
import org.slf4j.LoggerFactory
import scala.language.implicitConversions
import scala.reflect.{ClassTag, classTag}
class DagNode(val c... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.gen
import io.getquill.codegen.model._
import io.getquill.codegen.util.StringUtil.{indent, _}
case class EmitterSettings[TableMeta, ColumnMeta](
caseClassTables: Seq[TableStereotype[TableMeta, ColumnMeta]],
querySchemaTables: Seq[TableStereotype[TableMeta, ColumnMeta]],
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen<|fim_suffix|>erySchema[Person]("ALPHA.PERSON", ...) def bravoPerson =
* querySchema[Person]("BRAVO.PERSON", ...) } }</pre>
*/
def querySchemaNaming: QuerySchemaNaming = `"query"`
def filter(tc: RawSchema[TableMeta, ColumnMeta]): Boolean
def defaultNamespace: Strin... | fim | zio/zio-quill | scala |
<|fim_suffix|>(rawType).replaceFirst("java\\.lang\\.", "")
if (column.nullable) s"Option[${tpe}]" else tpe
}
}
}
def CombinedTableSchemas = new CombinedTableSchemasGen(_, _)
class CombinedTableSchemasGen(
tableColumns: TableStereotype[TableMeta, ColumnMeta],
querySchemaN... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.gen
trait QuerySchema<|fim_suffix|>GeneratorComponents =>
object `"query"` extends QuerySchemaNaming {
override def apply(tm: TableMeta): String = "query"
}
object `[namespace][Table]` extends QuerySchemaNaming {
override def apply(tm: TableMeta): String =
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.gen
import io.getquill.codegen.model._
/**
* Packages stereotyped tables into emitters.
*/
class StereotypePackager[Emitter, TableMeta, ColumnMeta] {
def packageIntoEmitters(
emitterMaker: (EmitterSettings[TableMeta, ColumnMeta]) => Emitter,
packagingStrategy: Pa... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.model
import io.getquill.codegen.util.StringUtil._
sealed trait NameParser {
def generateQuerySchemas: Boolean
def parseColumn(cm: JdbcColumnMeta): String
def parseTable(tm: JdbcTableMeta): String
}
trait LiteralNames extends NameParser {
def generateQuerySchemas ... | fim | zio/zio-quill | scala |
<|fim_suffix|>.dataType)
ColumnFusion(
a.name,
commonAncestor,
a.nullable || b.nullable,
a.meta ++ b.meta
)
}
protected def fuseColumns(
a: Seq[ColumnFusion[ColumnMeta]],
b: Seq[ColumnFusion[ColumnMeta]]
): Seq[ColumnFusion[ColumnMeta]] = {
// join the two sets of colu... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.model
import io.getquill.codegen.util.ScalaLangUtil.escape
trait ByName {
def prefix: String
def namespaceMaker: PackageNamingStrategy.NamespaceMaker
def byName(table: TableStereotype[_, _]) = namespaceMaker(table)
}
seale<|fim_suffix|>
def rawFieldName: String = col... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.model
object PackagingStrategy {
object ByPackageObject {
private def packageByNamespace(prefix: String) = PackageObjectByNamespace(prefix, _.table.namespace)
def Simple(packagePrefix: String = "") =
PackagingStrategy(
GroupByPackage,
packageB... | fim | zio/zio-quill | scala |
package io.getquill.codegen.model
import java.sql.ResultSet
case class RawSchema[T, C](table: T, columns: Seq[C])
trait BasicTableMeta {
def tableSchema: Option[String]
def tableName: String
}
trait BasicColumnMeta {
def columnName: String
}
case class JdbcTableMeta(
tableCat: Option[String],
tableSchema... | fim | zio/zio-quill | scala |
<|fim_suffix|> tables (in the same schema) that we wish to combine it with.
*/
case class TableStereotype[TableMeta, ColumnMeta](
table: TableFusion[TableMeta],
columns: Seq[ColumnFusion[ColumnMeta]]
)
case class TableFusion[TableMeta](
namespace: String,
name: String,
meta: Seq[TableMeta]
)
case class Col... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.model
import io.getquill.codegen.gen.HasBas<|fim_suffix|>r[TableMeta] = TableMeta => String
type Expresser[TableMeta, ColumnMeta] = (RawSchema[TableMeta, ColumnMeta]) => TableStereotype[TableMeta, ColumnMeta]
type Fuser[TableMeta, ColumnMeta] =
(Seq[TableSte... | fim | zio/zio-quill | scala |
<|fim_suffix|>sage) {}
<|fim_prefix|>package io.getquill.codegen.model
sealed trait UnrecognizedTypeStrategy
case object AssumeString extends UnrecognizedTypeStrategy
case object SkipColumn extends UnrecognizedTypeStrategy
case object ThrowTypingError extends UnrecognizedTypeStrategy
// TODO Need to documen... | fim | zio/zio-quill | scala |
<|fim_suffix|> Map[K, V]) extends AnyVal {
def zipOnKeys(o: Map[K, V]): Map[K, (Option[V], Option[V])] = zipMapsOnKeys(m, o)
def zipOnKeysOrdered(o: Map[K, V]): ListMap[K, (Option[V], Option[V])] = zipMapsOnKeysOrdered(m, o)
}
def zipMapsOnKeys[K, V](one: Map[K, V], two: Map[K, V]): Map[K, (Opti... | fim | zio/zio-quill | scala |
<|fim_suffix|>,
"sealed",
"super",
"this",
"throw",
"trait",
"try",
"true",
"type",
"val",
"var",
"while",
"with",
"yield"
)
}
<|fim_prefix|>package io.getquill.codegen.util
object ScalaLangUtil {
def escape(str: String) =
if (isKeyword(str)<|fim_middle|>) s"... | fim | zio/zio-quill | scala |
<|fim_suffix|>eq[String] = seq.filterNot(_.trim == "")
}
}
<|fim_prefix|>package io.getquill.codegen.uti<|fim_middle|>l
object StringSeqUtil {
implicit final class StringSeqExt(private val seq: Seq[String]) extends AnyVal {
def pruneEmpty: S<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_suffix|> case Nil => Nil
}).toArray
)
def unquote: String = str.replaceFirst("^\"", "").replaceFirst("\"$", "")
def trimFront: String = str.dropWhile(_ == '\n')
def notEmpty: Option[String] = if (str.trim == "") None else Some(str)
def inSetNocase(se... | fim | zio/zio-quill | scala |
<|fim_suffix|>Person](...) }
* } }
*
* trait BravoExtensions[+Idiom <: io.getquill.idiom.Idiom, Naming <:
* io.getquill.NamingStrategy] { this:io.getquill.context.Context[Idiom, Naming]
* \=>
*
* trait BravoSchema { object PersonDao { def query = querySchema[Person](...) }
* } }
*
* // Since PersonDao is insi... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.jdbc
import io.getquill.context.jdbc.JdbcContext
import io.getquill.context.sql.idiom.SqlIdiom
import scala.util.{Failure, Success, Try}
object DatabaseTypes {
import io.getquill._
def all: Seq[DatabaseType] = Seq(H2, MySql, SqlServer, Postgres, Sqlite, Oracle)
objec... | fim | zio/zio-quill | scala |
<|fim_suffix|>on), packagePrefix)
def this(config: JdbcContextConfig, packagePrefix: String) =
this(config.dataSource, packagePrefix)
def this(config: Config, packagePrefix: String) = this(JdbcContextConfig(config), packagePrefix)
def this(configPrefix: String, packagePrefix: String) = this(LoadConfig(configP... | fim | zio/zio-quill | scala |
<|fim_suffix|>}
}
override def apply(connectionMaker: JdbcConnectionMaker): Seq[RawSchema[JdbcTableMeta, JdbcColumnMeta]] = {
val tableMap =
extractTables(connectionMaker)
.map(t => ((t.tableCat, t.tableSchema, t.tableName), t))
.toMap
val columns = extractColumns(connectionMaker)
... | fim | zio/zio-quill | scala |
package io.getquill.codegen.jdbc.gen
import io.getquill.codegen.gen.CodeGeneratorComponents
import io.getquill.codegen.jdbc.DatabaseTypes.DatabaseType
import io.getquill.codegen.jdbc.model.JdbcTypes._
import io.getquill.codegen.jdbc.model.{DefaultJdbcTyper, JdbcTypeInfo}
import io.getquill.codegen.model._
trait JdbcC... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.jdbc.gen
import io.getquill.codegen.gen.Generator
import io.get<|fim_suffix|>etquill.codegen.jdbc.model.JdbcStereotyper
import io.getquill.codegen.jdbc.model.JdbcTypes.JdbcConnectionMaker
import io.getquill.codegen.jdbc.util.DiscoverDatabaseType
import io.getquill.codegen.mode... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.jdbc.model
import io.getquill.codegen.model._
import java.sql.Types._
import scala.reflect.{ClassTag, classTag}
class DefaultJdbcTyper(
strategy: UnrecognizedTypeStrategy,
numericPreference: NumericPreference
) extends (JdbcTypeInfo => Option[ClassTag[_]]) {
private[g... | fim | zio/zio-quill | scala |
<|fim_suffix|>,
namespacer: Namespacer[JdbcTableMeta],
typer: JdbcTyper
) extends Expresser[JdbcTableMeta, JdbcColumnMeta] {
override def apply(
schema: RawSchema[JdbcTableMeta, JdbcColumnMeta]
): TableStereotype[JdbcTableMeta, JdbcColumnMeta] = {
val tableModel = TableFusion(
namespacer(schema.ta... | fim | zio/zio-quill | scala |
<|fim_suffix|>jects into expression objects
val expressionTables = schemaTables.map(expresser(_))
// group by the namespaces
val groupedExpressions =
expressionTables.groupBy(tc => (tc.table.namespace, tc.table.name))
// unify expression objects
val unified = groupedExpressions.m... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.jdbc.model
import io.getquill.codegen.model.JdbcColumnMeta
case class <|fim_suffix|>peInfo(jdbcType: Int, size: Int, typeName: Option[String])
object JdbcTypeInfo {
def apply(cs: JdbcColumnMeta): JdbcTypeInfo = JdbcTypeInfo(cs.dataType, cs.size, Some(cs.typeName))
}
<|fim_m... | fim | zio/zio-quill | scala |
package io.getquill.codegen.jdbc.model
import java.sql.Connection
import io.getquill.codegen.model.{JdbcColumnMeta, JdbcTableMeta, RawSchema}
import scala.reflect.ClassTag
object JdbcTypes {
type JdbcConnectionMaker = () => Connection
type JdbcSchemaReader = (JdbcConnectionMaker) => Seq[RawSchema[JdbcTab... | fim | zio/zio-quill | scala |
<|fim_suffix|>w IllegalArgumentException("Could not parse database product name.", e)
}
}
}
<|fim_prefix|>package io.getquill.codegen.jdbc.util
import io.getquill.codegen.jdbc.DatabaseTypes.DatabaseType
import io.getquill.codegen.jdbc.model.JdbcTypes.JdbcConnectionMaker
import io.getquill.util.Using.Manager
im... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen
import java.time.LocalDateTime
import io.getquill.codegen.dag.CatalogBasedAncestry
import org.scalatest.BeforeAndAfter
import org.scalatest.funsuite.AnyFunSuite
import org.scalatest.matchers.should.Matchers._
import scala.reflect.{ClassTag, classTag}
// I.e. something the t... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.codegen
import io.getquill.codegen.util.StringUtil._
import org.scalatest.freespec.AnyFreeSpec
import org.scalatest.matchers.should.Matchers
import scala.reflect.runtime.universe._
import scala.tools.reflect.ToolBox
class SimpleCodegenSpec extends AnyFreeSpec with Matchers {... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen
import io.getquill.codegen.codegen.SimpleCodegenSpec
import io.getquill.codegen.util.StringUtil._
import com.typesafe.scalalogging.Logger
import io.getquill.codegen.model.{CustomNames, SnakeCaseCustomTable, SnakeCaseNames}
import io.getquill.codegen.util.SchemaConfig._
class ... | fim | zio/zio-quill | scala |
package io.getquill.codegen
import java.sql.DriverManager
import io.getquill.codegen.jdbc.gen.JdbcGeneratorBase
import io.getquill.codegen.jdbc.model.JdbcTypes.JdbcQuerySchemaNaming
import io.getquill.codegen.model.Stereotyper.Namespacer
import io.getquill.codegen.model._
import io.getquill.codegen.util.SchemaConfig
... | fim | zio/zio-quill | scala |
<|fim_prefix|>packa<|fim_suffix|>l twoSchema = `schema_snakecase_twoschema_differentcolumns_differenttypes`
}
object CodegenTestCaseRunner {
private val logger = Logger(LoggerFactory.getLogger(this.getClass))
def main(args: Array[String]): Unit = {
val path = args(0)
val prefixes =
if (args.dro... | fim | zio/zio-quill | scala |
<|fim_suffix|>rce,
JdbcContextConfig(
prefix.loadConfig.withValue("dataSource.user", ConfigValueFactory.fromAnyRef("alpha"))
).dataSource,
JdbcContextConfig(
prefix.loadConfig.withValue("dataSource.user", ConfigValueFactory.fromAnyRef("bravo"))
).dataSource
).ma... | fim | zio/zio-quill | scala |
<|fim_suffix|>eed to run a manual query to get tables from alpha/bravo databases if they exist
case SqlServer => {
import io.getquill._
val ctx = new SqlServerJdbcContext[Literal](Literal, ds)
import ctx._
val tables =
ctx.run(
sql"""
(select table... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.util
import java.io.Closeable
import com.typesafe.config.ConfigFactory
import io.getquill.JdbcContextConfig
import javax.sql.DataSource
import OptionOps._
import scala.util.Try
sealed trait ConfigPrefix {
def value: String
def packagePath: String
private[getquill] def... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.util
import scala.uti<|fim_suffix|>s AnyVal {
def andNotEmpty: Option[String] = opt.flatMap(s => if (s.trim.isEmpty) None else Some(s))
}
}
<|fim_middle|>l.{Failure, Success, Try}
object OptionOps {
implicit final class OptExt[T](private val o: Option[T]) extends AnyVa... | fim | zio/zio-quill | scala |
<|fim_suffix|>ce(fileName)).mkString
logger.info("Loaded content: " + content)
content
}
}
object SchemaConfig {
case object `schema_casesensitive` extends SchemaConfig
case object `schema_simple` extends SchemaConfig
ca... | 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.