빠르고 정확한 개발자

wsl2 용량 최적화

wefree — Tue, 10 Feb 2026 21:18:44 +0900

wsl 에서 docker 를 사용하고 있다면, wsl 볼륨이 windows 에서 용량을 너무 많이 차지할 수 있다.

특히 C:\Users\USER\AppData\Local\Packages\CanonicalGroupLimited.Ubuntu_79rhkp1fndgsc\LocalState\ext4.vhdx 의 파일이 매우 커질 수 있다.

아래처럼 최적화로 용량을 줄일 수 있다.

wsl --shutdown
Optimize-VHD -Path "C:\Users\USER\AppData\Local\Packages\CanonicalGroupLimited.Ubuntu_79rhkp1fndgsc\LocalState\ext4.vhdx" -Mode Full

DuckDB 에서 PostgreSQL 연결하기

wefree — Fri, 31 Oct 2025 22:20:21 +0900

import duckdb

# (1) DuckDB 연결 — 메모리 또는 파일 DB
con = duckdb.connect()  # 메모리 기반
# 또는
# con = duckdb.connect("mydb.duckdb")  # 파일 기반

# (2) PostgreSQL extension 설치 / 로드 (필요한 경우)
con.execute("INSTALL postgres;")
con.execute("LOAD postgres;")

# (3) PostgreSQL DB를 ATTACH
# 예: 로컬의 PostgreSQL 인스턴스, 기본 스키마 public
con.execute("""
ATTACH 'dbname=postgres user=postgres host=127.0.0.1 port=5432 password=mypassword'
  AS pg_db
  (TYPE postgres)
""")

# (4) 연결된 PostgreSQL 테이블을 쿼리
# 예: pg_db.public.mytable 라는 테이블이 있다면
res = con.execute("SELECT * FROM pg_db.company LIMIT 5").fetchdf()
print(res)

# (5) (선택) PostgreSQL 쪽에 데이터를 쓰기
# con.execute("""
#             INSERT INTO pg_db.new_table (col1, col2)
#             VALUES (1, 'abc')
#             """)

DuckDB 에서 pyspark api 사용하기

wefree — Fri, 31 Oct 2025 22:18:41 +0900

https://duckdb.org/docs/stable/clients/python/spark_api

from duckdb.experimental.spark.sql import SparkSession as session
from duckdb.experimental.spark.sql.functions import lit, col
import pandas as pd

spark = session.builder.getOrCreate()

pandas_df = pd.DataFrame({
    'age': [10, 20, 30]
})

df = spark.createDataFrame(pandas_df)

res = df.select(col('age'))
res.toPandas().head()

각 파티션에서 TaskContext를 사용해 현재 partitionId가져오기

wefree — Fri, 11 Jul 2025 23:00:35 +0900

import org.apache.spark.sql.SparkSession

object PartitionIdTest {
	def main(args: Array[String]): Unit = {
		// TaskId는 Spark에서 작업을 실행할 때 각 작업에 대한 고유한 식별자를 제공합니다.
		// 이 식별자는 Spark의 내부 로깅 및 모니터링에 사용됩니다.
		// SparkContext의 getTaskId() 메서드를 사용하여 현재 작업의 TaskId를 가져올 수 있습니다.

		implicit val spark: SparkSession = SparkSession.builder().appName("TaskIdTest").master("local[*]").getOrCreate()
		import spark.implicits._

		(1 to 10).toDF.repartition(10).foreachPartition { patition =>
			// 각 파티션에서 TaskContext를 사용하여 현재 작업의 TaskId를 가져옵니다.

			val partitionId = org.apache.spark.TaskContext.get().partitionId()
			println(s"Current Partition ID in partition: $partitionId")
		}

		spark.stop()
	}
}

실행 결과

Current Partition ID in partition: 4
Current Partition ID in partition: 6
Current Partition ID in partition: 8
Current Partition ID in partition: 9
Current Partition ID in partition: 0
Current Partition ID in partition: 1
Current Partition ID in partition: 3
Current Partition ID in partition: 2
Current Partition ID in partition: 7
Current Partition ID in partition: 5

라이브러리 형태로 만들기

import org.apache.spark.TaskContext
import org.apache.spark.sql.SparkSession

import java.time.format.DateTimeFormatter
import java.time.{LocalDate, LocalDateTime, ZoneId}

object SparkPartition {
	implicit class SparkPartition(spark: SparkSession) {
		def foreachExecutor(size: Int)(f: Int => Unit): Unit = {
			import spark.implicits._

			(0 until size).toDF.repartition(size).foreachPartition { partition =>
				val id: Int = TaskContext.get().partitionId()

				f(id)
				partition.foreach { _ => Unit }
			}
		}
	}

	def main(args: Array[String]): Unit = {
		implicit val spark: SparkSession = SparkSession.builder()
			.appName("SparkPartition")
			.master("local[*]")
			.getOrCreate()

		spark.foreachExecutor(2) { id =>
			println(s"Partition ID: $id")

			while(true) {
				// Simulate some processing
				val now: String = LocalDateTime.now(ZoneId.of("Asia/Seoul")).format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)
				println(s"$now Processing in partition: $id")
				Thread.sleep(60000L) // Sleep to simulate work
			}
		}

		spark.stop()
	}
}

주식 각 종목의 가장 최근 결과 가져오기

wefree — Sat, 21 Jun 2025 16:38:13 +0900

                SELECT DISTINCT ON (i.code) 
                       i.code, i.date, i.last_actual_price, i.final_predicted_price,
                       i.price_change, i.price_change_percent, i.test_r2, i.volatility, 
                       i.prediction_days, i.last_actual_date,
                       i.train_r2, i.test_mse, i.test_rmse, i.test_mae,
                       c.name as company_name, c.rank, i.model_info
                FROM investment i
                JOIN company c ON i.code = c.code
                ORDER BY i.code, i.date DESC

Dataset 으로 정의된 case class 의 fields 가져오기

wefree — Tue, 10 Jun 2025 21:06:28 +0900

case class PwlLog(
	log_type: String,
	device_type: String,
	event_type: String
)

val fields: Array[String] = classOf[PwlLog].getDeclaredFields.map(_.getName)

spark.read
     ....
     .withColumn("log_type", ...)
     .select(fields.map(col): _*)
     .as[PwlLog]

개발 환경 세팅 & Job 제출

wefree — Mon, 5 May 2025 18:19:33 +0900

docker-compose.yml 로 flink cluster 시작

version: '2'
services:
  jobmanager:
    image: flink:1.18.1-scala_2.12-java17
    ports:
      - "8081:8081"
    command: jobmanager
    environment:
      - |
        FLINK_PROPERTIES=
        jobmanager.rpc.address: jobmanager        
    volumes:
      - /mnt/c:/opt/flink/c

  taskmanager:
    image: flink:1.18.1-scala_2.12-java17
    depends_on:
      - jobmanager
    command: taskmanager
    scale: 1
    environment:
      - |
        FLINK_PROPERTIES=
        jobmanager.rpc.address: jobmanager
        taskmanager.numberOfTaskSlots: 2
    volumes:
      - /mnt/c:/opt/flink/c

아래 명령어로 flink cluster 시작

외부 /mnt/c 위치를 volume mount 해 놓음

docker compose up

container 에 접속

docker exec -it flink-jobmanager-1 /bin/bash

example job 제출

WordCount.java

bin/flink run -c com.github.windbird.WordCountExample WordCount.jar --input wc.txt

Local dashboard 보기

http://localhost:8081/

TypeTag, ClassTag

wefree — Tue, 22 Apr 2025 21:54:13 +0900

TypeTag

import scala.reflect.runtime.universe._

def printType[T: TypeTag](value: T): Unit = {
  println(s"Type: ${typeOf[T]}")
}

printType(42)          // 출력: Type: Int
printType("Hello")     // 출력: Type: String

ClassTag

import scala.reflect.ClassTag

def createArray[T: ClassTag](size: Int): Array[T] = {
  new Array[T](size)
}

val intArray = createArray[Int](5)  // Int 배열 생성
val strArray = createArray[String](5)  // String 배열 생성

Semaphore 를 사용해 최대 maxConcurrent 개의 Future만 실행되도록 제한

wefree — Thu, 13 Mar 2025 10:28:32 +0900

내가 작성

package com.naver.search.web

import java.util.concurrent.Semaphore
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.{Await, Future}

object SemaphoreFutureTest {
	def semFuture[T](f: => T, n: Int): Future[T] = {
		val sem = new Semaphore(n)
		Future {
			try {
				sem.acquire()
				f
			} finally {
				sem.release()
			}
		}
	}

	def f(x: Int): Int = {
		Thread.sleep(1000)
		println(x)
		x * 10
	}


	def main(args: Array[String]): Unit = {
		val futures: Seq[Future[Int]] = (1 to 9).map { x =>
			semFuture(f(x), 2)
		}

		val r: Future[Seq[Int]] = Future.sequence(futures)
		val ints: Seq[Int] = Await.result(r, scala.concurrent.duration.Duration.Inf)
		ints.foreach(println)
	}
}

AI 작성 코드

import scala.concurrent.{Future, ExecutionContext}
import scala.concurrent.duration._
import java.util.concurrent.Semaphore

implicit val ec: ExecutionContext = ExecutionContext.global

def limitConcurrentFutures[T](futures: List[() => Future[T]], maxConcurrent: Int): Future[List[T]] = {
  val semaphore = new Semaphore(maxConcurrent)

  val limitedFutures = futures.map { futureFunc =>
      semaphore.acquire()
      try {
        futureFunc()
      } finally {
        semaphore.release()
      }
  }

  Future.sequence(limitedFutures)
}

// 사용 예제
val tasks: List[() => Future[Int]] = List(
  () => Future { Thread.sleep(1000); 1 },
  () => Future { Thread.sleep(1000); 2 },
  () => Future { Thread.sleep(1000); 3 },
  () => Future { Thread.sleep(1000); 4 }
)

val result: Future[List[Int]] = limitConcurrentFutures(tasks, 2)
result.onComplete(println)

Session Kill

wefree — Mon, 10 Mar 2025 20:45:31 +0900

아래 nGQL 로 session 을 확인 / KILL 할 수 있다.

show SESSIONS;
kill SESSION <sessionId>

그런데 연결된 session 이 너무 많아 하나씩 KILL 하기 힘들 때는 코드를 작성해 진행할 수 있다.

import com.vesoft.nebula.client.graph.SessionPool
import com.vesoft.nebula.client.graph.data.ResultSet

import scala.collection.JavaConverters._

object KillAllSessions {
	def main(args: Array[String]): Unit = {
		val sessionPool: SessionPool = ...
		val resultSet: ResultSet = sessionPool.execute("SHOW SESSIONS;")

		try {
			val sessionIds: Seq[Long] = for {
				row <- resultSet.getRows.asScala
				id = row.getValues.asScala.head.getIVal
			} yield id

			sessionIds.foreach { id =>
				sessionPool.execute(s"KILL SESSION $id;")
				println(s"Killed session $id")
			}
		} finally {
			sessionPool.close()
		}
	}
}