아마존에서 Amazon Ion 데이터 유형 사용하기 QLDB - Amazon Quantum 원장 데이터베이스(Amazon QLDB)

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

아마존에서 Amazon Ion 데이터 유형 사용하기 QLDB

중요

지원 종료 알림: 기존 고객은 2025년 7월 31일 지원이 종료될 QLDB 때까지 Amazon을 사용할 수 있습니다. 자세한 내용은 아마존 QLDB 원장을 Amazon Aurora SQL Postgre로 마이그레이션을 참조하십시오.

아마존은 데이터를 아마존 이온 형식으로 QLDB 저장합니다. 에서 QLDB 데이터를 사용하려면 지원되는 프로그래밍 언어에 대한 종속 항목으로 Ion 라이브러리를 사용해야 합니다.

이 섹션에서는 데이터를 네이티브 타입에서 해당 타입의 Ion 형식으로 변환하는 방법과 그 반대의 방법을 알아봅니다. 이 참조 안내서는 QLDB 드라이버를 사용하여 QLDB 원장의 Ion 데이터를 처리하는 코드 예제를 보여줍니다. 여기에는 Java, 의 코드 예제가 포함되어 있습니다. NET(C#), Go, Node.js (TypeScript), Python

사전 조건

다음 코드 예제는 이름이 지정된 활성 원장에 연결된 QLDB 드라이버 인스턴스가 있다고 가정합니다. ExampleTable 이 표에는 다음과 같은 8개 필드가 있는 기존 문서 하나가 포함되어 있습니다:

  • ExampleBool

  • ExampleInt

  • ExampleFloat

  • ExampleDecimal

  • ExampleTimestamp

  • ExampleString

  • ExampleBlob

  • ExampleList

참고

이 참조에서는 각 필드에 저장된 형식이 해당 명칭과 일치한다고 가정합니다. 실제로 는 문서 필드에 스키마 또는 데이터 유형 정의를 적용하지 QLDB 않습니다.

부울

다음 코드 예에서는 Ion 부울 타입을 처리하는 방법을 보여줍니다.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); boolean exampleBoolean = driver.execute((txn) -> { // Transforming a Java boolean to Ion boolean aBoolean = true; IonValue ionBool = ionSystem.newBool(aBoolean); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleBool = ?", ionBool); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleBool from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java boolean // Cast IonValue to IonBool first aBoolean = ((IonBool)ionValue).booleanValue(); } // exampleBoolean is now the value fetched from QLDB return aBoolean; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# bool to Ion. bool nativeBool = true; IIonValue ionBool = valueFactory.NewBool(nativeBool); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleBool = ?", ionBool); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleBool from ExampleTable"); }); bool? retrievedBool = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# bool. retrievedBool = ionValue.BoolValue; }
참고

동기 코드로 변환하려면 awaitasync 키워드를 제거하고 IAsyncResult 유형을 IResult로 변경하세요.

Go
exampleBool, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aBool := true // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleBool = ?", aBool) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleBool FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult bool err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleBool is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonBoolean(driver: QldbDriver): Promise<boolean> { return (driver.executeLambda(async (txn: TransactionExecutor) => { // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleBool = ?", true); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleBool FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to a TypeScript Boolean const boolValue: boolean = ionValue.booleanValue(); return boolValue; }) ); }
Python
def update_and_query_ion_bool(txn): # QLDB can take in a Python bool a_bool = True # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleBool = ?", a_bool) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleBool FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python bool is a child class of Python bool a_bool = ion_value # example_bool is now the value fetched from QLDB return a_bool example_bool = driver.execute_lambda(lambda txn: update_and_query_ion_bool(txn))

정수

다음 코드 예에서는 Ion 정수형을 처리하는 방법을 보여줍니다.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); int exampleInt = driver.execute((txn) -> { // Transforming a Java int to Ion int aInt = 256; IonValue ionInt = ionSystem.newInt(aInt); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleInt = ?", ionInt); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleInt from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java int // Cast IonValue to IonInt first aInt = ((IonInt)ionValue).intValue(); } // exampleInt is now the value fetched from QLDB return aInt; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# int to Ion. int nativeInt = 256; IIonValue ionInt = valueFactory.NewInt(nativeInt); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleInt = ?", ionInt); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleInt from ExampleTable"); }); int? retrievedInt = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# int. retrievedInt = ionValue.IntValue; }
참고

동기 코드로 변환하려면 awaitasync 키워드를 제거하고 IAsyncResult 유형을 IResult로 변경하세요.

Go
exampleInt, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aInt := 256 // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleInt = ?", aInt) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleInt FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult int err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleInt is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonInt(driver: QldbDriver): Promise<number> { return (driver.executeLambda(async (txn: TransactionExecutor) => { // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleInt = ?", 256); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleInt FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to a TypeScript Number const intValue: number = ionValue.numberValue(); return intValue; }) ); }
Python
def update_and_query_ion_int(txn): # QLDB can take in a Python int a_int = 256 # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleInt = ?", a_int) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleInt FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python int is a child class of Python int a_int = ion_value # example_int is now the value fetched from QLDB return a_int example_int = driver.execute_lambda(lambda txn: update_and_query_ion_int(txn))

Float

다음 코드 예에서는 Ion 플로트 타입을 처리하는 방법을 보여줍니다.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); float exampleFloat = driver.execute((txn) -> { // Transforming a Java float to Ion float aFloat = 256; IonValue ionFloat = ionSystem.newFloat(aFloat); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleFloat = ?", ionFloat); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleFloat from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java float // Cast IonValue to IonFloat first aFloat = ((IonFloat)ionValue).floatValue(); } // exampleFloat is now the value fetched from QLDB return aFloat; });
.NET

C# 플로트 사용

using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# float to Ion. float nativeFloat = 256; IIonValue ionFloat = valueFactory.NewFloat(nativeFloat); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleFloat = ?", ionFloat); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleFloat from ExampleTable"); }); float? retrievedFloat = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# float. We cast ionValue.DoubleValue to a float // but be cautious, this is a down-cast and can lose precision. retrievedFloat = (float)ionValue.DoubleValue; }
참고

동기 코드로 변환하려면 awaitasync 키워드를 제거하고 IAsyncResult 유형을 IResult로 변경하세요.

C# 더블 사용

using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# double to Ion. double nativeDouble = 256; IIonValue ionFloat = valueFactory.NewFloat(nativeDouble); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleFloat = ?", ionFloat); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleFloat from ExampleTable"); }); double? retrievedDouble = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# double. retrievedDouble = ionValue.DoubleValue; }
참고

동기 코드로 변환하려면 awaitasync 키워드를 제거하고 IAsyncResult 유형을 IResult로 변경하세요.

Go
exampleFloat, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aFloat := float32(256) // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleFloat = ?", aFloat) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleFloat FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { // float64 would work as well var decodedResult float32 err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleFloat is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonFloat(driver: QldbDriver): Promise<number> { return (driver.executeLambda(async (txn: TransactionExecutor) => { // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleFloat = ?", 25.6); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleFloat FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to a TypeScript Number const floatValue: number = ionValue.numberValue(); return floatValue; }) ); }
Python
def update_and_query_ion_float(txn): # QLDB can take in a Python float a_float = float(256) # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleFloat = ?", a_float) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleFloat FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python float is a child class of Python float a_float = ion_value # example_float is now the value fetched from QLDB return a_float example_float = driver.execute_lambda(lambda txn: update_and_query_ion_float(txn))

10진수

다음 코드 예에서는 Ion 10진수 타입을 처리하는 방법을 보여줍니다.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); double exampleDouble = driver.execute((txn) -> { // Transforming a Java double to Ion double aDouble = 256; IonValue ionDecimal = ionSystem.newDecimal(aDouble); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleDecimal = ?", ionDecimal); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleDecimal from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java double // Cast IonValue to IonDecimal first aDouble = ((IonDecimal)ionValue).doubleValue(); } // exampleDouble is now the value fetched from QLDB return aDouble; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# decimal to Ion. decimal nativeDecimal = 256.8723m; IIonValue ionDecimal = valueFactory.NewDecimal(nativeDecimal); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleDecimal = ?", ionDecimal); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleDecimal from ExampleTable"); }); decimal? retrievedDecimal = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# decimal. retrievedDecimal = ionValue.DecimalValue; }
참고

동기 코드로 변환하려면 awaitasync 키워드를 제거하고 IAsyncResult 유형을 IResult로 변경하세요.

Go
exampleDecimal, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aDecimal, err := ion.ParseDecimal("256") if err != nil { return nil, err } // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleDecimal = ?", aDecimal) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleDecimal FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult ion.Decimal err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleDecimal is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonDecimal(driver: QldbDriver): Promise<Decimal> { return (driver.executeLambda(async (txn: TransactionExecutor) => { // Creating a Decimal value. Decimal is an Ion Type with high precision let ionDecimal: Decimal = dom.load("2.5d-6").decimalValue(); // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleDecimal = ?", ionDecimal); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleDecimal FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Get the Ion Decimal ionDecimal = ionValue.decimalValue(); return ionDecimal; }) ); }
참고

를 사용하여 Ion 십진수를 숫자로 ionValue.numberValue() 변환할 수도 있습니다. JavaScript ionValue.numberValue()를 사용하면 성능이 더 좋지만 정확도는 떨어집니다.

Python
def update_and_query_ion_decimal(txn): # QLDB can take in a Python decimal a_decimal = Decimal(256) # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleDecimal = ?", a_decimal) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleDecimal FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python decimal is a child class of Python decimal a_decimal = ion_value # example_decimal is now the value fetched from QLDB return a_decimal example_decimal = driver.execute_lambda(lambda txn: update_and_query_ion_decimal(txn))

Timestamp

다음 코드 예에서는 Ion 타임스탬프 타입을 처리하는 방법을 보여줍니다.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); Date exampleDate = driver.execute((txn) -> { // Transforming a Java Date to Ion Date aDate = new Date(); IonValue ionTimestamp = ionSystem.newUtcTimestamp(aDate); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleTimestamp = ?", ionTimestamp); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleTimestamp from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java Date // Cast IonValue to IonTimestamp first aDate = ((IonTimestamp)ionValue).dateValue(); } // exampleDate is now the value fetched from QLDB return aDate; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; using Amazon.IonDotnet; ... IValueFactory valueFactory = new ValueFactory(); // Convert C# native DateTime to Ion. DateTime nativeDateTime = DateTime.Now; // First convert it to a timestamp object from Ion. Timestamp timestamp = new Timestamp(nativeDateTime); // Then convert to Ion timestamp. IIonValue ionTimestamp = valueFactory.NewTimestamp(timestamp); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleTimestamp = ?", ionTimestamp); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleTimestamp from ExampleTable"); }); DateTime? retrievedDateTime = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# DateTime. retrievedDateTime = ionValue.TimestampValue.DateTimeValue; }
참고

동기 코드로 변환하려면 awaitasync 키워드를 제거하고 IAsyncResult 유형을 IResult로 변경하세요.

Go
exampleTimestamp, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aTimestamp := time.Date(2006, time.May, 20, 12, 30, 0, 0, time.UTC) if err != nil { return nil, err } // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleTimestamp = ?", aTimestamp) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleTimestamp FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult ion.Timestamp err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleTimestamp is now the value fetched from QLDB return decodedResult.GetDateTime(), nil } return nil, result.Err() })
Node.js
async function queryIonTimestamp(driver: QldbDriver): Promise<Date> { return (driver.executeLambda(async (txn: TransactionExecutor) => { let exampleDateTime: Date = new Date(Date.now()); // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleTimestamp = ?", exampleDateTime); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleTimestamp FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to a TypeScript Date exampleDateTime = ionValue.timestampValue().getDate(); return exampleDateTime; }) ); }
Python
def update_and_query_ion_timestamp(txn): # QLDB can take in a Python timestamp a_datetime = datetime.now() # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleTimestamp = ?", a_datetime) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleTimestamp FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python timestamp is a child class of Python datetime a_timestamp = ion_value # example_timestamp is now the value fetched from QLDB return a_timestamp example_timestamp = driver.execute_lambda(lambda txn: update_and_query_ion_timestamp(txn))

String

다음 코드 예에서는 Ion 문자열 타입을 처리하는 방법을 보여줍니다.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); String exampleString = driver.execute((txn) -> { // Transforming a Java String to Ion String aString = "Hello world!"; IonValue ionString = ionSystem.newString(aString); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleString = ?", ionString); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleString from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java String // Cast IonValue to IonString first aString = ((IonString)ionValue).stringValue(); } // exampleString is now the value fetched from QLDB return aString; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Convert C# string to Ion. String nativeString = "Hello world!"; IIonValue ionString = valueFactory.NewString(nativeString); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleString = ?", ionString); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleString from ExampleTable"); }); String retrievedString = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# string. retrievedString = ionValue.StringValue; }
참고

동기 코드로 변환하려면 awaitasync 키워드를 제거하고 IAsyncResult 유형을 IResult로 변경하세요.

Go
exampleString, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aString := "Hello World!" // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleString = ?", aString) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleString FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult string err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleString is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonString(driver: QldbDriver): Promise<string> { return (driver.executeLambda(async (txn: TransactionExecutor) => { // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleString = ?", "Hello World!"); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleString FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to a TypeScript String const stringValue: string = ionValue.stringValue(); return stringValue; }) ); }
Python
def update_and_query_ion_string(txn): # QLDB can take in a Python string a_string = "Hello world!" # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleString = ?", a_string) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleString FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python string is a child class of Python string a_string = ion_value # example_string is now the value fetched from QLDB return a_string example_string = driver.execute_lambda(lambda txn: update_and_query_ion_string(txn))

Blob

다음 코드 예에서는 Ion blob 타입을 처리하는 방법을 보여줍니다.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); byte[] exampleBytes = driver.execute((txn) -> { // Transforming a Java byte array to Ion // Transform any arbitrary data to a byte array to store in QLDB String aString = "Hello world!"; byte[] aByteArray = aString.getBytes(); IonValue ionBlob = ionSystem.newBlob(aByteArray); // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleBlob = ?", ionBlob); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleBlob from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Transforming Ion to a Java byte array // Cast IonValue to IonBlob first aByteArray = ((IonBlob)ionValue).getBytes(); } // exampleBytes is now the value fetched from QLDB return aByteArray; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; using System.Text; ... IValueFactory valueFactory = new ValueFactory(); // Transform any arbitrary data to a byte array to store in QLDB. string nativeString = "Hello world!"; byte[] nativeByteArray = Encoding.UTF8.GetBytes(nativeString); // Transforming a C# byte array to Ion. IIonValue ionBlob = valueFactory.NewBlob(nativeByteArray); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleBlob = ?", ionBlob); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleBlob from ExampleTable"); }); byte[] retrievedByteArray = null; // Assume there is only one document in ExampleTable. await foreach (IIonValue ionValue in selectResult) { // Transforming Ion to a C# byte array. retrievedByteArray = ionValue.Bytes().ToArray(); }
참고

동기 코드로 변환하려면 awaitasync 키워드를 제거하고 IAsyncResult 유형을 IResult로 변경하세요.

Go
exampleBlob, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aBlob := []byte("Hello World!") // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleBlob = ?", aBlob) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleBlob FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult []byte err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleBlob is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonBlob(driver: QldbDriver): Promise<Uint8Array> { return (driver.executeLambda(async (txn: TransactionExecutor) => { const enc = new TextEncoder(); let blobValue: Uint8Array = enc.encode("Hello World!"); // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleBlob = ?", blobValue); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleBlob FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Transforming Ion to TypeScript Uint8Array blobValue = ionValue.uInt8ArrayValue(); return blobValue; }) ); }
Python
def update_and_query_ion_blob(txn): # QLDB can take in a Python byte array a_string = "Hello world!" a_byte_array = str.encode(a_string) # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleBlob = ?", a_byte_array) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleBlob FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python blob is a child class of Python byte array a_blob = ion_value # example_blob is now the value fetched from QLDB return a_blob example_blob = driver.execute_lambda(lambda txn: update_and_query_ion_blob(txn))

나열

다음 코드 예는 Ion 리스트 타입을 처리하는 방법을 보여줍니다.

Java
// Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); List<Integer> exampleList = driver.execute((txn) -> { // Transforming a Java List to Ion List<Integer> aList = new ArrayList<>(); // Add 5 Integers to the List for the sake of example for (int i = 0; i < 5; i++) { aList.add(i); } // Create an empty Ion List IonList ionList = ionSystem.newEmptyList(); // Add the 5 Integers to the Ion List for (Integer i : aList) { // Convert each Integer to Ion ints first to add it to the Ion List ionList.add(ionSystem.newInt(i)); } // Insertion into QLDB txn.execute("UPDATE ExampleTable SET ExampleList = ?", (IonValue) ionList); // Fetching from QLDB Result result = txn.execute("SELECT VALUE ExampleList from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Iterate through the Ion List to map it to a Java List List<Integer> intList = new ArrayList<>(); for (IonValue ionInt : (IonList)ionValue) { // Convert the 5 Ion ints to Java Integers intList.add(((IonInt)ionInt).intValue()); } aList = intList; } // exampleList is now the value fetched from QLDB return aList; });
.NET
using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; using System.Collections.Generic; ... IValueFactory valueFactory = new ValueFactory(); // Transforming a C# list to Ion. IIonValue ionList = valueFactory.NewEmptyList(); foreach (int i in new List<int> {0, 1, 2, 3, 4}) { // Convert to Ion int and add to Ion list. ionList.Add(valueFactory.NewInt(i)); } IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleList = ?", ionList); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleList from ExampleTable"); }); List<int> retrievedList = new List<int>(); await foreach (IIonValue ionValue in selectResult) { // Iterate through the Ion List to map it to a C# list. foreach (IIonValue ionInt in ionValue) { retrievedList.Add(ionInt.IntValue); } }
참고

동기 코드로 변환하려면 awaitasync 키워드를 제거하고 IAsyncResult 유형을 IResult로 변경하세요.

Go
exampleList, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aList := []int{1, 2, 3, 4, 5} // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleList = ?", aList) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleList FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult []int err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleList is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonList(driver: QldbDriver): Promise<number[]> { return (driver.executeLambda(async (txn: TransactionExecutor) => { let listOfNumbers: number[] = [1, 2, 3, 4, 5]; // Updating QLDB await txn.execute("UPDATE ExampleTable SET ExampleList = ?", listOfNumbers); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT VALUE ExampleList FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // Get Ion List const ionList: dom.Value[] = ionValue.elements(); // Iterate through the Ion List to map it to a JavaScript Array let intList: number[] = []; ionList.forEach(item => { // Transforming Ion to a TypeScript Number const intValue: number = item.numberValue(); intList.push(intValue); }); listOfNumbers = intList; return listOfNumbers; }) ); }
Python
def update_and_query_ion_list(txn): # QLDB can take in a Python list a_list = list() for i in range(0, 5): a_list.append(i) # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleList = ?", a_list) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleList FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python blob is a child class of Python list a_list = ion_value # example_list is now the value fetched from QLDB return a_list example_list = driver.execute_lambda(lambda txn: update_and_query_ion_list(txn))

구조체

에서 QLDB struct 데이터 유형은 다른 Ion 유형과 특히 다릅니다. 표에 삽입하는 최상위 문서는 struct 타입이어야 합니다. 문서 필드는 중첩된 struct를 저장할 수도 있습니다.

단순화를 위해 다음 예에서는 ExampleStringExampleInt 필드만 있는 문서를 정의합니다.

Java
class ExampleStruct { public String exampleString; public int exampleInt; public ExampleStruct(String exampleString, int exampleInt) { this.exampleString = exampleString; this.exampleInt = exampleInt; } } // Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); ExampleStruct examplePojo = driver.execute((txn) -> { // Transforming a POJO to Ion ExampleStruct aPojo = new ExampleStruct("Hello world!", 256); // Create an empty Ion struct IonStruct ionStruct = ionSystem.newEmptyStruct(); // Map the fields of the POJO to Ion values and put them in the Ion struct ionStruct.add("ExampleString", ionSystem.newString(aPojo.exampleString)); ionStruct.add("ExampleInt", ionSystem.newInt(aPojo.exampleInt)); // Insertion into QLDB txn.execute("INSERT INTO ExampleTable ?", ionStruct); // Fetching from QLDB Result result = txn.execute("SELECT * from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Map the fields of the Ion struct to Java values and construct a new POJO ionStruct = (IonStruct)ionValue; IonString exampleString = (IonString)ionStruct.get("ExampleString"); IonInt exampleInt = (IonInt)ionStruct.get("ExampleInt"); aPojo = new ExampleStruct(exampleString.stringValue(), exampleInt.intValue()); } // examplePojo is now the document fetched from QLDB return aPojo; });

또는 Jackson 라이브러리를 사용하여 Ion에 데이터 타입을 매핑하거나 Ion에서 데이터 타입을 매핑할 수 있습니다. 라이브러리는 다른 Ion 데이터 타입을 지원하지만 이 예에서는 struct 타입에 초점을 맞춥니다.

class ExampleStruct { public String exampleString; public int exampleInt; @JsonCreator public ExampleStruct(@JsonProperty("ExampleString") String exampleString, @JsonProperty("ExampleInt") int exampleInt) { this.exampleString = exampleString; this.exampleInt = exampleInt; } @JsonProperty("ExampleString") public String getExampleString() { return this.exampleString; } @JsonProperty("ExampleInt") public int getExampleInt() { return this.exampleInt; } } // Instantiate an IonSystem from the Ion library IonSystem ionSystem = IonSystemBuilder.standard().build(); // Instantiate an IonObjectMapper from the Jackson library IonObjectMapper ionMapper = new IonValueMapper(ionSystem); ExampleStruct examplePojo = driver.execute((txn) -> { // Transforming a POJO to Ion ExampleStruct aPojo = new ExampleStruct("Hello world!", 256); IonValue ionStruct; try { // Use the mapper to convert Java objects into Ion ionStruct = ionMapper.writeValueAsIonValue(aPojo); } catch (IOException e) { // Wrap the exception and throw it for the sake of simplicity in this example throw new RuntimeException(e); } // Insertion into QLDB txn.execute("INSERT INTO ExampleTable ?", ionStruct); // Fetching from QLDB Result result = txn.execute("SELECT * from ExampleTable"); // Assume there is only one document in ExampleTable for (IonValue ionValue : result) { // Use the mapper to convert Ion to Java objects try { aPojo = ionMapper.readValue(ionValue, ExampleStruct.class); } catch (IOException e) { // Wrap the exception and throw it for the sake of simplicity in this example throw new RuntimeException(e); } } // examplePojo is now the document fetched from QLDB return aPojo; });
.NET

아마존을 이용하세요. QLDB.Driver.Serialization 라이브러리를 사용하여 네이티브 C# 데이터 유형을 Ion과 매핑하거나 Ion으로부터 네이티브 데이터 유형을 매핑할 수 있습니다. 라이브러리는 다른 Ion 데이터 타입을 지원하지만 이 예에서는 struct 타입에 초점을 맞춥니다.

using Amazon.QLDB.Driver.Generic; using Amazon.QLDB.Driver.Serialization; ... IAsyncQldbDriver driver = AsyncQldbDriver.Builder() .WithLedger("vehicle-registration") // Add Serialization library .WithSerializer(new ObjectSerializer()) .Build(); // Creating a C# POCO. ExampleStruct exampleStruct = new ExampleStruct { ExampleString = "Hello world!", ExampleInt = 256 }; IAsyncResult<ExampleStruct> selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute(txn.Query<Document>("UPDATE ExampleTable SET ExampleStruct = ?", exampleStruct)); // Fetching from QLDB. return await txn.Execute(txn.Query<ExampleStruct>("SELECT VALUE ExampleStruct from ExampleTable")); }); await foreach (ExampleStruct row in selectResult) { Console.WriteLine(row.ExampleString); Console.WriteLine(row.ExampleInt); }
참고

동기 코드로 변환하려면 awaitasync 키워드를 제거하고 IAsyncResult 유형을 IResult로 변경하세요.

또는 Amazon을 사용할 수도 있습니다. IonDotnet.Builders 라이브러리는 Ion 데이터 유형을 처리합니다.

using IAsyncResult = Amazon.QLDB.Driver.IAsyncResult; ... IValueFactory valueFactory = new ValueFactory(); // Creating Ion struct. IIonValue ionStruct = valueFactory.NewEmptyStruct(); ionStruct.SetField("ExampleString", valueFactory.NewString("Hello world!")); ionStruct.SetField("ExampleInt", valueFactory.NewInt(256)); IAsyncResult selectResult = await driver.Execute(async txn => { // Insertion into QLDB. await txn.Execute("UPDATE ExampleTable SET ExampleStruct = ?", ionStruct); // Fetching from QLDB. return await txn.Execute("SELECT VALUE ExampleStruct from ExampleTable"); }); string retrievedString = null; int? retrievedInt = null; await foreach (IIonValue ionValue in selectResult) { retrievedString = ionValue.GetField("ExampleString").StringValue; retrievedInt = ionValue.GetField("ExampleInt").IntValue; }
Go
exampleStruct, err := driver.Execute(context.Background(), func(txn qldbdriver.Transaction) (interface{}, error) { aStruct := map[string]interface{} { "ExampleString": "Hello World!", "ExampleInt": 256, } // Insertion into QLDB _, err = txn.Execute("UPDATE ExampleTable SET ExampleStruct = ?", aStruct) if err != nil { return nil, err } // Fetching from QLDB result, err := txn.Execute("SELECT VALUE ExampleStruct FROM ExampleTable") if err != nil { return nil, err } // Assume there is only one document in ExampleTable if result.Next(txn) { var decodedResult map[string]interface{} err := ion.Unmarshal(result.GetCurrentData(), &decodedResult) if err != nil { return nil, err } // exampleStruct is now the value fetched from QLDB return decodedResult, nil } return nil, result.Err() })
Node.js
async function queryIonStruct(driver: QldbDriver): Promise<any> { let exampleStruct: any = {stringValue: "Hello World!", intValue: 256}; return (driver.executeLambda(async (txn: TransactionExecutor) => { // Inserting into QLDB await txn.execute("INSERT INTO ExampleTable ?", exampleStruct); // Fetching from QLDB const resultList: dom.Value[] = (await txn.execute("SELECT * FROM ExampleTable")).getResultList(); // Assume there is only one document in ExampleTable const ionValue: dom.Value = resultList[0]; // We can get all the keys of Ion struct and their associated values const ionFieldNames: string[] = ionValue.fieldNames(); // Getting key and value of Ion struct to TypeScript String and Number const nativeStringVal: string = ionValue.get(ionFieldNames[0]).stringValue(); const nativeIntVal: number = ionValue.get(ionFieldNames[1]).numberValue(); // Alternatively, we can access to Ion struct fields, using their literal field names: // const nativeStringVal = ionValue.get("stringValue").stringValue(); // const nativeIntVal = ionValue.get("intValue").numberValue(); exampleStruct = {[ionFieldNames[0]]: nativeStringVal, [ionFieldNames[1]]: nativeIntVal}; return exampleStruct; }) ); }
Python
def update_and_query_ion_struct(txn): # QLDB can take in a Python struct a_struct = {"ExampleString": "Hello world!", "ExampleInt": 256} # Insertion into QLDB txn.execute_statement("UPDATE ExampleTable SET ExampleStruct = ?", a_struct) # Fetching from QLDB cursor = txn.execute_statement("SELECT VALUE ExampleStruct FROM ExampleTable") # Assume there is only one document in ExampleTable for ion_value in cursor: # Ion Python struct is a child class of Python struct a_struct = ion_value # example_struct is now the value fetched from QLDB return a_struct example_struct = driver.execute_lambda(lambda txn: update_and_query_ion_struct(txn))

Null 값 및 동적 타입

QLDB공개 콘텐츠를 지원하며 문서 필드에 대한 스키마 또는 데이터 유형 정의를 적용하지 않습니다. 문서에 Ion null 값을 저장할 수도 있습니다. QLDB 위의 모든 예에서는 반환된 각 데이터 타입이 알려져 있고 null이 아니라고 가정합니다. 다음 예에서는 데이터 타입을 알 수 없거나 null일 가능성이 있는 경우 Ion을 사용하는 방법을 보여줍니다.

Java
// Empty variables String exampleString = null; Integer exampleInt = null; // Assume ionValue is some queried data from QLDB IonValue ionValue = null; // Check the value type and assign it to the variable if it is not null if (ionValue.getType() == IonType.STRING) { if (ionValue.isNullValue()) { exampleString = null; } else { exampleString = ((IonString)ionValue).stringValue(); } } else if (ionValue.getType() == IonType.INT) { if (ionValue.isNullValue()) { exampleInt = null; } else { exampleInt = ((IonInt)ionValue).intValue(); } }; // Creating null values IonSystem ionSystem = IonSystemBuilder.standard().build(); // A null value still has an Ion type IonString ionString; if (exampleString == null) { // Specifically a null string ionString = ionSystem.newNullString(); } else { ionString = ionSystem.newString(exampleString); } IonInt ionInt; if (exampleInt == null) { // Specifically a null int ionInt = ionSystem.newNullInt(); } else { ionInt = ionSystem.newInt(exampleInt); } // Special case regarding null! // There is a generic null type which has Ion type 'Null'. // The above null values still have the types 'String' and 'Int' IonValue specialNull = ionSystem.newNull(); if (specialNull.getType() == IonType.NULL) { // This is true! } if (specialNull.isNullValue()) { // This is also true! } if (specialNull.getType() == IonType.STRING || specialNull.getType() == IonType.INT) { // This is false! }
.NET
// Empty variables. string exampleString = null; int? exampleInt = null; // Assume ionValue is some queried data from QLDB. IIonValue ionValue; if (ionValue.Type() == IonType.String) { exampleString = ionValue.StringValue; } else if (ionValue.Type() == IonType.Int) { if (ionValue.IsNull) { exampleInt = null; } else { exampleInt = ionValue.IntValue; } }; // Creating null values. IValueFactory valueFactory = new ValueFactory(); // A null value still has an Ion type. IIonValue ionString = valueFactory.NewString(exampleString); IIonValue ionInt; if (exampleInt == null) { // Specifically a null int. ionInt = valueFactory.NewNullInt(); } else { ionInt = valueFactory.NewInt(exampleInt.Value); } // Special case regarding null! // There is a generic null type which has Ion type 'Null'. IIonValue specialNull = valueFactory.NewNull(); if (specialNull.Type() == IonType.Null) { // This is true! } if (specialNull.IsNull) { // This is also true! }
Go

수렴 제한

Go에서 nil 값을 수렴한 다음 수렴 취소하면 해당 값의 타입이 유지되지 않습니다. nil 값은 Ion null로 수렴되지만, Ion null은 nil이 아닌 값 0으로 수렴 취소됩니다.

ionNull, err := ion.MarshalText(nil) // ionNull is set to ion null if err != nil { return } var result int err = ion.Unmarshal(ionNull, &result) // result unmarshals to 0 if err != nil { return }
Node.js
// Empty variables let exampleString: string; let exampleInt: number; // Assume ionValue is some queried data from QLDB // Check the value type and assign it to the variable if it is not null if (ionValue.getType() === IonTypes.STRING) { if (ionValue.isNull()) { exampleString = null; } else { exampleString = ionValue.stringValue(); } } else if (ionValue.getType() === IonTypes.INT) { if (ionValue.isNull()) { exampleInt = null; } else { exampleInt = ionValue.numberValue(); } } // Creating null values if (exampleString === null) { ionString = dom.load('null.string'); } else { ionString = dom.load.of(exampleString); } if (exampleInt === null) { ionInt = dom.load('null.int'); } else { ionInt = dom.load.of(exampleInt); } // Special case regarding null! // There is a generic null type which has Ion type 'Null'. // The above null values still have the types 'String' and 'Int' specialNull: dom.Value = dom.load("null.null"); if (specialNull.getType() === IonType.NULL) { // This is true! } if (specialNull.getType() === IonType.STRING || specialNull.getType() === IonType.INT) { // This is false! }
Python
# Empty variables example_string = None example_int = None # Assume ion_value is some queried data from QLDB # Check the value type and assign it to the variable if it is not null if ion_value.ion_type == IonType.STRING: if isinstance(ion_value, IonPyNull): example_string = None else: example_string = ion_value elif ion_value.ion_type == IonType.INT: if isinstance(ion_value, IonPyNull): example_int = None else: example_int = ion_value # Creating Ion null values if example_string is None: # Specifically a null string ion_string = loads("null.string") else: # QLDB can take in Python string ion_string = example_string if example_int is None: # Specifically a null int ion_int = loads("null.int") else: # QLDB can take in Python int ion_int = example_int # Special case regarding null! # There is a generic null type which has Ion type 'Null'. # The above null values still have the types 'String' and 'Int' special_null = loads("null.null") if special_null.ion_type == IonType.NULL: # This is true! if special_null.ion_type == IonType.STRING or special_null.ion_type == IonType.INT: # This is false!

로 하향 변환 JSON

애플리케이션에 JSON 호환성이 필요한 경우 Amazon Ion 데이터를 로 하향 변환할 수 있습니다. JSON 그러나 데이터에 존재하지 않는 풍부한 이온 유형을 사용하는 경우 Ion을 변환해도 손실이 발생합니다. JSON JSON

Ion으로의 JSON 변환 규칙에 대한 자세한 내용은 Amazon Ion JSON 쿡북의 하향 변환을 참조하십시오.