feat: add microsecond method to TimestampValue and TimeValue

docs/api/expressions/timestamps.md

@@ -141,6 +141,9 @@ All temporal operations are valid for both scalars and columns.
 ::: ibis.expr.types.temporal._TimeComponentMixin.hour
     options:
       heading_level: 4
+::: ibis.expr.types.temporal._TimeComponentMixin.microsecond
+    options:
+      heading_level: 4
 ::: ibis.expr.types.temporal._TimeComponentMixin.millisecond
     options:
       heading_level: 4

ibis/backends/base/sql/registry/main.py

@@ -338,6 +338,7 @@ def count_star(translator, op):
     ops.ExtractHour: timestamp.extract_field('hour'),
     ops.ExtractMinute: timestamp.extract_field('minute'),
     ops.ExtractSecond: timestamp.extract_field('second'),
+    ops.ExtractMicrosecond: timestamp.extract_field('microsecond'),
     ops.ExtractMillisecond: timestamp.extract_field('millisecond'),
     ops.TimestampTruncate: timestamp.truncate,
     ops.DateTruncate: timestamp.truncate,

ibis/backends/bigquery/registry.py

@@ -679,6 +679,7 @@ def _interval_multiply(t, op):
     ops.ExtractHour: _extract_field("hour"),
     ops.ExtractMinute: _extract_field("minute"),
     ops.ExtractSecond: _extract_field("second"),
+    ops.ExtractMicrosecond: _extract_field("microsecond"),
     ops.ExtractMillisecond: _extract_field("millisecond"),
     ops.Strftime: compiles_strftime,
     ops.StringToTimestamp: compiles_string_to_timestamp,

ibis/backends/clickhouse/compiler/values.py

@@ -1097,6 +1097,12 @@ def _fmt(op, _name: str = _name, **kw):
 
 del _fmt, _name, _op
 
+@translate_val.register(ops.ExtractMicrosecond)
+def _extract_microsecond(op, **kw):
+    arg = translate_val(op.arg, **kw)
+    dtype = serialize(op.output_dtype)
+    return f"CAST(substring(formatDateTime({arg}, '%f'), 1, 3) AS {dtype})"    
+
 
 @translate_val.register(ops.ExtractMillisecond)
 def _extract_millisecond(op, **kw):

ibis/backends/dask/execution/temporal.py

@@ -33,6 +33,7 @@
     execute_day_of_week_index_series,
     execute_day_of_week_name_series,
     execute_epoch_seconds,
+    execute_extract_microsecond_series,
     execute_extract_millisecond_series,
     execute_extract_timestamp_field_series,
     execute_interval_add_multiply_delta_series,
@@ -58,6 +59,7 @@
         (((dd.Series,) + integer_types), execute_timestamp_from_unix)
     ],
     ops.ExtractTemporalField: [((dd.Series,), execute_extract_timestamp_field_series)],
+    ops.ExtractMicrosecond: [((dd.Series,), execute_extract_microsecond_series)],
     ops.ExtractMillisecond: [((dd.Series,), execute_extract_millisecond_series)],
     ops.ExtractEpochSeconds: [((dd.Series,), execute_epoch_seconds)],
     ops.IntervalFromInteger: [((dd.Series,), execute_interval_from_integer_series)],

ibis/backends/impala/tests/snapshots/test_value_exprs/test_timestamp_extract_field/microsecond/out.sql

@@ -0,0 +1 @@
+extract(`i`, 'microsecond')

ibis/backends/impala/tests/test_value_exprs.py

@@ -182,7 +182,7 @@ def test_negate(table, colname, snapshot):
 
 @pytest.mark.parametrize(
     "field",
-    ['year', 'month', 'day', 'hour', 'minute', 'second', 'millisecond'],
+    ['year', 'month', 'day', 'hour', 'minute', 'second', 'microsecond', 'millisecond'],
 )
 def test_timestamp_extract_field(table, field, snapshot):
     expr = getattr(table.i, field)()

ibis/backends/mysql/registry.py

@@ -225,6 +225,9 @@ def compiles_mysql_trim(element, compiler, **kw):
         ops.ExtractDayOfYear: unary(sa.func.dayofyear),
         ops.ExtractEpochSeconds: unary(sa.func.UNIX_TIMESTAMP),
         ops.ExtractWeekOfYear: unary(sa.func.weekofyear),
+        ops.ExtractMicrosecond: fixed_arity(
+            lambda arg: sa.func.floor(sa.extract('microsecond', arg)), 1
+        ),
         ops.ExtractMillisecond: fixed_arity(
             lambda arg: sa.func.floor(sa.extract('microsecond', arg) / 1000), 1
         ),

ibis/backends/pandas/tests/execution/test_temporal.py

@@ -24,6 +24,7 @@
         (lambda v: v.hour(), lambda vt: vt.hour),
         (lambda v: v.minute(), lambda vt: vt.minute),
         (lambda v: v.second(), lambda vt: vt.second),
+        (lambda v: v.microsecond(), lambda vt: int(vt.microsecond)),
         (lambda v: v.millisecond(), lambda vt: int(vt.microsecond / 1e3)),
     ]
     + [

ibis/backends/polars/compiler.py

@@ -895,6 +895,7 @@ def unnest(op, **kw):
     ops.ExtractHour: "hour",
     ops.ExtractMinute: "minute",
     ops.ExtractSecond: "second",
+    ops.ExtractMicrosecond: "microsecond",
     ops.ExtractMillisecond: "millisecond",
 }
 

ibis/backends/pyspark/compiler.py

@@ -1371,6 +1371,11 @@ def compile_extract_second(t, op, **kwargs):
     return _extract_component_from_datetime(t, op, extract_fn=F.second, **kwargs)
 
 
+@compiles(ops.ExtractMicrosecond)
+def compile_extract_microsecond(t, op, **kwargs):
+    return _extract_component_from_datetime(t, op, extract_fn=F.microsecond, **kwargs) 
+
+
 @compiles(ops.ExtractMillisecond)
 def compile_extract_millisecond(t, op, **kwargs):
     raise com.UnsupportedOperationError(

ibis/backends/snowflake/registry.py

@@ -410,6 +410,12 @@ def _map_get(t, op):
         ops.RegexExtract: _regex_extract,
         ops.RegexSearch: fixed_arity(sa.sql.operators.custom_op("REGEXP"), 2),
         ops.RegexReplace: fixed_arity(sa.func.regexp_replace, 3),
+        ops.ExtractMicrosecond: fixed_arity(
+            lambda arg: sa.cast(
+                sa.extract("epoch_microsecond", arg) % 1000000, sa.SMALLINT
+            ),
+            1,
+        ),
         ops.ExtractMillisecond: fixed_arity(
             lambda arg: sa.cast(
                 sa.extract("epoch_millisecond", arg) % 1000, sa.SMALLINT

ibis/backends/sqlite/registry.py

@@ -340,6 +340,9 @@ def _day_of_the_week_name(arg):
         ops.ExtractHour: _strftime_int('%H'),
         ops.ExtractMinute: _strftime_int('%M'),
         ops.ExtractSecond: _strftime_int('%S'),
+        ops.ExtractMicrosecond: fixed_arity(
+            lambda arg: (sa.func.strftime('%f', arg)) % 1000, 1
+        ),
         ops.ExtractMillisecond: fixed_arity(
             lambda arg: (sa.func.strftime('%f', arg) * 1000) % 1000, 1
         ),

ibis/backends/tests/test_temporal.py

@@ -249,6 +249,27 @@ def test_timestamp_extract_literal(con, func, expected):
     assert con.execute(func(value).name("tmp")) == expected
 
 
+@pytest.mark.notimpl(["datafusion", "oracle"], raises=com.OperationNotDefinedError)
+@pytest.mark.broken(
+    ["druid"],
+    raises=AttributeError,
+    reason="'StringColumn' object has no attribute 'microsecond'",
+)
+@pytest.mark.notyet(
+    ["pyspark"],
+    raises=com.UnsupportedOperationError,
+    reason='PySpark backend does not support extracting microseconds.',
+)
+
+@pytest.mark.broken(["sqlite"], raises=AssertionError)
+def test_timestamp_extract_microseconds(backend, alltypes, df):
+    expr = alltypes.timestamp_col.microsecond().name("microsecond")
+    result = expr.execute()
+    expected = backend.default_series_rename(
+        (df.timestamp_col.dt.microsecond).astype('int32')
+    ).rename("microsecond")
+    backend.assert_series_equal(result, expected)
+
 @pytest.mark.notimpl(["datafusion", "oracle"], raises=com.OperationNotDefinedError)
 @pytest.mark.broken(
     ["druid"],
@@ -260,6 +281,7 @@ def test_timestamp_extract_literal(con, func, expected):
     raises=com.UnsupportedOperationError,
     reason='PySpark backend does not support extracting milliseconds.',
 )
+
 @pytest.mark.broken(["sqlite"], raises=AssertionError)
 def test_timestamp_extract_milliseconds(backend, alltypes, df):
     expr = alltypes.timestamp_col.millisecond().name("millisecond")

ibis/expr/decompile.py

@@ -20,6 +20,7 @@
     ops.ExtractDayOfYear: "day_of_year",
     ops.ExtractEpochSeconds: "epoch_seconds",
     ops.ExtractHour: "hour",
+    ops.ExtractMicrosecond: "microsecond",
     ops.ExtractMillisecond: "millisecond",
     ops.ExtractMinute: "minute",
     ops.ExtractMinute: "minute",

ibis/expr/operations/temporal.py

@@ -132,6 +132,11 @@ class ExtractSecond(ExtractTimeField):
     pass
 
 
+@public
+class ExtractMicrosecond(ExtractTimeField):
+    pass
+
+
 @public
 class ExtractMillisecond(ExtractTimeField):
     pass

ibis/expr/types/temporal.py

@@ -128,6 +128,10 @@ def second(self) -> ir.IntegerValue:
         """Extract the second component."""
         return ops.ExtractSecond(self).to_expr()
 
+    def microsecond(self) -> ir.IntegerValue:
+        """Extract the microsecond component."""
+        return ops.ExtractMicrosecond(self).to_expr()
+
     def millisecond(self) -> ir.IntegerValue:
         """Extract the millisecond component."""
         return ops.ExtractMillisecond(self).to_expr()

ibis/tests/expr/test_timestamp.py

@@ -35,6 +35,7 @@ def test_string_cast_to_timestamp(alltypes):
         ('hour', ops.ExtractHour, ir.IntegerColumn),
         ('minute', ops.ExtractMinute, ir.IntegerColumn),
         ('second', ops.ExtractSecond, ir.IntegerColumn),
+        ('microsecond', ops.ExtractMicrosecond, ir.IntegerColumn),
         ('millisecond', ops.ExtractMillisecond, ir.IntegerColumn),
     ],
 )
@@ -131,6 +132,7 @@ def test_timestamp_field_access_on_date(
         ('hour', ops.ExtractHour, ir.IntegerColumn),
         ('minute', ops.ExtractMinute, ir.IntegerColumn),
         ('second', ops.ExtractSecond, ir.IntegerColumn),
+        ('microsecond', ops.ExtractMicrosecond, ir.IntegerColumn),
         ('millisecond', ops.ExtractMillisecond, ir.IntegerColumn),
     ],
 )
@@ -148,6 +150,7 @@ def test_timestamp_field_access_on_date_failure(
         ('hour', ops.ExtractHour, ir.IntegerColumn),
         ('minute', ops.ExtractMinute, ir.IntegerColumn),
         ('second', ops.ExtractSecond, ir.IntegerColumn),
+        ('microsecond', ops.ExtractMicrosecond, ir.IntegerColumn),
         ('millisecond', ops.ExtractMillisecond, ir.IntegerColumn),
     ],
 )