reifydb-value 0.6.0

// SPDX-License-Identifier: MIT
// Copyright (c) 2026 ReifyDB

use std::{fmt, ops::Deref};

use serde::{Deserialize, Deserializer, Serialize, Serializer, de, de::Visitor};

pub static ROW_NUMBER_COLUMN_NAME: &str = "rownum";

#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq, Ord, Eq, Hash)]
pub struct RowNumber(pub u64);

impl RowNumber {
	pub fn new(id: u64) -> Self {
		assert!(id > 0, "Row numbers must be greater than 0, got {}", id);
		RowNumber(id)
	}

	pub fn value(&self) -> u64 {
		self.0
	}
}

impl Default for RowNumber {
	fn default() -> Self {
		RowNumber(1)
	}
}

impl Deref for RowNumber {
	type Target = u64;

	fn deref(&self) -> &Self::Target {
		&self.0
	}
}

impl PartialEq<u64> for RowNumber {
	fn eq(&self, other: &u64) -> bool {
		self.0.eq(other)
	}
}

impl From<u64> for RowNumber {
	fn from(id: u64) -> Self {
		assert!(id > 0, "Row numbers must be greater than 0, got {}", id);
		RowNumber(id)
	}
}

impl From<RowNumber> for u64 {
	fn from(row_number: RowNumber) -> Self {
		row_number.0
	}
}

impl fmt::Display for RowNumber {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		write!(f, "{}", self.0)
	}
}

impl Serialize for RowNumber {
	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
	where
		S: Serializer,
	{
		serializer.serialize_u64(self.0)
	}
}

impl<'de> Deserialize<'de> for RowNumber {
	fn deserialize<D>(deserializer: D) -> Result<RowNumber, D::Error>
	where
		D: Deserializer<'de>,
	{
		struct U64Visitor;

		impl Visitor<'_> for U64Visitor {
			type Value = RowNumber;

			fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
				formatter.write_str("an unsigned 64-bit number")
			}

			fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
			where
				E: de::Error,
			{
				if value == 0 {
					Err(E::custom("Row numbers must be greater than 0"))
				} else {
					Ok(RowNumber(value))
				}
			}
		}
		deserializer.deserialize_u64(U64Visitor)
	}
}