j[\UddlmZddlZddlmZmZmZddlmZm Z ddlm Z ddlm Z ddlmZddlmZdd lmZdd lmZdd lmZmZdd lmZdd lmZmZddlmZddl m!Z!ddl"m#Z#ej$e%5ddl&m'Z'dddn #1swxYwYerkddl(Z(ddl)m*Z*m+Z+m,Z,ddl-m.Z.ddlm/Z/m0Z0m1Z1m2Z2e(j3dkrddlm4Z4nddl5m4Z4ee!ze#ze jze j#e/ze j6ze j7zZ8de9d<dgZ:d*dZ;d+d ZdS)-) annotationsN) TYPE_CHECKINGGenericoverload)_check_for_pandas_check_for_pyarrow)pandas)pyarrow) FrameType)deprecate_renamed_parameter) is_pycapsule)issue_unstable_warning)_get_stack_localsqualified_type_name)wrap_ldf) from_arrow from_pandas) DataFrame) LazyFrame)Series) PySQLContext)Callable CollectionMapping) TracebackType)AnyFinalLiteral TypeAlias) )SelfrCompatibleFrameType SQLContextobjrreturnboolct|p~t|tpit|o%t|tjtjfp4t|o%t|tj tj fS)z2Check if the object can be converted to DataFrame.) r isinstancerrpdrrrpaTable RecordBatch)r%s W/home/longshao/multi-rider-rag/.venv/lib/python3.11/site-packages/polars/sql/context.py_compatible_framer/3s{ S U c9 % % U c " " Qz# bi7P'Q'Q U s # # S 32>8R(S(S rct|ttfr|St|tr&|St |rrt|tjtjfrLtt|x}tr|}|St|s5t|rGt|tj tj fr!t|Sdt|}t!|)z'Return LazyFrame from compatible input.zunrecognised frame type: )r)rrlazyrto_framerr*rr rr+r,r-rr ValueError)r%framemsgs r._ensure_lazyframer7=s0# 9-..xxzz C ||~~""$$$ 3   JsR\294M$N$N  {3///e 8 8 %NN$$Ezz|| c  3$.sRXr~4N$O$O###%%%D*=c*B*BDDoor0) n_objectsnamedall_compatibler8 int | Noner94str | Collection[str] | Callable[[str], bool] | Nonedict[str, Any]c`|rtntttf}t |||S)z5Return compatible frame objects from the local stack.)of_typer8r9)r/rrrr)r:r8r9r?s r._get_frame_localsr@Ps0$2U 9f7UG W  O O OOr0ceZdZUdZded<ded<ded<e dQdd d dRdZe dQdddSdZe dQdddTdZeddd  dUd d d dVd"Zeed d#dWd'Z eedXd)Z eedYd+Z ed d#dYd,Z dZd.Z d[d5Z d\d6Z edd#d]d7Z ed^d8Z ed_d9Z edd#d`d:Z edad;Z edbd<Z edd#dcd?Z d!d#dcd@Z dddDZ dUdEdFdedJZ dUdfdKZdgdNZdhdPZd!S)ir$a  Run SQL queries against DataFrame, LazyFrame, and Series data. .. warning:: This functionality is considered **unstable**, although it is close to being considered stable. It may be changed at any point without it being considered a breaking change. r_ctxtz Final[bool]_eager_executionzlist[set[str]]_tables_scope_stack.F)register_globalseagerselfSQLContext[LazyFrame]frames/Mapping[str, CompatibleFrameType | None] | NonerE bool | intrFLiteral[False] named_framesCompatibleFrameType | Noner&Nonec dSNrGrIrErFrMs r.__init__zSQLContext.__init__o sr0)rESQLContext[DataFrame] Literal[True]c dSrQrRrSs r.rTzSQLContext.__init__yrUr0r'c dSrQrRrSs r.rTzSQLContext.__init__rUr0eager_executionz0.20.31)versionNc Rtdtj|_||_t |pi}|r5t dD]\}}||vr ||vr|||<|s|r,||| |dSdS)u Initialize a new `SQLContext`. .. versionchanged:: 0.20.31 The `eager_execution` parameter was renamed `eager`. Parameters ---------- frames A `{name:frame, ...}` mapping which can include Polars frames *and* pandas DataFrames, Series and pyarrow Table and RecordBatch objects. register_globals Register compatible objects (polars DataFrame, LazyFrame, and Series) found in the globals, automatically mapping their variable name to a table name. To register other objects (pandas/pyarrow data) pass them explicitly, or call the `execute_global` classmethod. If given an integer then only the most recent "n" objects found will be registered. eager If True, returns execution results as `DataFrame` instead of `LazyFrame`. (Note that the query itself is always executed in lazy-mode; this parameter impacts whether :meth:`execute` returns an eager or lazy result frame). **named_frames Named eager/lazy frames, provided as kwargs. Examples -------- >>> lf = pl.LazyFrame({"a": [1, 2, 3], "b": ["x", None, "z"]}) >>> res = pl.SQLContext(frame=lf).execute( ... "SELECT b, a*2 AS two_a FROM frame WHERE b IS NOT NULL" ... ) >>> res.collect() shape: (2, 2) ┌─────┬───────┐ │ b ┆ two_a │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═══════╡ │ x ┆ 2 │ │ z ┆ 6 │ └─────┴───────┘ zY`SQLContext` is considered **unstable**, although it is close to being considered stable.Fr:N) rrnewrBrCdictr@itemsupdate register_many)rGrIrErFrMnamer%s r.rTzSQLContext.__init__sd  g   "%'' %fl##  -.$egg - - cv%%$l*B*B),L&  '\ ' MM, ' ' '   v & & & & & ' 'r0)rFquerystrrcdSrQrRclsrdrFs r.execute_globalzSQLContext.execute_globals Cr0rcdSrQrRrgs r.rizSQLContext.execute_globalsORsr0DataFrame | LazyFramecdSrQrRrgs r.rizSQLContext.execute_globalsRURUr0cttj|dd}td|}||d5}|||cdddS#1swxYwYdS)u Immediately execute a SQL query, automatically registering frame globals. Notes ----- * This convenience method automatically registers all compatible objects in the local stack that are referenced in the query, mapping their variable name to a table name. Note that in addition to polars DataFrame, LazyFrame, and Series this method *also* registers pandas DataFrame, Series, and pyarrow Table and RecordBatch objects. * Instead of calling this classmethod you should consider using `pl.sql`, which will use this code internally. Parameters ---------- query A valid SQL query string. eager If True, returns execution results as `DataFrame` instead of `LazyFrame`. (Note that the query itself is always executed in lazy-mode). Examples -------- >>> import pandas as pd >>> df = pl.LazyFrame({"a": [1, 2, 3], "b": [4, 5, 6]}) >>> df_pandas = pd.DataFrame({"a": [2, 3, 4], "c": [7, 8, 9]}) Join a polars LazyFrame with a pandas DataFrame (note use of the preferred `pl.sql` method, which is equivalent to `SQLContext.execute_global`): >>> pl.sql("SELECT df.*, c FROM df JOIN df_pandas USING(a)").collect() shape: (2, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ 2 ┆ 5 ┆ 7 │ │ 3 ┆ 6 ┆ 8 │ └─────┴─────┴─────┘ FT)include_schemaunique)r:r9)rIrE)rdrFN)setrtable_identifiersr@execute)rhrdrF table_namesrMctxs r.rizSQLContext.execute_globals^  *$     )KPPP S u = = = 9;;U%;88 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9sA''A+.A+SQLContext[FrameType]ct|dg|_|jt||S)zITrack currently registered tables on scope entry; supports nested scopes.rD)getattrrDappendrptablesrGs r. __enter__zSQLContext.__enter__sC#*41F#K#K   ''DKKMM(:(:;;; r0exc_typetype[BaseException] | Noneexc_valBaseException | Noneexc_tbTracebackType | Nonec|t||jz dS)z Unregister any tables created within the given scope on context exit. See Also -------- unregister )namesN) unregisterrpryrDpop)rGr|r~rs r.__exit__zSQLContext.__exit__ sP t{{}}%%(@(D(D(F(FF      r0crt|}d|dt|ddS)Nz)lenryid)rGn_tabless r.__repr__zSQLContext.__repr__1s9t{{}}%%DhDDr$xxDDDDDr0cdSrQrRrGrdrFs r.rrzSQLContext.execute8 Cr0cdSrQrRrs r.rrzSQLContext.execute=rr0cdSrQrRrs r.rrzSQLContext.executeBrr0cdSrQrRrs r.rrzSQLContext.executeGrr0cdSrQrRrs r.rrzSQLContext.executeLrr0cdSrQrRrs r.rrzSQLContext.executeQrr0 bool | NoneLazyFrame | DataFramecdSrQrRrs r.rrzSQLContext.executeVs !$r0ct|j|}|s|jr|n|S)u Parse the given SQL query and execute it against the registered frame data. Parameters ---------- query A valid string SQL query. eager Apply the query eagerly, returning `DataFrame` instead of `LazyFrame`. If unset, the value of the init-time "eager" parameter will be used. Note that the query itself is always executed in lazy-mode; this parameter only impacts the type of the returned frame. Examples -------- Declare frame data and register with a SQLContext: >>> df = pl.DataFrame( ... data=[ ... ("The Godfather", 1972, 6_000_000, 134_821_952, 9.2), ... ("The Dark Knight", 2008, 185_000_000, 533_316_061, 9.0), ... ("Schindler's List", 1993, 22_000_000, 96_067_179, 8.9), ... ("Pulp Fiction", 1994, 8_000_000, 107_930_000, 8.9), ... ("The Shawshank Redemption", 1994, 25_000_000, 28_341_469, 9.3), ... ], ... schema=["title", "release_year", "budget", "gross", "imdb_score"], ... orient="row", ... ) >>> ctx = pl.SQLContext(films=df) Execute a SQL query against the registered frame data: >>> ctx.execute( ... ''' ... SELECT title, release_year, imdb_score ... FROM films ... WHERE release_year > 1990 ... ORDER BY imdb_score DESC ... ''', ... eager=True, ... ) shape: (4, 3) ┌──────────────────────────┬──────────────┬────────────┐ │ title ┆ release_year ┆ imdb_score │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 │ ╞══════════════════════════╪══════════════╪════════════╡ │ The Shawshank Redemption ┆ 1994 ┆ 9.3 │ │ The Dark Knight ┆ 2008 ┆ 9.0 │ │ Schindler's List ┆ 1993 ┆ 8.9 │ │ Pulp Fiction ┆ 1994 ┆ 8.9 │ └──────────────────────────┴──────────────┴────────────┘ Execute a GROUP BY query: >>> ctx.execute( ... ''' ... SELECT ... MAX(release_year / 10) * 10 AS decade, ... SUM(gross) AS total_gross, ... COUNT(title) AS n_films, ... FROM films ... GROUP BY (release_year / 10) -- decade ... ORDER BY total_gross DESC ... ''', ... eager=True, ... ) shape: (3, 3) ┌────────┬─────────────┬─────────┐ │ decade ┆ total_gross ┆ n_films │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ u32 │ ╞════════╪═════════════╪═════════╡ │ 2000 ┆ 533316061 ┆ 1 │ │ 1990 ┆ 232338648 ┆ 3 │ │ 1970 ┆ 134821952 ┆ 1 │ └────────┴─────────────┴─────────┘ )rrBrrrCcollect)rGrdrFress r.rrzSQLContext.execute[sAbtz))%0011!&I$*?Is{{}}}cIr0rcr5r"c|tnt|}|j||j|S)u Register a single frame as a table, using the given name. Parameters ---------- name Name of the table. frame eager/lazy frame to associate with this table name. See Also -------- register_globals register_many unregister Examples -------- >>> df = pl.DataFrame({"hello": ["world"]}) >>> ctx = pl.SQLContext() >>> ctx.register("frame_data", df).execute("SELECT * FROM frame_data").collect() shape: (1, 1) ┌───────┐ │ hello │ │ --- │ │ str │ ╞═══════╡ │ world │ └───────┘ )rr7rBregister_ldf)rGrcr5s r.rzSQLContext.registers=> %} 2CE2J2J D%*--- r0Tr]nr;r:cPt||}||S)u9 Register all frames (lazy or eager) found in the current globals scope. Automatically maps variable names to table names. See Also -------- register register_many unregister Parameters ---------- n Register only the most recent "n" frames. all_compatible Control whether we *also* register pandas DataFrame, Series, and pyarrow Table and RecordBatch objects. If False, only Polars classes are registered with the SQL engine. Examples -------- >>> df1 = pl.DataFrame({"a": [1, 2, 3], "b": ["x", None, "z"]}) >>> df2 = pl.DataFrame({"a": [2, 3, 4], "c": ["t", "w", "v"]}) Register frames directly from variables found in the current globals scope: >>> ctx = pl.SQLContext(register_globals=True) >>> ctx.tables() ['df1', 'df2'] Query using the register variable/frame names >>> ctx.execute( ... "SELECT a, b, c FROM df1 LEFT JOIN df2 USING (a) ORDER BY a DESC" ... ).collect() shape: (3, 3) ┌─────┬──────┬──────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ str │ ╞═════╪══════╪══════╡ │ 3 ┆ z ┆ w │ │ 2 ┆ null ┆ t │ │ 1 ┆ x ┆ null │ └─────┴──────┴──────┘ )r:r8)rI)r@rb)rGrr:rIs r.rEzSQLContext.register_globalss.d#.ANNN!!!000r0c t|pi}|||D]\}}||||S)a Register multiple eager/lazy frames as tables, using the associated names. Parameters ---------- frames A `{name:frame, ...}` mapping. **named_frames Named eager/lazy frames, provided as kwargs. See Also -------- register register_globals unregister Examples -------- >>> lf1 = pl.LazyFrame({"a": [1, 2, 3], "b": ["m", "n", "o"]}) >>> lf2 = pl.LazyFrame({"a": [2, 3, 4], "c": ["p", "q", "r"]}) >>> lf3 = pl.LazyFrame({"a": [3, 4, 5], "b": ["s", "t", "u"]}) >>> lf4 = pl.LazyFrame({"a": [4, 5, 6], "c": ["v", "w", "x"]}) Register multiple frames at once, either by passing in as a dict... >>> ctx = pl.SQLContext().register_many({"tbl1": lf1, "tbl2": lf2}) >>> ctx.tables() ['tbl1', 'tbl2'] ...or using keyword args: >>> ctx.register_many(tbl3=lf3, tbl4=lf4).tables() ['tbl1', 'tbl2', 'tbl3', 'tbl4'] )r_rar`r)rGrIrMrcr5s r.rbzSQLContext.register_manys_Nfl## l###!<<>> ' 'KD% MM$ & & & & r0rstr | Collection[str]ctt|tr|g}|D]}|j||S)a Unregister one or more eager/lazy frames by name. Parameters ---------- names Names of the tables to unregister. Notes ----- You can also control table registration lifetime by using `SQLContext` as a context manager; this can often be more useful when such control is wanted: >>> df0 = pl.DataFrame({"colx": [0, 1, 2]}) >>> df1 = pl.DataFrame({"colx": [1, 2, 3]}) >>> df2 = pl.DataFrame({"colx": [2, 3, 4]}) Frames registered in-scope are automatically unregistered on scope-exit. Note that frames registered on construction will persist through subsequent scopes. >>> # register one frame at construction time, and the other two in-scope >>> with pl.SQLContext(tbl0=df0) as ctx: ... ctx.register_many(tbl1=df1, tbl2=df2).tables() ['tbl0', 'tbl1', 'tbl2'] After scope exit, none of the tables registered in-scope remain: >>> ctx.tables() ['tbl0'] See Also -------- register register_globals register_many Examples -------- >>> df0 = pl.DataFrame({"ints": [9, 8, 7, 6, 5]}) >>> lf1 = pl.LazyFrame({"text": ["a", "b", "c"]}) >>> lf2 = pl.LazyFrame({"misc": ["testing1234"]}) Register with a SQLContext object: >>> ctx = pl.SQLContext(test1=df0, test2=lf1, test3=lf2) >>> ctx.tables() ['test1', 'test2', 'test3'] Unregister one or more of the tables: >>> ctx.unregister(["test1", "test3"]).tables() ['test2'] >>> ctx.unregister("test2").tables() [] )r)rerBr)rGrnms r.rzSQLContext.unregister4sKp eS ! ! GE & &B J ! !" % % % % r0 list[str]cNt|jS)u) Return a list of the registered table names. Notes ----- The :meth:`tables` method will return the same values as the "SHOW TABLES" SQL statement, but as a list instead of a frame. Executing as SQL: >>> frame_data = pl.DataFrame({"hello": ["world"]}) >>> ctx = pl.SQLContext(hello_world=frame_data) >>> ctx.execute("SHOW TABLES", eager=True) shape: (1, 1) ┌─────────────┐ │ name │ │ --- │ │ str │ ╞═════════════╡ │ hello_world │ └─────────────┘ Calling the method: >>> ctx.tables() ['hello_world'] Examples -------- >>> df1 = pl.DataFrame({"hello": ["world"]}) >>> df2 = pl.DataFrame({"foo": ["bar", "baz"]}) >>> ctx = pl.SQLContext(hello_data=df1, foo_bar=df2) >>> ctx.tables() ['foo_bar', 'hello_data'] )sortedrB get_tablesrzs r.ryzSQLContext.tablesrs!Hdj++--...r0).) rGrHrIrJrErKrFrLrMrNr&rO) rGrVrIrJrErKrFrWrMrNr&rO) rGrVrIrJrErKrFr'rMrNr&rOrQ) rIrJrErKrFr'rMrNr&rO)rdrerFrLr&r)rdrerFrWr&r)rdrerFr'r&rk)r&ru)r|r}r~rrrr&rO)r&re)rGrVrdrerFrOr&r)rGrVrdrerFrLr&r)rGrVrdrerFrWr&r)rGrHrdrerFrOr&r)rGrHrdrerFrLr&r)rGrHrdrerFrWr&r)rdrerFrr&r)rcrer5rNr&r")rr;r:r'r&r")rIrJrMrNr&r")rrr&r")r&r)__name__ __module__ __qualname____doc____annotations__rrTr classmethodrir{rrrrrrErbrryrRr0r.r$r$[s!!!!''''CF(+ % XCF(+ XCF(+ X! !2GYOOOCGA'(- A'A'A'A'A'POA'F49[XRRR[XR UUU[XU*/8989898989[89t     "EEEEBEXXXBEXXX25$$$$$X$ 37RJRJRJRJRJRJh!!!!H#31>B313131313131nCG+++++Z<<<<|$/$/$/$/$/$/r0)r%rr&r')r%rr&r)r:r'r8r;r9r<r&r=)? __future__r contextlibtypingrrrpolars._dependenciesrrr r*r r+polars._typingr polars._utils.deprecationr polars._utils.pycapsuler polars._utils.unstablerpolars._utils.variousrrpolars._utils.wraprpolars.convertrrpolars.dataframerpolars.lazyframer polars.seriesrsuppress ImportError polars._plrrsyscollections.abcrrrtypesrrrrr version_infor"typing_extensionsr,r-r#r__all__r/r7r@r$rRr0r.rso""""""" GFFFFFFF------......$$$$$$AAAAAA000000999999HHHHHHHH''''''22222222&&&&&&&&&&&& Z%%))(((((()))))))))))))))JJJ==========######555555555555 7""******      ,  )C.   (   .   .,!BF PPPPPP{/{/{/{/{/#{/{/{/{/{/s:B  BB